smooth_linear_spline.hpp

Go to the documentation of this file.

/*****************************************************************************
** Ifdefs
*****************************************************************************/

#ifndef ECL_SMOOTH_LINEAR_SPLINE_HPP_
#define ECL_SMOOTH_LINEAR_SPLINE_HPP_

/*****************************************************************************
** Includes
*****************************************************************************/

#include <ecl/config/macros.hpp>
#include <ecl/concepts/streams.hpp>
#include <ecl/containers/array.hpp>
#include <ecl/exceptions/data_exception.hpp>
#include <ecl/exceptions/standard_exception.hpp>
#include "polynomial.hpp"
#include "macros.hpp"

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace ecl {

/*****************************************************************************
** Interface [SmoothLinearSpline]
*****************************************************************************/
class ecl_geometry_PUBLIC SmoothLinearSpline {
public:
        SmoothLinearSpline() {}
    SmoothLinearSpline(const Array<double>& x_data, const Array<double>& y_data, double a_max) throw (DataException<int>);

    virtual     ~SmoothLinearSpline() {}

        double operator()(const double &x) const ecl_assert_throw_decl(StandardException);
        double derivative(const double &x) const ecl_assert_throw_decl(StandardException);
        double dderivative(const double &x) const ecl_assert_throw_decl(StandardException);

        const Array<double>& domain() const { return discretised_domain; }

        /*********************
         * Static Constructor
        **********************/
        static SmoothLinearSpline Interpolation(const Array<double>& x_data, const Array<double>& y_data, double a_max) throw (DataException<int>)
        {
                try {
                        return SmoothLinearSpline(x_data, y_data, a_max);
                } catch ( DataException<int> &e ) {
                        throw DataException<int>(LOC,e);
                }
                return SmoothLinearSpline();  // avoid a warning because of the rethrown exception.
        }

        /******************************************
         * Streaming
        *******************************************/
        template <typename OutputStream>
        friend OutputStream& operator << (OutputStream &ostream, const SmoothLinearSpline &smooth_linear_spline);

private:
        Array<double> discretised_domain;       // 2*N points (2 end points + 2*(N-1) corner points)
        Array<LinearFunction> segments;         // N linear segments
        Array<QuinticPolynomial> corners;       // N-1 corners
};

/*****************************************************************************
** Implementation [SmoothLinearSpline][Streaming]
*****************************************************************************/

template <typename OutputStream>
OutputStream& operator << (OutputStream &ostream, const SmoothLinearSpline &smooth_linear_spline) {

        ecl_compile_time_concept_check(StreamConcept<OutputStream>);

    ostream << smooth_linear_spline.segments[0] << "\n";
    for ( unsigned int i = 1; i < smooth_linear_spline.segments.size(); ++i ) {
        ostream << smooth_linear_spline.corners[i-1] << "\n";
        ostream << smooth_linear_spline.segments[i] << "\n";
    }
    ostream.flush();
    return ostream;
}

} // namespace ecl

#endif /* ECL_SMOOTH_LINEAR_SPLINE_HPP_ */