codac_TubeVector.h

Go to the documentation of this file.

#ifndef __CODAC_TUBEVECTOR_H__
#define __CODAC_TUBEVECTOR_H__

#include <map>
#include <list>
#include <vector>
#include <initializer_list>
#include "codac_TFnc.h"
#include "codac_TrajectoryVector.h"
#include "codac_tube_arithmetic.h"
#include "codac_serialize_tubes.h"
#include "codac_BoolInterval.h"
#include "codac_TubeSynthesis.h"

namespace codac
{
  class TFnc;
  class Tube;
  class Trajectory;
  
  class TubeVector : public DynamicalItem
  {
    public:


      explicit TubeVector(const Interval& tdomain, int n);

      explicit TubeVector(const Interval& tdomain, const IntervalVector& codomain);

      explicit TubeVector(const Interval& tdomain, double timestep, int n);

      explicit TubeVector(const Interval& tdomain, double timestep, const IntervalVector& codomain);

      explicit TubeVector(const Interval& tdomain, double timestep, const TFnc& f);

      explicit TubeVector(const std::vector<Interval>& v_tdomains, const std::vector<IntervalVector>& v_codomains);

      TubeVector(std::initializer_list<Tube> list);

      TubeVector(const TubeVector& x);

      explicit TubeVector(const TubeVector& x, const IntervalVector& codomain);

      explicit TubeVector(int n, const Tube& x);

      explicit TubeVector(const TrajectoryVector& traj, double timestep);

      explicit TubeVector(const TrajectoryVector& lb, const TrajectoryVector& ub, double timestep);

      explicit TubeVector(const std::string& binary_file_name);

      explicit TubeVector(const std::string& binary_file_name, TrajectoryVector *&traj);

      ~TubeVector();

      int size() const;

      void resize(int n);

      const TubeVector subvector(int start_index, int end_index) const;

      void put(int start_index, const TubeVector& subvec);

      const TubeVector primitive() const;

      const TubeVector primitive(const IntervalVector& c) const;

      const TubeVector& operator=(const TubeVector& x);

      const Interval tdomain() const;

      const TrajectoryVector lb() const;

      const TrajectoryVector ub() const;


      int nb_slices() const;

      int time_to_index(double t) const;

      void sample(double t);

      void sample(double t, const IntervalVector& gate);

      void sample(const Tube& x);

      void sample(const TubeVector& x);


      const IntervalVector codomain() const;

      double volume() const;

      Tube& operator[](int index);

      const Tube& operator[](int index) const;

      const IntervalVector operator()(int slice_id) const;

      const IntervalVector operator()(double t) const;

      const IntervalVector operator()(const Interval& t) const;

      const std::pair<IntervalVector,IntervalVector> eval(const Interval& t = Interval::ALL_REALS) const;
      
      const IntervalVector interpol(double t, const TubeVector& v) const;

      const IntervalVector interpol(const Interval& t, const TubeVector& v) const;

      const Interval invert(const IntervalVector& y, const Interval& search_tdomain = Interval::ALL_REALS) const;

      void invert(const IntervalVector& y, std::vector<Interval> &v_t, const Interval& search_tdomain = Interval::ALL_REALS) const;

      const Interval invert(const IntervalVector& y, const TubeVector& v, const Interval& search_tdomain = Interval::ALL_REALS) const;

      void invert(const IntervalVector& y, std::vector<Interval> &v_t, const TubeVector& v, const Interval& search_tdomain = Interval::ALL_REALS) const;

      const TrajectoryVector diam(bool gates_thicknesses = false) const;

      const TrajectoryVector diam(const TubeVector& v) const;
      
      const Vector max_diam() const;

      double max_gate_diam(double& t) const;

      const Slice* steepest_slice() const;
      
      const Trajectory diag(bool gates_diag = false) const;

      const Trajectory diag(int start_index, int end_index, bool gates_diag = false) const;


      bool operator==(const TubeVector& x) const;

      bool operator!=(const TubeVector& x) const;

      bool is_subset(const TubeVector& x) const;

      bool is_strict_subset(const TubeVector& x) const;

      bool is_interior_subset(const TubeVector& x) const;

      bool is_strict_interior_subset(const TubeVector& x) const;

      bool is_superset(const TubeVector& x) const;

      bool is_strict_superset(const TubeVector& x) const;

      bool is_empty() const;

      const BoolInterval contains(const TrajectoryVector& x) const;

      bool overlaps(const TubeVector& x, float ratio = 1.) const;


      const TubeVector& set(const IntervalVector& y);

      const TubeVector& set(const IntervalVector& y, int slice_id);

      const TubeVector& set(const IntervalVector& y, double t);

      const TubeVector& set(const IntervalVector& y, const Interval& t);

      const TubeVector& set_empty();

      const TubeVector& inflate(double rad);

      const TubeVector& inflate(const Vector& rad);

      const TubeVector& inflate(const TrajectoryVector& rad);

      TubeVector& truncate_tdomain(const Interval& tdomain);

      void shift_tdomain(double a);


      const std::pair<TubeVector,TubeVector> bisect(double t, float ratio = 0.49) const;

      const std::pair<TubeVector,TubeVector> bisect(double t, int dim, float ratio = 0.49) const;


      const TubeVector& operator+=(const Interval& x);

      const TubeVector& operator+=(const Trajectory& x);

      const TubeVector& operator+=(const Tube& x);

      const TubeVector& operator+=(const IntervalVector& x);

      const TubeVector& operator+=(const TrajectoryVector& x);

      const TubeVector& operator+=(const TubeVector& x);

      const TubeVector& operator-=(const Interval& x);

      const TubeVector& operator-=(const Trajectory& x);

      const TubeVector& operator-=(const Tube& x);

      const TubeVector& operator-=(const IntervalVector& x);

      const TubeVector& operator-=(const TrajectoryVector& x);

      const TubeVector& operator-=(const TubeVector& x);

      const TubeVector& operator*=(const Interval& x);

      const TubeVector& operator*=(const Trajectory& x);

      const TubeVector& operator*=(const Tube& x);

      const TubeVector& operator/=(const Interval& x);

      const TubeVector& operator/=(const Trajectory& x);

      const TubeVector& operator/=(const Tube& x);

      const TubeVector& operator|=(const IntervalVector& x);

      const TubeVector& operator|=(const TrajectoryVector& x);

      const TubeVector& operator|=(const TubeVector& x);

      const TubeVector& operator&=(const IntervalVector& x);

      const TubeVector& operator&=(const TrajectoryVector& x);

      const TubeVector& operator&=(const TubeVector& x);


      const std::string class_name() const { return "TubeVector"; };

      friend std::ostream& operator<<(std::ostream& str, const TubeVector& x);


      void enable_synthesis(SynthesisMode mode = SynthesisMode::BINARY_TREE, double eps = 1.e-3) const;


      const IntervalVector integral(double t) const;

      const IntervalVector integral(const Interval& t) const;

      const IntervalVector integral(const Interval& t1, const Interval& t2) const;

      const std::pair<IntervalVector,IntervalVector> partial_integral(const Interval& t) const;

      const std::pair<IntervalVector,IntervalVector> partial_integral(const Interval& t1, const Interval& t2) const;


      void serialize(const std::string& binary_file_name = "x.tube", int version_number = SERIALIZATION_VERSION) const;

      void serialize(const std::string& binary_file_name, const TrajectoryVector& traj, int version_number = SERIALIZATION_VERSION) const;


      static bool same_slicing(const TubeVector& x1, const Tube& x2);

      static bool same_slicing(const TubeVector& x1, const TubeVector& x2);
      
      static const TubeVector hull(const std::list<TubeVector>& l_tubes);

    protected:

      TubeVector();

      const IntervalVector codomain_box() const;

      void deserialize(const std::string& binary_file_name, TrajectoryVector *&traj);

      // Class variables:

        int m_n = 0; 
        Tube *m_v_tubes = nullptr; 

      friend void deserialize_TubeVector(std::ifstream& bin_file, TubeVector *&tube);
  };
}

#endif