codac_Trajectory.h

Go to the documentation of this file.

#ifndef __CODAC_TRAJECTORY_H__
#define __CODAC_TRAJECTORY_H__

#include <map>
#include <list>
#include "codac_DynamicalItem.h"
#include "codac_TFunction.h"
#include "codac_traj_arithmetic.h"

namespace codac
{
  class TFunction;
  class TrajectoryVector;

  enum class TrajDefnType { ANALYTIC_FNC, MAP_OF_VALUES };
  
  class Trajectory : public DynamicalItem
  {
    public:


      Trajectory();

      Trajectory(const Interval& tdomain, const TFunction& f);

      Trajectory(const Interval& tdomain, const TFunction& f, double timestep);

      explicit Trajectory(const std::map<double,double>& m_map_values);

      explicit Trajectory(const std::list<double>& list_t, const std::list<double>& list_x);

      Trajectory(const Trajectory& traj);

      ~Trajectory();

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

      int size() const;

      const Interval tdomain() const;

      TrajDefnType definition_type() const;


      const std::map<double,double>& sampled_map() const;

      const TFunction* tfunction() const;

      const Interval codomain() const;

      double operator()(double t) const;

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

      double first_value() const;

      double last_value() const;


      bool not_defined() const;

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

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


      void set(double y, double t);

      Trajectory& truncate_tdomain(const Interval& tdomain);

      Trajectory& shift_tdomain(double a);

      bool constant_timestep(double& h) const;

      Trajectory& sample(double timestep);

      Trajectory& sample(const Trajectory& x);

      Trajectory& make_continuous();


      const Trajectory primitive(double c = 0.) const;

      const Trajectory primitive(double c, double timestep) const;

      const Trajectory diff() const;

      double finite_diff(double t, double h) const;


      const Trajectory& operator+=(double x);

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

      const Trajectory& operator-=(double x);

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

      const Trajectory& operator*=(double x);

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

      const Trajectory& operator/=(double x);

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


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

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


    protected:

      const IntervalVector codomain_box() const;

      void compute_codomain();

      // Class variables:

        Interval m_tdomain = Interval::EMPTY_SET; 
        Interval m_codomain = Interval::EMPTY_SET; 
        
        // A trajectory is defined either by a TFunction or a map of values
        TrajDefnType m_traj_def_type = TrajDefnType::MAP_OF_VALUES; 

        //union
        //{
          TFunction *m_function = nullptr; 
          std::map<double,double> m_map_values; 
        //};

      friend void deserialize_Trajectory(std::ifstream& bin_file, Trajectory *&traj);
      friend void deserialize_TrajectoryVector(std::ifstream& bin_file, TrajectoryVector *&traj);
  };
}

#endif