|
Geant4.10
|
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
|
Geant4.10
|
create the formal inverse function of another functionfor example, given a c2_function f More...
#include <c2_function.hh>
Public Member Functions | |
| c2_inverse_function_p (const c2_function< float_type > &source) | |
| Construct the operator. 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... | |
| void | set_start_hint (float_type hint) const |
| give the function a hint as to where to look for its inverse More... | |
| virtual float_type | get_start_hint (float_type x) const |
| get the starting hint. More... | |
| void | set_hinting_function (const c2_function< float_type > *hint_func) |
| set or unset the approximate function used to start the root finder More... | |
| void | set_hinting_function (const c2_const_ptr< float_type > hint_func) |
| set the hinting function from a pointer. 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... | |
Protected Member Functions | |
| c2_inverse_function_p () | |
| 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) |
Protected Attributes | |
| float_type | start_hint |
| const c2_const_ptr< float_type > | func |
| c2_const_ptr< float_type > | hinting_function |
| 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... | |
create the formal inverse function of another function
for example, given a c2_function f
will return x1=x to machine precision. The important part of this is that the resulting function is a first-class c2_function, so it knows its derivatives, too, unlike the case of a simple root-finding inverse. This means it can be integrated (for example) quite efficiently.
The factory function c2_factory::inverse_function() creates *new c2_inverse_function_p
Definition at line 1907 of file c2_function.hh.
| c2_inverse_function_p< float_type >::c2_inverse_function_p | ( | const c2_function< float_type > & | source | ) |
Construct the operator.
| source | the function to be inverted |
|
inlineprotected |
Definition at line 1952 of file c2_function.hh.
|
inlinevirtual |
get the starting hint.
This is virtual so if there is a better way, this can be easily overridden. It is used in value_with_derivatives() to guess where to start the root finder.
| x | the abscissa for which an estimate is needed |
Definition at line 1923 of file c2_function.hh.
References c2_inverse_function_p< float_type >::hinting_function, and c2_inverse_function_p< float_type >::start_hint.
|
inline |
set or unset the approximate function used to start the root finder
A hinting function is mostly useful if the evaluation of this inverse is going to be carried out in very non-local order, so the root finder has to start over for each step. If most evaluations are going to be made in fairly localized clusters (scanning through the function, for example), the default mechanism used (which just remembers the last point) is almost certainly faster.
Typically, the hinting function is likely to be set up by creating the inverse function, and then adaptively sampling an interpolating function from it, and then using the result to hint it. Another way, if the parent function is already an interpolating function, is just to create a version of the parent with the x & y coordinates reversed.
| hint_func | the function that is an approximate inverse of the parent of this inverse_function |
Definition at line 1942 of file c2_function.hh.
References c2_inverse_function_p< float_type >::hinting_function.
|
inline |
set the hinting function from a pointer.
See discussion
| hint_func | the container holding the function |
Definition at line 1948 of file c2_function.hh.
References c2_inverse_function_p< float_type >::hinting_function.
|
inline |
give the function a hint as to where to look for its inverse
| hint | the likely value of the inverse, which defaults to whatever the evaluation returned. |
Definition at line 1916 of file c2_function.hh.
References c2_inverse_function_p< float_type >::start_hint.
|
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.
| [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) |
Implements c2_function< float_type >.
|
protected |
Definition at line 1954 of file c2_function.hh.
|
protected |
Definition at line 1955 of file c2_function.hh.
Referenced by c2_inverse_function_p< float_type >::get_start_hint(), and c2_inverse_function_p< float_type >::set_hinting_function().
|
mutableprotected |
Definition at line 1953 of file c2_function.hh.
Referenced by c2_inverse_function_p< float_type >::get_start_hint(), and c2_inverse_function_p< float_type >::set_start_hint().
1.8.7