Splines

/*--------------------------------------------------------------------------*\
 |                                                                          |
 |  Copyright (C) 2016                                                      |
 |                                                                          |
 |         , __                 , __                                        |
 |        /|/  \               /|/  \                                       |
 |         | __/ _   ,_         | __/ _   ,_                                |
 |         |   \|/  /  |  |   | |   \|/  /  |  |   |                        |
 |         |(__/|__/   |_/ \_/|/|(__/|__/   |_/ \_/|/                       |
 |                           /|                   /|                        |
 |                           \|                   \|                        |
 |                                                                          |
 |      Enrico Bertolazzi                                                   |
 |      Dipartimento di Ingegneria Industriale                              |
 |      Universita` degli Studi di Trento                                   |
 |      email: enrico.bertolazzi@unitn.it                                   |
 |                                                                          |
\*--------------------------------------------------------------------------*/
 
/*\
 |   ____        _ _            _ ____
 |  / ___| _ __ | (_)_ __   ___/ |  _ \
 |  \___ \| '_ \| | | '_ \ / _ \ | | | |
 |   ___) | |_) | | | | | |  __/ | |_| |
 |  |____/| .__/|_|_|_| |_|\___|_|____/
 |        |_|
\*/
 
namespace Splines {
 
  class Spline1D {
  protected:
 
    #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
    std::string m_name;
    Spline * m_pSpline{nullptr};
 
    #endif
 
  public:
 
    Spline1D( Spline1D const & ) = delete;
    Spline1D const & operator = ( Spline1D const & ) = delete;
 
 
    Spline1D( std::string const & n )
    : m_name(n)
    {}
 
    ~Spline1D()
    {}
 
 
 
 
    string const & name() const { return m_pSpline->name(); }
 
    bool is_closed() const { return m_pSpline->is_closed(); }
 
    void make_closed() { m_pSpline->make_closed(); }
 
    void make_opened() { m_pSpline->make_opened(); }
 
    bool is_bounded() const { return m_pSpline->is_bounded(); }
 
    void make_unbounded() { m_pSpline->make_unbounded();  }
    void make_bounded() { m_pSpline->make_bounded(); }
 
    bool is_extended_constant() const { return m_pSpline->is_extended_constant(); }
    void make_extended_constant() { m_pSpline->make_extended_constant(); }
    void make_extended_not_constant() { m_pSpline->make_extended_not_constant(); }
 
 
 
    integer num_points() const { return m_pSpline->num_points(); }
 
    real_type x_node( integer i ) const { return m_pSpline->x_node(i); }
 
    real_type y_node( integer i ) const { return m_pSpline->y_node(i); }
 
    real_type x_begin() const { return m_pSpline->x_begin(); }
 
    real_type y_begin() const { return m_pSpline->y_begin(); }
 
    real_type x_end() const { return m_pSpline->x_end(); }
 
    real_type y_end() const { return m_pSpline->y_end(); }
 
    void reserve( integer npts ) { return m_pSpline->reserve( npts ); }
 
    void push_back( real_type x, real_type y ) { return m_pSpline->push_back( x, y ); }
    void drop_back() { m_pSpline->drop_back(); }
 
    // must be defined in derived classes
    void build() { m_pSpline->build(); }
 
    void setup( GenericContainer const & gc );
    void build( GenericContainer const & gc ) { setup(gc); }
 
    // must be defined in derived classes
    void
    build(
      SplineType1D tp,
      real_type const x[], integer incx,
      real_type const y[], integer incy,
      integer n
    );
 
    void
    build(
      SplineType1D    tp,
      real_type const x[],
      real_type const y[],
      integer         n
    ) {
      this->build( tp, x, 1, y, 1, n );
    }
 
    void
    build(
      SplineType1D              tp,
      vector<real_type> const & x,
      vector<real_type> const & y
    ) {
      integer n{integer(x.size())};
      this->build( tp, &x.front(), &y.front(), n );
    }
 
    void clear() { m_pSpline->clear(); }
 
    real_type x_min() const { return m_pSpline->x_min(); }
 
    real_type x_max() const { return m_pSpline->x_max(); }
 
    real_type y_min() const { return m_pSpline->y_min(); }
 
    real_type y_max() const { return m_pSpline->y_max(); }
 
    void set_origin( real_type x0 ) { return m_pSpline->set_origin( x0 ); }
 
    void set_range( real_type xmin, real_type xmax ) { return m_pSpline->set_range( xmin, xmax ); }
 
    void
    dump(
      ostream_type & s,
      integer        nintervals,
      char const     header[] = "x\ty"
    ) const {
      m_pSpline->dump( s, nintervals, header );
    }
 
    void
    dump(
      char const fname[],
      integer    nintervals,
      char const header[] = "x\ty"
    ) const {
      m_pSpline->dump( fname, nintervals, header );
    }
 
 
    real_type eval( real_type x ) const { return m_pSpline->eval(x); }
 
    real_type D( real_type x ) const { return m_pSpline->D(x); }
 
    real_type DD( real_type x ) const { return m_pSpline->DD(x); }
 
    real_type DDD( real_type x ) const { return m_pSpline->DDD(x); }
 
    real_type DDDD( real_type x ) const { return m_pSpline->DDDD(x); }
 
    real_type DDDDD( real_type x ) const { return m_pSpline->DDDDD(x); }
 
 
    real_type operator () ( real_type x ) const { return m_pSpline->eval(x); }
 
    real_type eval_D( real_type x ) const { return m_pSpline->D(x); }
 
    real_type eval_DD( real_type x ) const { return m_pSpline->DD(x); }
 
    real_type eval_DDD( real_type x ) const { return m_pSpline->DDD(x); }
 
    real_type eval_DDDD( real_type x ) const { return m_pSpline->DDDD(x); }
 
    real_type eval_DDDDD( real_type x ) const { return m_pSpline->DDDDD(x); }
 
    real_type
    id_eval( integer ni, real_type x ) const { return m_pSpline->id_eval(ni,x); }
 
    real_type
    id_D( integer ni, real_type x ) const { return m_pSpline->id_D(ni,x); }
 
    real_type
    id_DD( integer ni, real_type x ) const { return m_pSpline->id_DD(ni,x); }
 
    real_type
    id_DDD( integer ni, real_type x ) const { return m_pSpline->id_DDD(ni,x); }
 
    real_type
    id_DDDD( integer ni, real_type x ) const { return m_pSpline->id_DDDD(ni,x); }
 
    real_type
    id_DDDDD( integer ni, real_type x ) const { return m_pSpline->id_DDDDD(ni,x); }
 
 
    integer // order
    coeffs(
      real_type cfs[],
      real_type nodes[],
      bool      transpose = false
    ) const {
      return m_pSpline->coeffs( cfs, nodes, transpose );
    }
 
    integer order() const { return m_pSpline->order(); }
 
    void
    write_to_stream( ostream_type & s ) const
    { return m_pSpline->write_to_stream( s ); }
 
    char const *
    type_name() const
    { return m_pSpline->type_name(); }
 
    SplineType1D
    type() const
    { return m_pSpline->type(); }
 
    string
    info() const
    { return m_pSpline->info(); }
 
    void
    info( ostream_type & stream ) const
    { m_pSpline->info( stream ); }
 
    #ifdef SPLINES_BACK_COMPATIBILITY
    integer numPoints() const { return m_pSpline->num_points(); }
    real_type xNode( integer i ) const { return this->x_node(i); }
    real_type yNode( integer i ) const { return this->y_node(i); }
    real_type xBegin() const { return this->x_begin(); }
    real_type yBegin() const { return this->y_begin(); }
    real_type xEnd() const { return this->x_end(); }
    real_type yEnd() const { return this->y_end(); }
    void pushBack( real_type x, real_type y ) { return this->push_back( x, y ); }
    void dropBack() { this->drop_back(); }
    real_type xMin() const { return this->x_min(); }
    real_type xMax() const { return this->x_max(); }
    real_type yMin() const { return this->y_min(); }
    real_type yMax() const { return this->y_max(); }
    void setOrigin( real_type x0 ) { return this->set_origin( x0 ); }
    void setRange( real_type xmin, real_type xmax ) { return this->set_range( xmin, xmax ); }
    #endif
 
  };
 
}
 
// EOF: Spline1D.hxx