curve_abc.h

Go to the documentation of this file.

 
#ifndef _STRUCT_CURVE_ABC
#define _STRUCT_CURVE_ABC
 
#include <functional>
#include <memory>
 
#include "MathDefs.h"
#include "serialization/archive.hpp"
#include "serialization/eigen-matrix.hpp"
#include "serialization/registeration.hpp"
 
namespace ndcurves {
 
template <typename T>
bool isApprox(const T a, const T b, const T eps = 1e-6) {
  return fabs(a - b) < eps;
}
 
template <typename Time = double, typename Numeric = Time, bool Safe = false,
          typename Point = Eigen::Matrix<Numeric, Eigen::Dynamic, 1>,
          typename Point_derivate = Point>
struct curve_abc : public serialization::Serializable {
  typedef Point point_t;
  typedef Point_derivate point_derivate_t;
  typedef Time time_t;
  typedef Numeric num_t;
  typedef curve_abc<Time, Numeric, Safe, point_t, point_derivate_t>
      curve_t;  // parent class
  typedef curve_abc<Time, Numeric, Safe, point_derivate_t>
      curve_derivate_t;  // parent class
  typedef std::shared_ptr<curve_t> curve_ptr_t;
 
  /* Constructors - destructors */
 public:
  curve_abc() {}
 
  virtual ~curve_abc() {}
  /* Constructors - destructors */
 
  /*Operations*/
  virtual point_t operator()(const time_t t) const = 0;
 
  virtual curve_derivate_t* compute_derivate_ptr(
      const std::size_t order) const = 0;
 
  virtual point_derivate_t derivate(const time_t t,
                                    const std::size_t order) const = 0;
 
  bool isEquivalent(
      const curve_t* other,
      const Numeric prec = Eigen::NumTraits<Numeric>::dummy_precision(),
      const size_t order = 5) const {
    bool equal = ndcurves::isApprox<num_t>(min(), other->min()) &&
                 ndcurves::isApprox<num_t>(max(), other->max()) &&
                 (dim() == other->dim());
    if (!equal) {
      return false;
    }
    time_t inc =
        (max() - min()) / 10.;  // FIXME : define this step somewhere ??
    // check the value along the two curves
    time_t t = min();
    while (t <= max()) {
      if (!(*this)(t).isApprox(other->operator()(t), prec)) {
        return false;
      }
      t += inc;
    }
    //  check if the derivatives are equal
    for (size_t n = 1; n <= order; ++n) {
      t = min();
      while (t <= max()) {
        if (!derivate(t, n).isApprox(other->derivate(t, n), prec)) {
          return false;
        }
        t += inc;
      }
    }
    return true;
  }
 
  virtual bool isApprox(
      const curve_t* other,
      const Numeric prec =
          Eigen::NumTraits<Numeric>::dummy_precision()) const = 0;
 
  /*Operations*/
 
  /*Helpers*/
  virtual std::size_t dim() const = 0;
  virtual time_t min() const = 0;
  virtual time_t max() const = 0;
  virtual std::size_t degree() const = 0;
 
  std::pair<time_t, time_t> timeRange() { return std::make_pair(min(), max()); }
  /*Helpers*/
 
  // Serialization of the class
  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version) {
    serialization::register_types<Archive>(ar, version);
    if (version) {
      // Do something depending on version ?
    }
  }
};
BOOST_SERIALIZATION_ASSUME_ABSTRACT(curve_abc)
}  // namespace ndcurves
 
DEFINE_CLASS_TEMPLATE_VERSION(
    SINGLE_ARG(typename Time, typename Numeric, bool Safe, typename Point,
               typename Point_derivate),
    SINGLE_ARG(ndcurves::curve_abc<Time, Numeric, Safe, Point, Point_derivate>))
#endif  //_STRUCT_CURVE_ABC