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 >:

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 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...

Data Fields
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:

    c2_ptr<double> c2p;
    c2_factory<double> c2;
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.

1383 : c2_function<float_type>(),

1384 fTransform(*new c2_lin_lin_function_transformation<float_type>) { }

c2_lin_lin_function_transformation

a transformation of a function in and out of lin-lin space

Definition: c2_function.hh:1279

interpolating_function_p::fTransform

const c2_function_transformation< float_type > & fTransform

Definition: c2_function.hh:1573

c2_function

the parent class for all c2_functions.c2_functions know their value, first, and second derivative at ...

Definition: c2_function.hh:138

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.

1388 : c2_function<float_type>(),

1389 fTransform(transform) { }

interpolating_function_p::fTransform

const c2_function_transformation< float_type > & fTransform

Definition: c2_function.hh:1573

c2_function

the parent class for all c2_functions.c2_functions know their value, first, and second derivative at ...

Definition: c2_function.hh:138

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.

1485 { delete &fTransform; }

interpolating_function_p::fTransform

const c2_function_transformation< float_type > & fTransform

Definition: c2_function.hh:1573

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

rhs	the 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().

1548 {

1549 return binary_operator(rhs, new c2_sum_p<float_type>()); }

interpolating_function_p::binary_operator

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 ...

c2_sum_p

create a c2_function which is the sum of two other c2_function objects.This should always be construc...

Definition: c2_function.hh:80

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

rhs	the function to apply
combining_stub	a 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().

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.

1489 { return *new interpolating_function_p<float_type>(); }

interpolating_function_p

create a cubic spline interpolation of a set of (x,y) pairsThis is one of the main reasons for c2_fun...

Definition: c2_function.hh:1377

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

rhs	interpolating_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.

                                                                           {
                 Xraw=rhs.Xraw; X=rhs.X; F=rhs.F; y2=rhs.y2;
                 set_sampling_grid_pointer(Xraw);
         }

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.

1583 {return i.first<j.first;}

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

rhs	the 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().

1563 {

1564 return binary_operator(rhs, new c2_ratio_p<float_type>()); }

c2_ratio_p

create a c2_function which is the ratio of two other c2_functions.This should always be constructed u...

Definition: c2_function.hh:83

interpolating_function_p::binary_operator

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 ...

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]	xvals	the abscissas
[in,out]	yvals	the 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]	xvals	the transformed abscissas
[in,out]	yvals	the transformed ordinates
[in,out]	y2vals	the 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.

1509 { xvals=X; yvals=F; y2vals=y2; }

interpolating_function_p::y2

std::vector< float_type > y2

Definition: c2_function.hh:1585

interpolating_function_p::F

std::vector< float_type > F

Definition: c2_function.hh:1585

interpolating_function_p::X

std::vector< float_type > X

Definition: c2_function.hh:1585

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

x	the 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.
f	the list of function values.
lowerSlopeNatural	if true, set y''(first point)=0, otherwise compute it from lowerSope
lowerSlope	derivative of the function at the lower bound, used only if lowerSlopeNatural is false
upperSlopeNatural	if true, set y''(last point)=0, otherwise compute it from upperSope
upperSlope	derivative of the function at the upper bound, used only if upperSlopeNatural is false
splined	if 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

data	std::vector of std::pairs of x,y. Will be sorted into x increasing order in place.
lowerSlopeNatural	if true, set y''(first point)=0, otherwise compute it from lowerSope
lowerSlope	derivative of the function at the lower bound, used only if lowerSlopeNatural is false
upperSlopeNatural	if true, set y''(last point)=0, otherwise compute it from upperSope
upperSlope	derivative of the function at the upper bound, used only if upperSlopeNatural is false
splined	if 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

bins	if bins .size()==binheights .size(), the centers of the bins. if bins .size()==binheights .size()+1, the edges of the bins
binheights	a 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.
splined	if 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

bincenters	the positions at which to sample the function binheights
binheights	a 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

rhs	the 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().

1558 {

1559 return binary_operator(rhs, new c2_product_p<float_type>()); }

c2_product_p

create a c2_function which is the product of two other c2_functions.This should always be constructed...

Definition: c2_function.hh:82

interpolating_function_p::binary_operator

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 ...

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

func	a function without any requirement of valid derivatives to sample into an interpolating function. Very probably a c2_classic_function.
amin	the lower bound of the region to sample
amax	the upper bound of the region to sample
abs_tol	the 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_tol	the maximum relative error permitted when linearly interpolating the points. the real error will be much smaller, since this uses cubic splines at the end.
lowerSlopeNatural	if true, set y'(first point) from 3-point parabola, otherwise compute it from lowerSope
lowerSlope	derivative of the function at the lower bound, used only if lowerSlopeNatural is false
upperSlopeNatural	if true, set y'(last point) from 3-point parabola, otherwise compute it from upperSope
upperSlope	derivative 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

bound the 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

bound the 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

rhs	the 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().

1553 {

1554 return binary_operator(rhs, new c2_diff_p<float_type>()); }

interpolating_function_p::binary_operator

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 ...

c2_diff_p

create a c2_function which is the difference of two other c2_functions.This should always be construc...

Definition: c2_function.hh:81

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

source the 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]	x	the point at which to evaluate the function
[out]	yprime	the first derivative (if pointer is non-null)
[out]	yprime2	the second derivative (if pointer is non-null)