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