Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
c2_function< float_type > Class Template Referenceabstract

the parent class for all c2_functions.c2_functions know their value, first, and second derivative at almost every point. They can be efficiently combined with binary operators, via c2_binary_function, composed via c2_composed_function_, have their roots found via find_root(), and be adaptively integrated via partial_integrals() or integral(). They also can carry information with them about how to find 'interesting' points on the function. This information is set with set_sampling_grid() and extracted with get_sampling_grid(). More...

#include <c2_function.hh>

Inheritance diagram for c2_function< float_type >:
Collaboration diagram for c2_function< float_type >:

Public Member Functions

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...
 
virtual float_type value_with_derivatives (float_type x, float_type *yprime, float_type *yprime2) const =0
 get the value and derivatives. More...
 
float_type operator() (float_type x) const
 evaluate the function in the classic way, ignoring derivatives. More...
 
float_type operator() (float_type x, float_type *yprime, float_type *yprime2) const
 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
 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
 
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
 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
 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
 
float_type xmax () const
 
void set_domain (float_type amin, float_type amax)
 
size_t get_evaluations () const
 
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
 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)
 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
 
void preen_sampling_grid (std::vector< float_type > *result) const
 The grid is modified in place. More...
 
void refine_sampling_grid (std::vector< float_type > &grid, size_t refinement) const
 
c2_function< float_type > & normalized_function (float_type amin, float_type amax, float_type norm=1.0) const
 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
 
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
 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
 
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
 decrement our reference count. Do not destroy at zero. More...
 
void release_ownership () const
 
size_t count_owners () const
 get the reference count, mostly for debugging More...
 
void fill_fblock (c2_fblock< float_type > &fb) const
 fill in a c2_fblock<float_type>... a shortcut for the integrator & sampler More...
 

Protected Member Functions

 c2_function (const c2_function< float_type > &src)
 
 c2_function ()
 
virtual void set_sampling_grid_pointer (std::vector< float_type > &grid)
 

Protected Attributes

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 c2_function< float_type >

the parent class for all c2_functions.

c2_functions know their value, first, and second derivative at almost every point. They can be efficiently combined with binary operators, via c2_binary_function, composed via c2_composed_function_, have their roots found via find_root(), and be adaptively integrated via partial_integrals() or integral(). They also can carry information with them about how to find 'interesting' points on the function. This information is set with set_sampling_grid() and extracted with get_sampling_grid().

Particularly important subclasses are the interpolating functions classes, interpolating_function , lin_log_interpolating_function, log_lin_interpolating_function, log_log_interpolating_function, and arrhenius_interpolating_function, as well as the template functions inverse_integrated_density_function().

For a discussion of memory management, see memory_management

Definition at line 147 of file c2_function.hh.

Constructor & Destructor Documentation

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

destructor

Definition at line 161 of file c2_function.hh.

161  {
163  if(root_info) delete root_info;
164  if(owner_count) {
165  std::ostringstream outstr;
166  outstr << "attempt to delete an object with non-zero ownership in class";
167  outstr << typeid(*this).name() << std::endl;
168  //throw c2_exception(outstr.str().c_str());
169  }
170  }
std::vector< float_type > * sampling_grid
Definition: c2_function.hh:544
bool no_overwrite_grid
Definition: c2_function.hh:545
template<typename float_type = double>
c2_function< float_type >::c2_function ( const c2_function< float_type > &  src)
inlineprotected

Definition at line 527 of file c2_function.hh.

528  : sampling_grid(0),
529  no_overwrite_grid(false),
530  fXMin(src.fXMin), fXMax(src.fXMax), root_info(0), owner_count(0)
531  {} // copy constructor only copies domain, and is only for internal use
float_type fXMax
Definition: c2_function.hh:547
float_type fXMin
Definition: c2_function.hh:547
std::vector< float_type > * sampling_grid
Definition: c2_function.hh:544
bool no_overwrite_grid
Definition: c2_function.hh:545
template<typename float_type = double>
c2_function< float_type >::c2_function ( )
inlineprotected

Definition at line 532 of file c2_function.hh.

532  :
535  fXMax(std::numeric_limits<float_type>::max()), root_info(0), owner_count(0)
536  {}
float_type fXMax
Definition: c2_function.hh:547
T max(const T t1, const T t2)
brief Return the largest of the two arguments
float_type fXMin
Definition: c2_function.hh:547
std::vector< float_type > * sampling_grid
Definition: c2_function.hh:544
bool no_overwrite_grid
Definition: c2_function.hh:545

Member Function Documentation

template<typename float_type = double>
c2_piecewise_function_p<float_type>* c2_function< 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

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

This method has three modes, depending on the derivs flag.

If derivs is 2, it computes a c2_piecewise_function_p representation of its parent function, which may be a much faster function to use in codes if the parent function is expensive. If xvals and yvals are non-null, it will also fill them in with the function values at each grid point the adaptive algorithm chooses.

If derivs is 1, this does not create the connectors, and returns an null pointer, but will fill in the xvals and yvals vectors with values of the function at points such that the linear interpolation error between the points is bounded by the tolerance values given. Because it uses derivative information from the function to manage the error control, it is almost completely free of issues with missing periods of oscillatory functions, even with no information provided in the sampling grid. This is typically useful for sampling a function for plotting.

If derivs is 0, this does something very like what it does if derivs = 1, but without derivatives. Instead, to compute the intermediate value of the function for error control, it just uses 3-point parabolic interpolation. This is useful amost exclusively for converting a non-c2_function, with no derivatives, but wrapped in a c2_classic_function wrapper, into a table of values to seed an interpolating_function_p. Note, however, that without derivatives, this is very susceptible to missing periods of oscillatory functions, so it is important to set a sampling grid which isn't too much coarser than the typical oscillations.

Note
the sampling_grid of the returned function matches the sampling_grid of its parent.
See Also
Adaptive Sampling Examples
Parameters
aminlower bound of the domain for sampling
amaxupper bound of the domain for sampling
abs_tolthe absolute error bound for each segment
rel_tolthe fractional error bound for each segment.
derivsif 0 or 1, return a useless function, but fill in the xvals and yvals vectors (if non-null). Also, if 0 or 1, tolerances refer to linear interpolation, not high-order interpolation. If 2, return a full piecewise collection of c2_connector_function_p segments. See discussion above.
[in,out]xvalsvector of abscissas at which the function was actually sampled (if non-null)
[in,out]yvalsvector of function values corresponding to xvals (if non-null)
Returns
a new, sampled representation, if derivs is 2. A null pointer if derivs is 0 or 1.
template<typename float_type = double>
bool c2_function< float_type >::check_monotonicity ( const std::vector< float_type > &  data,
const char  message[] 
) const

check that a vector is monotonic, throw an exception if not, and return a flag if it is reversed

Parameters
dataa vector of data points which are expected to be monotonic.
messagean informative string to include in an exception if this throws c2_exception
Returns
true if in decreasing order, false if increasing
template<typename float_type = double>
void c2_function< float_type >::claim_ownership ( ) const
inline

increment our reference count. Destruction is only legal if the count is zero.

Definition at line 506 of file c2_function.hh.

506 { owner_count++; }
template<typename float_type = double>
size_t c2_function< float_type >::count_owners ( ) const
inline

get the reference count, mostly for debugging

Returns
the count

Definition at line 524 of file c2_function.hh.

524 { return owner_count; }
template<typename float_type = double>
const std::string c2_function< float_type >::cvs_file_vers ( ) const

get versioning information for the source file

Returns
the CVS Id string
template<typename float_type = double>
const std::string c2_function< float_type >::cvs_header_vers ( ) const
inline

get versioning information for the header file

Returns
the CVS Id string

Definition at line 151 of file c2_function.hh.

151  { return
152  "c2_function.hh 490 2012-04-10 19:05:40Z marcus ";
153  }
template<typename float_type = double>
void c2_function< float_type >::fill_fblock ( c2_fblock< float_type > &  fb) const
inline

fill in a c2_fblock<float_type>... a shortcut for the integrator & sampler

Parameters
[in,out]fbthe block to fill in with information

Definition at line 556 of file c2_function.hh.

557  {
558  fb.y=value_with_derivatives(fb.x, &fb.yp, &fb.ypp);
559  fb.ypbad=c2_isnan(fb.yp) || !c2_isfinite(fb.yp);
560  fb.yppbad=c2_isnan(fb.ypp) || !c2_isfinite(fb.ypp);
562  }
float_type x
the abscissa
Definition: c2_function.hh:108
float_type ypp
the second derivative at x
Definition: c2_function.hh:114
#define c2_isnan
Definition: c2_function.hh:51
float_type yp
the derivative at x
Definition: c2_function.hh:112
bool yppbad
is NaN of Inf
Definition: c2_function.hh:119
float_type y
the value of the function at x
Definition: c2_function.hh:110
#define c2_isfinite
Definition: c2_function.hh:52
void increment_evaluations() const
count evaluations
Definition: c2_function.hh:399
virtual float_type value_with_derivatives(float_type x, float_type *yprime, float_type *yprime2) const =0
get the value and derivatives.
template<typename float_type = double>
float_type c2_function< 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

solve f(x)==value very efficiently, with explicit knowledge of derivatives of the function

find_root solves by iterated inverse quadratic extrapolation for a solution to f(x)=y. It includes checks against bad convergence, so it should never be able to fail. Unlike typical secant method or fancier Brent's method finders, this does not depend in any strong wasy on the brackets, unless the finder has to resort to successive approximations to close in on a root. Often, it is possible to make the brackets equal to the domain of the function, if there is any clue as to where the root lies, as given by the parameter start.

Parameters
lower_bracketthe lower bound for the search
upper_bracketthe upper bound for the search. Function sign must be opposite to that at lower_bracket
startstarting value for the search
valuethe value of the function being sought (solves f(x) = value)
[out]errorIf pointer is zero, errors raise exception. Otherwise, returns error here.
[out]final_yprimeIf pointer is not zero, return derivative of function at root
[out]final_yprime2If pointer is not zero, return second derivative of function at root
Returns
the position of the root.
See Also
Root finding sample

Here is the caller graph for this function:

template<typename float_type = double>
size_t c2_function< float_type >::get_evaluations ( ) const
inline

and sampler do increment it.

Returns
number of evaluations logged since last reset.

Definition at line 395 of file c2_function.hh.

395 { return evaluations; }
size_t evaluations
Definition: c2_function.hh:548
template<typename float_type = double>
virtual void c2_function< float_type >::get_sampling_grid ( float_type  amin,
float_type  amax,
std::vector< float_type > &  grid 
) const
virtual

Reimplemented in c2_sin_p< float_type >, c2_plugin_function_p< float_type >, and c2_plugin_function_p< G4double >.

Here is the caller graph for this function:

template<typename float_type = double>
std::vector<float_type>* c2_function< float_type >::get_sampling_grid_pointer ( ) const
inline

get the sampling grid, which may be a null pointer

Returns
pointer to the sampling grid

Definition at line 432 of file c2_function.hh.

432  {
433  return sampling_grid; }
std::vector< float_type > * sampling_grid
Definition: c2_function.hh:544
template<typename float_type = double>
float_type c2_function< float_type >::get_trouble_point ( ) const
inline

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.

Returns
x value of point at which something went wrong, if integrator (or otherwise) returned a nan.

Definition at line 502 of file c2_function.hh.

502 { return bad_x_point; }
float_type bad_x_point
this point may be used to record where a calculation ran into trouble
Definition: c2_function.hh:551
template<typename float_type = double>
void c2_function< float_type >::increment_evaluations ( ) const
inline

count evaluations

Definition at line 399 of file c2_function.hh.

399 { evaluations++; }
size_t evaluations
Definition: c2_function.hh:548

Here is the caller graph for this function:

template<typename float_type = double>
float_type c2_function< 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

a fully-automated integrator which uses the information provided by the get_sampling_grid() function to figure out what to do.

It returns the integral of the function over the domain requested with error tolerances as specified. It is just a front-end to partial_integrals()

Parameters
aminlower bound of the domain for integration
amaxupper bound of the domain for integration
partialsif non-NULL, a vector in which to receive the partial integrals. It will automatically be sized appropriately, if provided, to contain n - 1 elements where n is the length of xgrid
abs_tolthe absolute error bound for each segment
rel_tolthe fractional error bound for each segment. If the error is smaller than either the relative or absolute tolerance, the integration step is finished.
derivsnumber of derivatives to trust, which sets the order of the integrator. The order is 3*derivs + 4. derivs can be 0, 1, or 2.
adaptif true, use recursive adaptation, otherwise do simple evaluation on the grid provided with no error checking.
extrapolateif true, use simple Richardson extrapolation on the final 2 steps to reduce the error.
Returns
sum of partial integrals, which is the definite integral from the first value in xgrid to the last.
template<typename float_type = double>
c2_function<float_type>& c2_function< float_type >::normalized_function ( float_type  amin,
float_type  amax,
float_type  norm = 1.0 
) const

create a new c2_function from this one which is normalized on the interval

Parameters
aminlower bound of the domain for integration
amaxupper bound of the domain for integration
normthe desired integral for the function over the region
Returns
a new c2_function with the desired norm.
template<typename float_type = double>
float_type c2_function< float_type >::operator() ( float_type  x) const
inline

evaluate the function in the classic way, ignoring derivatives.

Parameters
xthe point at which to evaluate
Returns
the value of the function

Definition at line 186 of file c2_function.hh.

187  { return value_with_derivatives(x, (float_type *)0, (float_type *)0); }
tuple x
Definition: test.py:50
virtual float_type value_with_derivatives(float_type x, float_type *yprime, float_type *yprime2) const =0
get the value and derivatives.
template<typename float_type = double>
float_type c2_function< float_type >::operator() ( float_type  x,
float_type *  yprime,
float_type *  yprime2 
) const
inline

get the value and derivatives.

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

Definition at line 195 of file c2_function.hh.

197  { return value_with_derivatives(x, yprime, yprime2); }
tuple x
Definition: test.py:50
virtual float_type value_with_derivatives(float_type x, float_type *yprime, float_type *yprime2) const =0
get the value and derivatives.
template<typename float_type = double>
c2_composed_function_p<float_type>& c2_function< float_type >::operator() ( const c2_function< float_type > &  inner) const
inline

compose this function outside another.

Parameters
innerthe inner function
Returns
the composed function

Definition at line 495 of file c2_function.hh.

496  { return *new c2_composed_function_p<float_type>((*this), inner); }
template<typename float_type = double>
c2_product_p<float_type>& c2_function< float_type >::operator* ( const c2_function< float_type > &  rhs) const
inline

factory function to create a c2_product_p from a regular algebraic expression.

Parameters
rhsthe right-hand term of the product
Returns
a new c2_function

Definition at line 486 of file c2_function.hh.

487  { return *new c2_product_p<float_type>(*this, rhs); }
create a c2_function which is the product of two other c2_functions.This should always be constructed...
Definition: c2_function.hh:82
template<typename float_type = double>
c2_sum_p<float_type>& c2_function< float_type >::operator+ ( const c2_function< float_type > &  rhs) const
inline

factory function to create a c2_sum_p from a regular algebraic expression.

Parameters
rhsthe right-hand term of the sum
Returns
a new c2_function

Definition at line 473 of file c2_function.hh.

474  { return *new c2_sum_p<float_type>(*this, rhs); }
template<typename float_type = double>
c2_diff_p<float_type>& c2_function< float_type >::operator- ( const c2_function< float_type > &  rhs) const
inline

factory function to create a c2_diff_p from a regular algebraic expression.

Parameters
rhsthe right-hand term of the difference
Returns
a new c2_function

Definition at line 479 of file c2_function.hh.

480  { return *new c2_diff_p<float_type>(*this, rhs); }
template<typename float_type = double>
c2_ratio_p<float_type>& c2_function< float_type >::operator/ ( const c2_function< float_type > &  rhs) const
inline

Definition at line 488 of file c2_function.hh.

489  { return *new c2_ratio_p<float_type>(*this, rhs); }
create a c2_function which is the ratio of two other c2_functions.This should always be constructed u...
Definition: c2_function.hh:83
template<typename float_type = double>
float_type c2_function< 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

solve f(x)=value partial_integrals uses a method with an error O(dx**10) with full information from the derivatives, and falls back to lower order methods if informed of incomplete derivatives. It uses exact midpoint splitting of the intervals for recursion, resulting in no recomputation of the function during recursive descent at previously computed points.

Parameters
xgridpoints between which to evaluate definite integrals.
partialsif non-NULL, a vector in which to receive the partial integrals. It will automatically be sized apprpropriately, if provided, to contain n - 1 elements where n is the length of xgrid
abs_tolthe absolute error bound for each segment
rel_tolthe fractional error bound for each segment. If the error is smaller than either the relative or absolute tolerance, the integration step is finished.
derivsnumber of derivatives to trust, which sets the order of the integrator. The order is 3*derivs + 4. derivs can be 0, 1, or 2.
adaptif true, use recursive adaptation, otherwise do simple evaluation on the grid provided with no error checking.
extrapolateif true, use simple Richardson extrapolation on the final 2 steps to reduce the error.
Returns
sum of partial integrals, which is the definite integral from the first value in xgrid to the last.
template<typename float_type = double>
void c2_function< float_type >::preen_sampling_grid ( std::vector< float_type > *  result) const

The grid is modified in place.

template<typename float_type = double>
void c2_function< float_type >::refine_sampling_grid ( std::vector< float_type > &  grid,
size_t  refinement 
) const
template<typename float_type = double>
void c2_function< float_type >::release_ownership ( ) const
inline

Definition at line 519 of file c2_function.hh.

519  {
520  if(!release_ownership_for_return()) delete this;
521  }
size_t release_ownership_for_return() const
decrement our reference count. Do not destroy at zero.
Definition: c2_function.hh:509
template<typename float_type = double>
size_t c2_function< float_type >::release_ownership_for_return ( ) const
inline

decrement our reference count. Do not destroy at zero.

Returns
final owner count, to check whether object should disappear.

Definition at line 509 of file c2_function.hh.

509  {
510  if(!owner_count) {
511  std::ostringstream outstr;
512  outstr << "attempt to release ownership of an unowned function in class ";
513  outstr << typeid(*this).name() << std::endl;
514  throw c2_exception(outstr.str().c_str());
515  }
516  owner_count--;
517  return owner_count;
518  }
the exception class for c2_function operations.
Definition: c2_function.hh:65

Here is the caller graph for this function:

template<typename float_type = double>
void c2_function< float_type >::reset_evaluations ( ) const
inline

reset the counter

Definition at line 397 of file c2_function.hh.

397 { evaluations=0; }
size_t evaluations
Definition: c2_function.hh:548
template<typename float_type = double>
void c2_function< float_type >::set_domain ( float_type  amin,
float_type  amax 
)
inline

Definition at line 391 of file c2_function.hh.

391 { fXMin=amin; fXMax=amax; }
float_type fXMax
Definition: c2_function.hh:547
float_type fXMin
Definition: c2_function.hh:547

Here is the caller graph for this function:

template<typename float_type = double>
virtual void c2_function< float_type >::set_sampling_grid ( const std::vector< float_type > &  grid)
virtual

establish a grid of 'interesting' points on the function.

The sampling grid describes a reasonable initial set of points to look at the function. this should generally be set at a scale which is quite coarse, and sufficient for initializing adaptive integration or possibly root bracketing. For sampling a function to build a new interpolating function, one may want to refine this for accuracy. However, interpolating_functions themselves return their original X grid by default, so refining the grid in this case might be a bad idea.

Parameters
grida vector of abscissas. The contents is copied into an internal vector, so the grid can be discarded after passingin.
template<typename float_type = double>
virtual void c2_function< float_type >::set_sampling_grid_pointer ( std::vector< float_type > &  grid)
inlineprotectedvirtual

Definition at line 538 of file c2_function.hh.

539  {
542  }
std::vector< float_type > * sampling_grid
Definition: c2_function.hh:544
bool no_overwrite_grid
Definition: c2_function.hh:545

Here is the caller graph for this function:

template<typename float_type = double>
c2_function<float_type>& c2_function< float_type >::square_normalized_function ( float_type  amin,
float_type  amax,
float_type  norm = 1.0 
) const
template<typename float_type = double>
c2_function<float_type>& 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

create a new c2_function from this one which is square-normalized with the provided weight on the interval

Parameters
aminlower bound of the domain for integration
amaxupper bound of the domain for integration
weighta c2_function providing the weight
normthe desired integral for the function over the region
Returns
a new c2_function with the desired norm.
template<typename float_type = double>
virtual float_type c2_function< float_type >::value_with_derivatives ( float_type  x,
float_type *  yprime,
float_type *  yprime2 
) const
pure 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

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

Implemented in c2_piecewise_function_p< float_type >, c2_connector_function_p< float_type >, c2_inverse_function_p< float_type >, c2_power_law_p< float_type >, c2_quadratic_p< float_type >, c2_linear_p< float_type >, c2_linear_p< G4double >, c2_identity_p< float_type >, c2_recip_p< float_type >, c2_sqrt_p< float_type >, c2_exp_p< float_type >, c2_log_p< float_type >, c2_tan_p< float_type >, c2_cos_p< float_type >, c2_sin_p< float_type >, interpolating_function_p< float_type >, c2_constant_p< float_type >, c2_cached_function_p< float_type >, c2_scaled_function_p< float_type >, c2_binary_function< float_type >, c2_plugin_function_p< float_type >, c2_plugin_function_p< G4double >, and c2_classic_function_p< float_type >.

Here is the caller graph for this function:

template<typename float_type = double>
float_type c2_function< float_type >::xmax ( ) const
inline

Definition at line 390 of file c2_function.hh.

390 { return fXMax; }
float_type fXMax
Definition: c2_function.hh:547

Here is the caller graph for this function:

template<typename float_type = double>
float_type c2_function< float_type >::xmin ( ) const
inline

Definition at line 389 of file c2_function.hh.

389 { return fXMin; }
float_type fXMin
Definition: c2_function.hh:547

Here is the caller graph for this function:

Member Data Documentation

template<typename float_type = double>
float_type c2_function< float_type >::bad_x_point
mutableprotected

this point may be used to record where a calculation ran into trouble

Definition at line 551 of file c2_function.hh.

template<typename float_type = double>
size_t c2_function< float_type >::evaluations
mutableprotected

Definition at line 548 of file c2_function.hh.

template<typename float_type = double>
float_type c2_function< float_type >::fXMax
protected

Definition at line 547 of file c2_function.hh.

template<typename float_type = double>
float_type c2_function< float_type >::fXMin
protected

Definition at line 547 of file c2_function.hh.

template<typename float_type = double>
bool c2_function< float_type >::no_overwrite_grid
protected

Definition at line 545 of file c2_function.hh.

template<typename float_type = double>
std::vector<float_type>* c2_function< float_type >::sampling_grid
protected

Definition at line 544 of file c2_function.hh.


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