Hello,
I am modeling a 1-dim real numerical function f, not necessarily monotone,
described by :
x0 y0
x1 y1
.
xn-1 yn-1
by
template
class Curve : public std::map {
protected:
Curve();
virtual ~Curve();
const InterpolationType& interpolator() const;
const ExtrapolationType& extrapolator() const;
const IntegrationType& integrator() const;
double operator()(double t) const; /**< read f(t) */
double& operator()(double t); /**< write f(t)=ft */
double inverse(double f) const; /**< read f-1(f) */
double derivative(double t) const; /**< read f'(t) */
/**
* \brief Returns Integral over [tmin,tmax] of f(t) using
* the template argument integration method
*/
double integral(double tmax, double tmin =0.0) const;
/**
* \brief Returns Integral over [tmin,tmax] of f^n(t) using
* the template argument integration method
*/
double integral(int n, double tmax, double tmin =0.0) const;
/**
* \brief Applies operation Op on the f(t) curve, outputs in result
*/
template<typename Op> void transform(Curve& result) const;
/**
* \brief Outputs tabulated data
*/
friend std::ostream& operator<<(std::ostream& s, const Curve& rhs);
private:
const InterpolationType& interpolator_;
const ExtrapolationType& extrapolator_;
const IntegrationType& integrator_;
};
There are different ways of interpolating f(x) for x0 <= x <= xn-1,
extrapolating f(x) for x<x0 or x>xn-1,
and integrating over some domain [tmin,tmax]
1- Each of InterpolationType, ExtrapolationType, IntegrationType arguments
expects
a type derived from BaseInterpolator, BaseExtrapolator, BaseIntegrator,
but I am not certain I need this inheritance.
What are the tradeoffs?
2- Curve is an internal implementation object of my library. However,
private derived classes
from Curve will be exposed to library users. So Curve's header will have to
be exposed too.
I guess public inheritance from map is fine? There are no public
constructors.
3- Constructing the curve is not performance-critical, but the operator(),
inverse,
derivative and integral are. I have played with native arrays, with map and
with
boost::multi_array with optimized macros, and it seems operator() when it is
a simple
linear interpolation is fastest with maps (because they are sorted). Any
comments?
Rds,
Hicham Mouline