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 ecl_assert_throw_decl(StandardException);
        double derivative(double x) const ecl_assert_throw_decl(StandardException);
        double dderivative(double x) const ecl_assert_throw_decl(StandardException);

        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) ecl_assert_throw_decl(ecl::StandardException);

        virtual ~C2CubicSpline() {};
        C2CubicSpline(const ecl::Array<double>& x_set, const ecl::Array<double>& y_set) ecl_assert_throw_decl(ecl::StandardException);

        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) ecl_assert_throw_decl(ecl::StandardException);

        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_ */