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