create a c2_function which smoothly connects two other c2_functions.This takes two points and generates a polynomial which matches two c2_function arguments at those two points, with two derivatives at each point, and an arbitrary value at the center of the region. It is useful for splicing together functions over rough spots (0/0, for example). More...
#include <c2_function.hh>
Inheritance diagram for c2_connector_function_p< float_type >:
Collaboration diagram for c2_connector_function_p< float_type >:
Public Member Functions | |
| c2_connector_function_p (float_type x0, const c2_function< float_type > &f0, float_type x2, const c2_function< float_type > &f2, bool auto_center, float_type y1) | |
| construct the container from two functions More... | |
| c2_connector_function_p (float_type x0, float_type y0, float_type yp0, float_type ypp0, float_type x2, float_type y2, float_type yp2, float_type ypp2, bool auto_center, float_type y1) | |
| construct the container from numerical values More... | |
| c2_connector_function_p (const c2_fblock< float_type > &fb0, const c2_fblock< float_type > &fb2, bool auto_center, float_type y1) | |
| construct the container from c2_fblock<float_type> objects More... | |
| virtual | ~c2_connector_function_p () |
| destructor 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... | |
 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 | |
| void | init (const c2_fblock< float_type > &fb0, const c2_fblock< float_type > &fb2, bool auto_center, float_type y1) |
| fill container numerically 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) |
Protected Attributes | |
| float_type | fhinv |
| float_type | fy1 |
| float_type | fa |
| float_type | fb |
| float_type | fc |
| float_type | fd |
| float_type | fe |
| float_type | ff |
| 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 c2_connector_function_p< float_type >
create a c2_function which smoothly connects two other c2_functions.
This takes two points and generates a polynomial which matches two c2_function arguments at those two points, with two derivatives at each point, and an arbitrary value at the center of the region. It is useful for splicing together functions over rough spots (0/0, for example).
If auto_center is true, the value at the midpoint is computed so that the resulting polynomial is of order 5. If auto_center is false, the value y1 is used at the midpoint, resulting in a polynomial of order 6.
This is usually used in conjunction with c2_piecewise_function_p to assemble an apparently seamless function from a series of segments.
- See Also
- Sample Applications and Adaptive sampling
The factory function c2_factory::connector_function() creates *new c2_connector_function_p
Definition at line 1996 of file c2_function.hh.
Constructor & Destructor Documentation
template<typename float_type = double>
| c2_connector_function_p< float_type >::c2_connector_function_p | ( | float_type | x0, |
| const c2_function< float_type > & | f0, | ||
| float_type | x2, | ||
| const c2_function< float_type > & | f2, | ||
| bool | auto_center, | ||
| float_type | y1 | ||
| ) |
construct the container from two functions
- Parameters
-
x0 the point at which to match f1 and its derivatives f0 the function on the left side to be connected x2 the point at which to match f2 and its derivatives f2 the function on the right side to be connected auto_center if true, no midpoint value is specified. If false, match the value y1 at the midpoint y1 the value to match at the midpoint, if auto_center is false
- Returns
- a c2_function with domain (x0,x2) which smoothly connects f0(x0) and f2(x2)
template<typename float_type = double>
| c2_connector_function_p< float_type >::c2_connector_function_p | ( | float_type | x0, |
| float_type | y0, | ||
| float_type | yp0, | ||
| float_type | ypp0, | ||
| float_type | x2, | ||
| float_type | y2, | ||
| float_type | yp2, | ||
| float_type | ypp2, | ||
| bool | auto_center, | ||
| float_type | y1 | ||
| ) |
construct the container from numerical values
- Parameters
-
x0 the position of the left edge y0 the function derivative on the left boundary yp0 the function second derivative on the left boundary ypp0 the function value on the left boundary x2 the position of the right edge y2 the function derivative on the right boundary yp2 the function second derivative on the right boundary ypp2 the function value on the right boundary auto_center if true, no midpoint value is specified. If false, match the value y1 at the midpoint y1 the value to match at the midpoint, if auto_center is false
- Returns
- a c2_function with domain (x0,x2) which smoothly connects the points described
template<typename float_type = double>
| c2_connector_function_p< float_type >::c2_connector_function_p | ( | const c2_fblock< float_type > & | fb0, |
| const c2_fblock< float_type > & | fb2, | ||
| bool | auto_center, | ||
| float_type | y1 | ||
| ) |
construct the container from c2_fblock<float_type> objects
- Parameters
-
fb0 the left edge fb2 the right edge auto_center if true, no midpoint value is specified. If false, match the value y1 at the midpoint y1 the value to match at the midpoint, if auto_center is false
- Returns
- a c2_function with domain (fb0.x,fb2.x) which smoothly connects fb0 and fb2
template<typename float_type = double>
|
virtual |
destructor
Member Function Documentation
template<typename float_type = double>
|
protected |
fill container numerically
template<typename float_type = double>
|
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)
- Returns
- the value of the function
Implements c2_function< float_type >.
Member Data Documentation
template<typename float_type = double>
|
protected |
Definition at line 2046 of file c2_function.hh.
template<typename float_type = double>
|
protected |
Definition at line 2046 of file c2_function.hh.
template<typename float_type = double>
|
protected |
Definition at line 2046 of file c2_function.hh.
template<typename float_type = double>
|
protected |
Definition at line 2046 of file c2_function.hh.
template<typename float_type = double>
|
protected |
Definition at line 2046 of file c2_function.hh.
template<typename float_type = double>
|
protected |
Definition at line 2046 of file c2_function.hh.
template<typename float_type = double>
|
protected |
Definition at line 2046 of file c2_function.hh.
template<typename float_type = double>
|
protected |
Definition at line 2046 of file c2_function.hh.
The documentation for this class was generated from the following file:
- source/examples/extended/electromagnetic/TestEm7/include/c2_function.hh
