Geant4  10.00.p01
interpolating_function_p< float_type > Class Template Reference

create a cubic spline interpolation of a set of (x,y) pairsThis is one of the main reasons for c2_function objects to exist. More...

#include <c2_function.hh>

+ Inheritance diagram for interpolating_function_p< float_type >:
+ Collaboration diagram for interpolating_function_p< float_type >:

Public Member Functions

 interpolating_function_p ()
 an empty linear-linear cubic-spline interpolating_function_p More...
 
 interpolating_function_p (const c2_function_transformation< float_type > &transform)
 an empty cubic-spline interpolating_function_p with a specific transform More...
 
interpolating_function_p
< float_type > & 
load (const std::vector< float_type > &x, const std::vector< float_type > &f, bool lowerSlopeNatural, float_type lowerSlope, bool upperSlopeNatural, float_type upperSlope, bool splined=true) throw (c2_exception)
 do the dirty work of constructing the spline from a function. More...
 
interpolating_function_p
< float_type > & 
load_pairs (std::vector< std::pair< float_type, float_type > > &data, bool lowerSlopeNatural, float_type lowerSlope, bool upperSlopeNatural, float_type upperSlope, bool splined=true) throw (c2_exception)
 do the dirty work of constructing the spline from a function. More...
 
interpolating_function_p
< float_type > & 
sample_function (const c2_function< float_type > &func, float_type amin, float_type amax, float_type abs_tol, float_type rel_tol, bool lowerSlopeNatural, float_type lowerSlope, bool upperSlopeNatural, float_type upperSlope) throw (c2_exception)
 do the dirty work of constructing the spline from a function. More...
 
interpolating_function_p
< float_type > & 
load_random_generator_function (const std::vector< float_type > &bincenters, const c2_function< float_type > &binheights) throw (c2_exception)
 initialize from a grid of points and a c2_function (un-normalized) to an interpolator which, when evaluated with a uniform random variate on [0,1] returns random numbers distributed as the input function. More...
 
interpolating_function_p
< float_type > & 
load_random_generator_bins (const std::vector< float_type > &bins, const std::vector< float_type > &binheights, bool splined=true) throw (c2_exception)
 initialize from a grid of points and an std::vector of probability densities (un-normalized) to an interpolator which, when evaluated with a uniform random variate on [0,1] returns random numbers distributed as the input histogram. More...
 
virtual float_type value_with_derivatives (float_type x, float_type *yprime, float_type *yprime2) const throw (c2_exception)
 get the value and derivatives. More...
 
virtual ~interpolating_function_p ()
 destructor More...
 
virtual
interpolating_function_p
< float_type > & 
clone () const throw (c2_exception)
 create a new, empty interpolating function of this type (virtual constructor) More...
 
void get_data (std::vector< float_type > &xvals, std::vector< float_type > &yvals) const throw ()
 retrieve copies of the x & y tables from which this was built More...
 
void get_internal_data (std::vector< float_type > &xvals, std::vector< float_type > &yvals, std::vector< float_type > &y2vals) const
 retrieve copies of the transformed x, y and y2 tables from which this was built More...
 
void set_lower_extrapolation (float_type bound)
 enable extrapolation of the function below the tabulated data. More...
 
void set_upper_extrapolation (float_type bound)
 enable extrapolation of the function above the tabulated data. More...
 
interpolating_function_p
< float_type > & 
unary_operator (const c2_function< float_type > &source) const
 create a new interpolating_function_p which is the source function applied to every point in the interpolating tables More...
 
interpolating_function_p
< float_type > & 
binary_operator (const c2_function< float_type > &rhs, const c2_binary_function< float_type > *combining_stub) const
 create a new interpolating_function_p which is the parent interpolating_function_p combined with rhs using combiner at every point in the interpolating tables More...
 
interpolating_function_p
< float_type > & 
add_pointwise (const c2_function< float_type > &rhs) const
 produce a newly resampled interpolating_function_p which is the specified sum. More...
 
interpolating_function_p
< float_type > & 
subtract_pointwise (const c2_function< float_type > &rhs) const
 produce a newly resampled interpolating_function_p which is the specified difference. More...
 
interpolating_function_p
< float_type > & 
multiply_pointwise (const c2_function< float_type > &rhs) const
 produce a newly resampled interpolating_function_p which is the specified product. More...
 
interpolating_function_p
< float_type > & 
divide_pointwise (const c2_function< float_type > &rhs) const
 produce a newly resampled interpolating_function_p which is the specified ratio. More...
 
void clone_data (const interpolating_function_p< float_type > &rhs)
 copy data from another interpolating function. This only makes sense if the source function has the same transforms as the destination. More...
 
- Public Member Functions inherited from c2_function< float_type >
const std::string cvs_header_vers () const
 get versioning information for the header file More...
 
const std::string cvs_file_vers () const
 get versioning information for the source file More...
 
virtual ~c2_function ()
 destructor More...
 
float_type operator() (float_type x) const throw (c2_exception)
 evaluate the function in the classic way, ignoring derivatives. More...
 
float_type operator() (float_type x, float_type *yprime, float_type *yprime2) const throw (c2_exception)
 get the value and derivatives. More...
 
float_type find_root (float_type lower_bracket, float_type upper_bracket, float_type start, float_type value, int *error=0, float_type *final_yprime=0, float_type *final_yprime2=0) const throw (c2_exception)
 solve f(x)==value very efficiently, with explicit knowledge of derivatives of the function More...
 
float_type partial_integrals (std::vector< float_type > xgrid, std::vector< float_type > *partials=0, float_type abs_tol=1e-12, float_type rel_tol=1e-12, int derivs=2, bool adapt=true, bool extrapolate=true) const throw (c2_exception)
 for points in xgrid, adaptively return Integral[f(x),{x,xgrid[i],xgrid[i+1]}] and return in vector, along with sum More...
 
float_type integral (float_type amin, float_type amax, std::vector< float_type > *partials=0, float_type abs_tol=1e-12, float_type rel_tol=1e-12, int derivs=2, bool adapt=true, bool extrapolate=true) const throw (c2_exception)
 a fully-automated integrator which uses the information provided by the get_sampling_grid() function to figure out what to do. More...
 
c2_piecewise_function_p
< float_type > * 
adaptively_sample (float_type amin, float_type amax, float_type abs_tol=1e-12, float_type rel_tol=1e-12, int derivs=2, std::vector< float_type > *xvals=0, std::vector< float_type > *yvals=0) const throw (c2_exception)
 create a c2_piecewise_function_p from c2_connector_function_p segments which is a representation of the parent function to the specified accuracy, but maybe much cheaper to evaluate More...
 
float_type xmin () const
 return the lower bound of the domain for this function as set by set_domain() More...
 
float_type xmax () const
 return the upper bound of the domain for this function as set by set_domain() More...
 
void set_domain (float_type amin, float_type amax)
 set the domain for this function. More...
 
size_t get_evaluations () const
 this is a counter owned by the function but which can be used to monitor efficiency of algorithms. More...
 
void reset_evaluations () const
 reset the counter More...
 
void increment_evaluations () const
 count evaluations More...
 
bool check_monotonicity (const std::vector< float_type > &data, const char message[]) const throw (c2_exception)
 check that a vector is monotonic, throw an exception if not, and return a flag if it is reversed More...
 
virtual void set_sampling_grid (const std::vector< float_type > &grid) throw (c2_exception)
 establish a grid of 'interesting' points on the function. More...
 
std::vector< float_type > * get_sampling_grid_pointer () const
 get the sampling grid, which may be a null pointer More...
 
virtual void get_sampling_grid (float_type amin, float_type amax, std::vector< float_type > &grid) const
 return the grid of 'interesting' points along this function which lie in the region requested More...
 
void preen_sampling_grid (std::vector< float_type > *result) const
 clean up endpoints on a grid of points More...
 
void refine_sampling_grid (std::vector< float_type > &grid, size_t refinement) const
 refine a grid by splitting each interval into more intervals More...
 
c2_function< float_type > & normalized_function (float_type amin, float_type amax, float_type norm=1.0) const throw (c2_exception)
 create a new c2_function from this one which is normalized on the interval More...
 
c2_function< float_type > & square_normalized_function (float_type amin, float_type amax, float_type norm=1.0) const throw (c2_exception)
 create a new c2_function from this one which is square-normalized on the interval More...
 
c2_function< float_type > & square_normalized_function (float_type amin, float_type amax, const c2_function< float_type > &weight, float_type norm=1.0) const throw (c2_exception)
 create a new c2_function from this one which is square-normalized with the provided weight on the interval More...
 
c2_sum_p< float_type > & operator+ (const c2_function< float_type > &rhs) const
 factory function to create a c2_sum_p from a regular algebraic expression. More...
 
c2_diff_p< float_type > & operator- (const c2_function< float_type > &rhs) const
 factory function to create a c2_diff_p from a regular algebraic expression. More...
 
c2_product_p< float_type > & operator* (const c2_function< float_type > &rhs) const
 factory function to create a c2_product_p from a regular algebraic expression. More...
 
c2_ratio_p< float_type > & operator/ (const c2_function< float_type > &rhs) const
 factory function to create a c2_ratio_p from a regular algebraic expression. More...
 
c2_composed_function_p
< float_type > & 
operator() (const c2_function< float_type > &inner) const
 compose this function outside another. More...
 
float_type get_trouble_point () const
 Find out where a calculation ran into trouble, if it got a nan. If the most recent computation did not return a nan, this is undefined. More...
 
void claim_ownership () const
 increment our reference count. Destruction is only legal if the count is zero. More...
 
size_t release_ownership_for_return () const throw (c2_exception)
 decrement our reference count. Do not destroy at zero. More...
 
void release_ownership () const throw (c2_exception)
 decrement our reference count. If the count reaches zero, destroy ourself. More...
 
size_t count_owners () const
 get the reference count, mostly for debugging More...
 
void fill_fblock (c2_fblock< float_type > &fb) const throw (c2_exception)
 fill in a c2_fblock<float_type>... a shortcut for the integrator & sampler More...
 

Public Attributes

const
c2_function_transformation
< float_type > & 
fTransform
 

Protected Member Functions

void spline (bool lowerSlopeNatural, float_type lowerSlope, bool upperSlopeNatural, float_type upperSlope) throw (c2_exception)
 create the spline coefficients More...
 
- Protected Member Functions inherited from c2_function< float_type >
 c2_function (const c2_function< float_type > &src)
 
 c2_function ()
 
virtual void set_sampling_grid_pointer (std::vector< float_type > &grid)
 

Static Protected Member Functions

static bool comp_pair (std::pair< float_type, float_type > const &i, std::pair< float_type, float_type > const &j)
 

Protected Attributes

std::vector< float_type > Xraw
 
std::vector< float_type > X
 
std::vector< float_type > F
 
std::vector< float_type > y2
 
c2_const_ptr< float_type > sampler_function
 
bool xInverted
 
size_t lastKLow
 
- Protected Attributes inherited from c2_function< float_type >
std::vector< float_type > * sampling_grid
 
bool no_overwrite_grid
 
float_type fXMin
 
float_type fXMax
 
size_t evaluations
 
float_type bad_x_point
 this point may be used to record where a calculation ran into trouble More...
 

Detailed Description

template<typename float_type = double>
class interpolating_function_p< float_type >

create a cubic spline interpolation of a set of (x,y) pairs

This is one of the main reasons for c2_function objects to exist.

It provides support for cubic spline interpolation of data provides from tables of x, y pairs. It supports automatic, transparent linearization of the data before storing in its tables (through subclasses such as log_lin_interpolating_function, lin_log_interpolating_function, and log_log_interpolating_function) to permit very high accuracy representations of data which have a suitable structure. It provides utility functions LinearInterpolatingGrid() and LogLogInterpolatingGrid() to create grids for mapping other functions onto a arithmetic or geometric grid.

In its simplest form, an untransformed cubic spline of a data set, using natural boundary conditions (vanishing second derivative), is created as:

std::vector<double> xvals(10), yvals(10);
// < fill in xvals and yvals >
c2p myfunc=c2.interpolating_function().load(xvals, yvals,true,0,true,0);
// and it can be evaluated at a point for its value only by:
double y=myfunc(x);
// or it can be evaluated with its derivatives by
double yprime, yprime2;
double y=myfunc(x,&yprime, &yprime2);
The factory function c2_factory::interpolating_function() creates *new interpolating_function_p()

Definition at line 1377 of file c2_function.hh.

Constructor & Destructor Documentation

template<typename float_type = double>
interpolating_function_p< float_type >::interpolating_function_p ( )
inline

an empty linear-linear cubic-spline interpolating_function_p

lots to say here, but see Numerical Recipes for a discussion of cubic splines.

Definition at line 1383 of file c2_function.hh.

template<typename float_type = double>
interpolating_function_p< float_type >::interpolating_function_p ( const c2_function_transformation< float_type > &  transform)
inline

an empty cubic-spline interpolating_function_p with a specific transform

Definition at line 1388 of file c2_function.hh.

template<typename float_type = double>
virtual interpolating_function_p< float_type >::~interpolating_function_p ( )
inlinevirtual

destructor

Definition at line 1485 of file c2_function.hh.

References interpolating_function_p< float_type >::fTransform.

Member Function Documentation

template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::add_pointwise ( const c2_function< float_type > &  rhs) const
inline

produce a newly resampled interpolating_function_p which is the specified sum.

Parameters
rhsthe function to add, pointwise
Returns
a new interpolating_function_p

Definition at line 1548 of file c2_function.hh.

References interpolating_function_p< float_type >::binary_operator().

+ Here is the call graph for this function:

template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::binary_operator ( const c2_function< float_type > &  rhs,
const c2_binary_function< float_type > *  combining_stub 
) const

create a new interpolating_function_p which is the parent interpolating_function_p combined with rhs using combiner at every point in the interpolating tables

This carefully manages the derivative of the composed function at the two ends.

Parameters
rhsthe function to apply
combining_stuba function which defines which binary operation to use.
Returns
a new interpolating_function_p with the same mappings for x and y

Referenced by interpolating_function_p< float_type >::add_pointwise(), interpolating_function_p< float_type >::divide_pointwise(), interpolating_function_p< float_type >::multiply_pointwise(), and interpolating_function_p< float_type >::subtract_pointwise().

+ Here is the caller graph for this function:

template<typename float_type = double>
virtual interpolating_function_p<float_type>& interpolating_function_p< float_type >::clone ( ) const
throw (c2_exception
)
inlinevirtual

create a new, empty interpolating function of this type (virtual constructor)

Reimplemented in arrhenius_interpolating_function_p< float_type >, log_log_interpolating_function_p< float_type >, lin_log_interpolating_function_p< float_type >, and log_lin_interpolating_function_p< float_type >.

Definition at line 1488 of file c2_function.hh.

template<typename float_type = double>
void interpolating_function_p< float_type >::clone_data ( const interpolating_function_p< float_type > &  rhs)
inline

copy data from another interpolating function. This only makes sense if the source function has the same transforms as the destination.

Parameters
rhsinterpolating_function_p to copy from

Definition at line 1568 of file c2_function.hh.

References interpolating_function_p< float_type >::F, c2_function< float_type >::set_sampling_grid_pointer(), interpolating_function_p< float_type >::X, interpolating_function_p< float_type >::Xraw, and interpolating_function_p< float_type >::y2.

+ Here is the call graph for this function:

template<typename float_type = double>
static bool interpolating_function_p< float_type >::comp_pair ( std::pair< float_type, float_type > const &  i,
std::pair< float_type, float_type > const &  j 
)
inlinestaticprotected

Definition at line 1583 of file c2_function.hh.

template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::divide_pointwise ( const c2_function< float_type > &  rhs) const
inline

produce a newly resampled interpolating_function_p which is the specified ratio.

Parameters
rhsthe function to divide, pointwise
Returns
a new interpolating_function_p

Definition at line 1563 of file c2_function.hh.

References interpolating_function_p< float_type >::binary_operator().

+ Here is the call graph for this function:

template<typename float_type = double>
void interpolating_function_p< float_type >::get_data ( std::vector< float_type > &  xvals,
std::vector< float_type > &  yvals 
) const
throw (
)

retrieve copies of the x & y tables from which this was built

This is often useful in the creation of new interpolating functions with transformed data. The vectors will have their sizes set correctly on return.

Parameters
[in,out]xvalsthe abscissas
[in,out]yvalsthe ordinates
template<typename float_type = double>
void interpolating_function_p< float_type >::get_internal_data ( std::vector< float_type > &  xvals,
std::vector< float_type > &  yvals,
std::vector< float_type > &  y2vals 
) const
inline

retrieve copies of the transformed x, y and y2 tables from which this was built

The vectors will have their sizes set correctly on return.

Parameters
[in,out]xvalsthe transformed abscissas
[in,out]yvalsthe transformed ordinates
[in,out]y2valsthe second derivatives

Definition at line 1505 of file c2_function.hh.

References interpolating_function_p< float_type >::F, interpolating_function_p< float_type >::X, and interpolating_function_p< float_type >::y2.

template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::load ( const std::vector< float_type > &  x,
const std::vector< float_type > &  f,
bool  lowerSlopeNatural,
float_type  lowerSlope,
bool  upperSlopeNatural,
float_type  upperSlope,
bool  splined = true 
)
throw (c2_exception
)

do the dirty work of constructing the spline from a function.

Parameters
xthe list of abscissas. Must be either strictly increasing or strictly decreasing. Strictly increasing is preferred, as less memory is used since a copy is not required for the sampling grid.
fthe list of function values.
lowerSlopeNaturalif true, set y''(first point)=0, otherwise compute it from lowerSope
lowerSlopederivative of the function at the lower bound, used only if lowerSlopeNatural is false
upperSlopeNaturalif true, set y''(last point)=0, otherwise compute it from upperSope
upperSlopederivative of the function at the upper bound, used only if upperSlopeNatural is false
splinedif true (default), use cubic spline, if false, use linear interpolation.
Returns
the same interpolating function, filled
template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::load_pairs ( std::vector< std::pair< float_type, float_type > > &  data,
bool  lowerSlopeNatural,
float_type  lowerSlope,
bool  upperSlopeNatural,
float_type  upperSlope,
bool  splined = true 
)
throw (c2_exception
)

do the dirty work of constructing the spline from a function.

Parameters
datastd::vector of std::pairs of x,y. Will be sorted into x increasing order in place.
lowerSlopeNaturalif true, set y''(first point)=0, otherwise compute it from lowerSope
lowerSlopederivative of the function at the lower bound, used only if lowerSlopeNatural is false
upperSlopeNaturalif true, set y''(last point)=0, otherwise compute it from upperSope
upperSlopederivative of the function at the upper bound, used only if upperSlopeNatural is false
splinedif true (default), use cubic spline, if false, use linear interpolation.
Returns
the same interpolating function, filled
template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::load_random_generator_bins ( const std::vector< float_type > &  bins,
const std::vector< float_type > &  binheights,
bool  splined = true 
)
throw (c2_exception
)

initialize from a grid of points and an std::vector of probability densities (un-normalized) to an interpolator which, when evaluated with a uniform random variate on [0,1] returns random numbers distributed as the input histogram.

See also
Arbitrary random generation inverse_integrated_density starts with a probability density std::vector, generates the integral, and generates an interpolating_function_p of the inverse function which, when evaluated using a uniform random on [0,1] returns values with a density distribution equal to the input distribution If the data are passed in reverse order (large X first), the integral is carried out from the big end.
Parameters
binsif bins .size()==binheights .size(), the centers of the bins.
if bins .size()==binheights .size()+1, the edges of the bins
binheightsa vector which describes the density of the random number distribution to be produced. Note density... the numbers in the bins are not counts, but counts/unit bin width.
splinedif true (default), use cubic spline, if false, use linear interpolation. This can often be used to fix ringing if there are very sharp features in the generator.
Returns
an initialized interpolator, which if evaluated randomly with a uniform variate on [0,1] produces numbers distributed according to binheights
template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::load_random_generator_function ( const std::vector< float_type > &  bincenters,
const c2_function< float_type > &  binheights 
)
throw (c2_exception
)

initialize from a grid of points and a c2_function (un-normalized) to an interpolator which, when evaluated with a uniform random variate on [0,1] returns random numbers distributed as the input function.

See also
Arbitrary random generation inverse_integrated_density starts with a probability density std::vector, generates the integral, and generates an interpolating_function_p of the inverse function which, when evaluated using a uniform random on [0,1] returns values with a density distribution equal to the input distribution If the data are passed in reverse order (large X first), the integral is carried out from the big end.
Parameters
bincentersthe positions at which to sample the function binheights
binheightsa function which describes the density of the random number distribution to be produced.
Returns
an initialized interpolator, which if evaluated randomly with a uniform variate on [0,1] produces numbers distributed according to binheights
template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::multiply_pointwise ( const c2_function< float_type > &  rhs) const
inline

produce a newly resampled interpolating_function_p which is the specified product.

Parameters
rhsthe function to multiply, pointwise
Returns
a new interpolating_function_p

Definition at line 1558 of file c2_function.hh.

References interpolating_function_p< float_type >::binary_operator().

+ Here is the call graph for this function:

template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::sample_function ( const c2_function< float_type > &  func,
float_type  amin,
float_type  amax,
float_type  abs_tol,
float_type  rel_tol,
bool  lowerSlopeNatural,
float_type  lowerSlope,
bool  upperSlopeNatural,
float_type  upperSlope 
)
throw (c2_exception
)

do the dirty work of constructing the spline from a function.

Parameters
funca function without any requirement of valid derivatives to sample into an interpolating function. Very probably a c2_classic_function.
aminthe lower bound of the region to sample
amaxthe upper bound of the region to sample
abs_tolthe maximum absolute error permitted when linearly interpolating the points. the real error will be much smaller, since this uses cubic splines at the end.
rel_tolthe maximum relative error permitted when linearly interpolating the points. the real error will be much smaller, since this uses cubic splines at the end.
lowerSlopeNaturalif true, set y'(first point) from 3-point parabola, otherwise compute it from lowerSope
lowerSlopederivative of the function at the lower bound, used only if lowerSlopeNatural is false
upperSlopeNaturalif true, set y'(last point) from 3-point parabola, otherwise compute it from upperSope
upperSlopederivative of the function at the upper bound, used only if upperSlopeNatural is false
Returns
the same interpolating function, filled
Note
If the interpolator being filled has a log vertical axis, put the desired relative error in abs_tol, and 0 in rel_tol since the absolute error on the log of a function is the relative error on the function itself.
template<typename float_type = double>
void interpolating_function_p< float_type >::set_lower_extrapolation ( float_type  bound)

enable extrapolation of the function below the tabulated data.

This allows the interpolator to be extrapolated outside the bounds of the data, using whatever derivatives it already had at the lower bound.

Parameters
boundthe abscissa to which the function should be extended.
template<typename float_type = double>
void interpolating_function_p< float_type >::set_upper_extrapolation ( float_type  bound)

enable extrapolation of the function above the tabulated data.

This allows the interpolator to be extrapolated outside the bounds of the data, using whatever derivatives it already had at the upper bound.

Parameters
boundthe abscissa to which the function should be extended.
template<typename float_type = double>
void interpolating_function_p< float_type >::spline ( bool  lowerSlopeNatural,
float_type  lowerSlope,
bool  upperSlopeNatural,
float_type  upperSlope 
)
throw (c2_exception
)
protected

create the spline coefficients

template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::subtract_pointwise ( const c2_function< float_type > &  rhs) const
inline

produce a newly resampled interpolating_function_p which is the specified difference.

Parameters
rhsthe function to subtract, pointwise
Returns
a new interpolating_function_p

Definition at line 1553 of file c2_function.hh.

References interpolating_function_p< float_type >::binary_operator().

+ Here is the call graph for this function:

template<typename float_type = double>
interpolating_function_p<float_type>& interpolating_function_p< float_type >::unary_operator ( const c2_function< float_type > &  source) const

create a new interpolating_function_p which is the source function applied to every point in the interpolating tables

This carefully manages the derivative of the composed function at the two ends.

Parameters
sourcethe function to apply
Returns
a new interpolating_function_p with the same mappings for x and y
template<typename float_type = double>
virtual float_type interpolating_function_p< float_type >::value_with_derivatives ( float_type  x,
float_type *  yprime,
float_type *  yprime2 
) const
throw (c2_exception
)
virtual

get the value and derivatives.

There is required checking for null pointers on the derivatives, and most implementations should operate faster if derivatives are not needed.

Parameters
[in]xthe point at which to evaluate the function
[out]yprimethe first derivative (if pointer is non-null)
[out]yprime2the second derivative (if pointer is non-null)
Returns
the value of the function

Implements c2_function< float_type >.

Member Data Documentation

template<typename float_type = double>
std::vector<float_type> interpolating_function_p< float_type >::F
protected
template<typename float_type = double>
const c2_function_transformation<float_type>& interpolating_function_p< float_type >::fTransform
template<typename float_type = double>
size_t interpolating_function_p< float_type >::lastKLow
mutableprotected

Definition at line 1588 of file c2_function.hh.

template<typename float_type = double>
c2_const_ptr<float_type> interpolating_function_p< float_type >::sampler_function
protected

Definition at line 1586 of file c2_function.hh.

template<typename float_type = double>
std::vector<float_type> interpolating_function_p< float_type >::X
protected
template<typename float_type = double>
bool interpolating_function_p< float_type >::xInverted
protected

Definition at line 1587 of file c2_function.hh.

template<typename float_type = double>
std::vector<float_type> interpolating_function_p< float_type >::Xraw
protected

Definition at line 1585 of file c2_function.hh.

Referenced by interpolating_function_p< float_type >::clone_data().

template<typename float_type = double>
std::vector<float_type> interpolating_function_p< float_type >::y2
protected

The documentation for this class was generated from the following file: