cubic_spline.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef ECL_GEOMETRY_CUBIC_SPLINE_HPP_
#define ECL_GEOMETRY_CUBIC_SPLINE_HPP_
 
/*****************************************************************************
** Includes
*****************************************************************************/
 
#include "polynomial.hpp"
#include <ecl/config/macros.hpp>
#include <ecl/concepts/macros.hpp>
#include <ecl/concepts/streams.hpp>
#include <ecl/concepts/containers.hpp>
#include <ecl/containers/array.hpp>
#include <ecl/exceptions/standard_exception.hpp>
#include <ecl/utilities/blueprints.hpp>
 
/*****************************************************************************
** Namespaces
*****************************************************************************/
 
namespace ecl {
 
/*****************************************************************************
** Forward Declarations
*****************************************************************************/
 
class CubicSpline;
 
namespace blueprints {
 
class C2CubicSpline;
class DerivativeHeuristicCubicSpline;
 
} // namespace blueprints
 
/*****************************************************************************
** BluePrintFactory
*****************************************************************************/
template<>
class ECL_PUBLIC BluePrintFactory< CubicSpline > {
    public:
        static blueprints::C2CubicSpline Natural(const Array<double>& x_set, const Array<double>& y_set);
        static blueprints::C2CubicSpline ContinuousDerivatives(
                const Array<double>& x_set, const Array<double>& y_set, const double ydot_0, const double ydot_f);
        static blueprints::DerivativeHeuristicCubicSpline DerivativeHeuristic(
                const Array<double>& x_set, const Array<double>& y_set, const double ydot_0, const double ydot_f);
 
        virtual ~BluePrintFactory() {}
};
 
/*****************************************************************************
** Interface [CubicSpline]
*****************************************************************************/
class ECL_PUBLIC CubicSpline : public BluePrintFactory< CubicSpline > {
    public:
        /******************************************
        ** Constructors
        *******************************************/
        CubicSpline () {};
        template<typename Derived>
        CubicSpline(const BluePrint< Derived > &blueprint) {
            blueprint.implementApply(*this);
        }
        virtual ~CubicSpline () {};
 
        /******************************************
        ** Access
        *******************************************/
        friend class blueprints::DerivativeHeuristicCubicSpline;
        friend class blueprints::C2CubicSpline;
        double operator()(const double &x) const;
        double derivative(double x) const;
        double dderivative(double x) const;
 
        const Array<double>& domain() { return discretised_domain; }
        const Array<CubicPolynomial>& polynomials() { return cubic_polynomials; }
 
        /******************************************
        ** Streaming
        *******************************************/
        template <typename OutputStream>
        friend OutputStream& operator << (OutputStream &ostream, const CubicSpline &cubic_spline);
 
    private:
        Array<double> discretised_domain;      // N+1 x_i's
        // Would normally use pointers here, but the polynomials have fixed storage
        // size, the copy cost is small and the access times will be faster this way.
        Array<CubicPolynomial> cubic_polynomials;   // N polynomials
};
 
/*****************************************************************************
** Implementation [CubicSpline][Streaming]
*****************************************************************************/
 
template <typename OutputStream>
OutputStream& operator << (OutputStream &ostream, const CubicSpline &cubic_spline) {
 
        ecl_compile_time_concept_check(StreamConcept<OutputStream>);
 
    for ( unsigned int i = 0; i < cubic_spline.cubic_polynomials.size(); ++i ) {
        ostream << cubic_spline.cubic_polynomials[i] << "\n";
    }
    ostream.flush();
    return ostream;
}
 
/*****************************************************************************
** BluePrints
*****************************************************************************/
 
namespace blueprints {
 
/*****************************************************************************
** Interface [C2CubicSpline]
*****************************************************************************/
 
class ECL_PUBLIC C2CubicSpline : public ecl::BluePrint<C2CubicSpline> {
    public:
        typedef ecl::CubicSpline base_type;
        C2CubicSpline() {};
 
        C2CubicSpline(const ecl::Array<double>& x_set, const ecl::Array<double>& y_set,
                                        const double ydot_0, const double ydot_f);
 
        virtual ~C2CubicSpline() {};
        C2CubicSpline(const ecl::Array<double>& x_set, const ecl::Array<double>& y_set);
 
        ecl::CubicSpline instantiate();
 
        void apply(ecl::CubicSpline& spline) const;
 
    private:
        ecl::Array<double> x_data;
        ecl::Array<double> y_data;
        ecl::Array<double> yddot_data;
};
 
/*****************************************************************************
** Interface [DerivativeHeuristicCubicSpline]
*****************************************************************************/
 
class ECL_PUBLIC DerivativeHeuristicCubicSpline : public ecl::BluePrint<DerivativeHeuristicCubicSpline> {
    public:
        typedef ecl::CubicSpline base_type;
        DerivativeHeuristicCubicSpline() {};
 
        DerivativeHeuristicCubicSpline(const ecl::Array<double>& x_set, const ecl::Array<double>& y_set,
                        const double ydot_0, const double ydot_f);
 
        virtual ~DerivativeHeuristicCubicSpline() {};
        ecl::CubicSpline instantiate();
 
        void apply(ecl::CubicSpline& spline) const;
 
    private:
        ecl::Array<double> x_data;
        ecl::Array<double> y_data;
        ecl::Array<double> ydot_data;
};
 
} // namespace blueprints
} // namespace ecl
 
#endif /* ECL_GEOMETRY_CUBIC_SPLINE_HPP_ */