ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
log_log_interpolating_function_p< float_type > Class Template Reference

A spline with X and Y transformed into log space.Most useful for functions looking like y=x^n or any other function with a huge X and Y dynamic range. More...

#include <geant4/tree/geant4-10.6-release/examples/extended/electromagnetic/TestEm7/include/c2_function.hh>

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

Public Member Functions

 log_log_interpolating_function_p ()
 an empty log-log cubic-spline interpolating_function_p
 
virtual
interpolating_function_p
< float_type > & 
clone () const
 
- Public Member Functions inherited from interpolating_function_p< float_type >
 interpolating_function_p ()
 an empty linear-linear cubic-spline interpolating_function_p
 
 interpolating_function_p (const c2_function_transformation< float_type > &transform)
 an empty cubic-spline interpolating_function_p with a specific transform
 
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)
 do the dirty work of constructing the spline from a function.
 
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)
 do the dirty work of constructing the spline from a function.
 
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)
 do the dirty work of constructing the spline from a function.
 
interpolating_function_p
< float_type > & 
load_random_generator_function (const std::vector< float_type > &bincenters, const c2_function< float_type > &binheights)
 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.
 
interpolating_function_p
< float_type > & 
load_random_generator_bins (const std::vector< float_type > &bins, const std::vector< float_type > &binheights, bool splined=true)
 
virtual float_type value_with_derivatives (float_type x, float_type *yprime, float_type *yprime2) const
 get the value and derivatives.
 
virtual ~interpolating_function_p ()
 destructor
 
void get_data (std::vector< float_type > &xvals, std::vector< float_type > &yvals) const
 
void get_internal_data (std::vector< float_type > &xvals, std::vector< float_type > &yvals, std::vector< float_type > &y2vals) const
 
void set_lower_extrapolation (float_type bound)
 
void set_upper_extrapolation (float_type bound)
 
interpolating_function_p
< float_type > & 
unary_operator (const c2_function< float_type > &source) const
 
interpolating_function_p
< float_type > & 
binary_operator (const c2_function< float_type > &rhs, const c2_binary_function< float_type > *combining_stub) const
 
interpolating_function_p
< float_type > & 
add_pointwise (const c2_function< float_type > &rhs) const
 
interpolating_function_p
< float_type > & 
subtract_pointwise (const c2_function< float_type > &rhs) const
 
interpolating_function_p
< float_type > & 
multiply_pointwise (const c2_function< float_type > &rhs) const
 
interpolating_function_p
< float_type > & 
divide_pointwise (const c2_function< float_type > &rhs) const
 
void clone_data (const interpolating_function_p< float_type > &rhs)
 
- Public Member Functions inherited from c2_function< float_type >
const std::string cvs_header_vers () const
 get versioning information for the header file
 
const std::string cvs_file_vers () const
 get versioning information for the source file
 
virtual ~c2_function ()
 destructor
 
float_type operator() (float_type x) const
 evaluate the function in the classic way, ignoring derivatives.
 
float_type operator() (float_type x, float_type *yprime, float_type *yprime2) const
 get the value and derivatives.
 
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
 
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.
 
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
 
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
 
void increment_evaluations () const
 count evaluations
 
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
 
virtual void set_sampling_grid (const std::vector< float_type > &grid)
 establish a grid of 'interesting' points on the function.
 
std::vector< float_type > * get_sampling_grid_pointer () const
 get the sampling grid, which may be a null pointer
 
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.
 
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
 
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
 
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.
 
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.
 
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.
 
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.
 
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.
 
void claim_ownership () const
 increment our reference count. Destruction is only legal if the count is zero.
 
size_t release_ownership_for_return () const
 decrement our reference count. Do not destroy at zero.
 
void release_ownership () const
 
size_t count_owners () const
 get the reference count, mostly for debugging
 
void fill_fblock (c2_fblock< float_type > &fb) const
 fill in a c2_fblock<float_type>... a shortcut for the integrator & sampler
 

Additional Inherited Members

- Public Attributes inherited from interpolating_function_p< float_type >
const
c2_function_transformation
< float_type > & 
fTransform
 
- Protected Member Functions inherited from interpolating_function_p< float_type >
void spline (bool lowerSlopeNatural, float_type lowerSlope, bool upperSlopeNatural, float_type upperSlope)
 create the spline coefficients
 
- Static Protected Member Functions inherited from interpolating_function_p< float_type >
static bool comp_pair (std::pair< float_type, float_type > const &i, std::pair< float_type, float_type > const &j)
 
- Protected Attributes inherited from interpolating_function_p< float_type >
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
 

Detailed Description

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

A spline with X and Y transformed into log space.

Most useful for functions looking like y=x^n or any other function with a huge X and Y dynamic range.

Definition at line 1763 of file c2_function.hh.

View newest version in sPHENIX GitHub at line 1763 of file c2_function.hh

Constructor & Destructor Documentation

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

an empty log-log cubic-spline interpolating_function_p

Definition at line 1768 of file c2_function.hh.

View newest version in sPHENIX GitHub at line 1768 of file c2_function.hh

Member Function Documentation

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

Reimplemented from interpolating_function_p< float_type >.

Definition at line 1772 of file c2_function.hh.

View newest version in sPHENIX GitHub at line 1772 of file c2_function.hh


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