codac_Slice.h

Go to the documentation of this file.

 
#ifndef __CODAC_SLICE_H__
#define __CODAC_SLICE_H__
 
#include "codac_Tube.h"
#include "codac_Trajectory.h"
#include "codac_DynamicalItem.h"
#include "codac_ConvexPolygon.h"
#include "codac_TubeTreeSynthesis.h"
#include "codac_BoolInterval.h"
 
namespace codac
{
  #define EPSILON_CONTAINS ibex::next_float(0.) * 1000. 
 
  class Tube;
  class Trajectory;
 
  class Slice : public DynamicalItem
  {
    public:
 
    // Base:
 
 
      explicit Slice(const Interval& tdomain, const Interval& codomain = Interval::ALL_REALS);
 
      Slice(const Slice& x);
 
      ~Slice();
 
      int size() const;
 
      const Slice& operator=(const Slice& x);
 
      const Interval tdomain() const;
 
 
      Slice* prev_slice();
 
      const Slice* prev_slice() const;
 
      Slice* next_slice();
 
      const Slice* next_slice() const;
 
      const Interval input_gate() const;
 
      const Interval output_gate() const;
 
      const ConvexPolygon polygon(const Slice& v) const;
 
 
      const Interval codomain() const;
 
      const IntervalVector box() const;
 
      static double diam(const Interval& interval);
 
      double diam() const;
 
      double volume() const;
 
      const Interval operator()(double t) const;
 
      const Interval operator()(const Interval& t) const;
 
      const std::pair<Interval,Interval> eval(const Interval& t = Interval::ALL_REALS) const;
 
      const Interval interpol(double t, const Slice& v) const;
 
      const Interval interpol(const Interval& t, const Slice& v) const;
 
      const Interval invert(const Interval& y, const Interval& search_tdomain = Interval::ALL_REALS) const;
 
      const Interval invert(const Interval& y, const Slice& v, const Interval& search_tdomain = Interval::ALL_REALS) const;
 
 
      bool operator==(const Slice& x) const;
 
      bool operator!=(const Slice& x) const;
 
      bool is_subset(const Slice& x) const;
 
      bool is_strict_subset(const Slice& x) const;
 
      bool is_interior_subset(const Slice& x) const;
 
      bool is_strict_interior_subset(const Slice& x) const;
 
      bool is_superset(const Slice& x) const;
 
      bool is_strict_superset(const Slice& x) const;
 
      bool is_empty() const;
 
      const BoolInterval contains(const Trajectory& x) const;
 
 
      void set(const Interval& y);
 
      void set_empty();
 
      void set_envelope(const Interval& envelope, bool slice_consistency = true);
 
      void set_input_gate(const Interval& input_gate, bool slice_consistency = true);
 
      void set_output_gate(const Interval& output_gate, bool slice_consistency = true);
 
      const Slice& inflate(double rad);
 
 
      Slice& operator+=(double x);
 
      Slice& operator+=(const Trajectory& x);
 
      Slice& operator+=(const Slice& x);
 
      Slice& operator-=(double x);
 
      Slice& operator-=(const Trajectory& x);
 
      Slice& operator-=(const Slice& x);
 
      Slice& operator*=(double x);
 
      Slice& operator*=(const Trajectory& x);
 
      Slice& operator*=(const Slice& x);
 
      Slice& operator/=(double x);
 
      Slice& operator/=(const Trajectory& x);
 
      Slice& operator/=(const Slice& x);
 
      Slice& operator|=(double x);
 
      Slice& operator|=(const Trajectory& x);
 
      Slice& operator|=(const Slice& x);
 
      Slice& operator&=(double x);
 
      Slice& operator&=(const Trajectory& x);
 
      Slice& operator&=(const Slice& x);
 
 
      const std::string class_name() const { return "Slice"; };
 
      friend std::ostream& operator<<(std::ostream& str, const Slice& x);
      
 
    protected:
 
      void set_tdomain(const Interval& tdomain);
 
      void shift_tdomain(double a);
 
      static void chain_slices(Slice *first_slice, Slice *second_slice);
 
      static void merge_slices(Slice *first_slice, Slice *&second_slice);
 
      const IntervalVector codomain_box() const;
 
      // Class variables:
 
        Interval m_tdomain; 
        Interval m_codomain = Interval::ALL_REALS; 
        Interval *m_input_gate = nullptr, *m_output_gate = nullptr; 
        Slice *m_prev_slice = nullptr, *m_next_slice = nullptr; 
        mutable TubeTreeSynthesis *m_synthesis_reference = nullptr; 
 
      friend class Tube;
      friend class TubeTreeSynthesis;
      friend class CtcEval;
      friend void deserialize_Tube(std::ifstream& bin_file, Tube *&tube);
  };
}
 
#endif