Base class for explicit steppers with error estimation and stepper fulfilling the FSAL (first-same-as-last) property.
More...
|
| explicit_error_stepper_fsal_base (const algebra_type &algebra=algebra_type()) |
| Constructs a explicit_stepper_fsal_base class. More...
|
|
order_type | order (void) const |
|
order_type | stepper_order (void) const |
|
order_type | error_order (void) const |
|
template<class System , class StateInOut > |
void | do_step (System system, StateInOut &x, time_type t, time_type dt) |
| This method performs one step. More...
|
|
template<class System , class StateInOut > |
void | do_step (System system, const StateInOut &x, time_type t, time_type dt) |
| Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut. More...
|
|
template<class System , class StateInOut , class DerivInOut > |
boost::disable_if
< boost::is_same< StateInOut,
time_type >, void >::type | do_step (System system, StateInOut &x, DerivInOut &dxdt, time_type t, time_type dt) |
| The method performs one step with the stepper passed by Stepper. More...
|
|
template<class System , class StateIn , class StateOut > |
boost::disable_if
< boost::is_same< StateIn,
time_type >, void >::type | do_step (System system, const StateIn &in, time_type t, StateOut &out, time_type dt) |
| The method performs one step with the stepper passed by Stepper. More...
|
|
template<class System , class StateIn , class DerivIn , class StateOut , class DerivOut > |
void | do_step (System system, const StateIn &in, const DerivIn &dxdt_in, time_type t, StateOut &out, DerivOut &dxdt_out, time_type dt) |
| The method performs one step with the stepper passed by Stepper. More...
|
|
template<class System , class StateInOut , class Err > |
void | do_step (System system, StateInOut &x, time_type t, time_type dt, Err &xerr) |
| The method performs one step with the stepper passed by Stepper and estimates the error. More...
|
|
template<class System , class StateInOut , class Err > |
void | do_step (System system, const StateInOut &x, time_type t, time_type dt, Err &xerr) |
| Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut. More...
|
|
template<class System , class StateInOut , class DerivInOut , class Err > |
boost::disable_if
< boost::is_same< StateInOut,
time_type >, void >::type | do_step (System system, StateInOut &x, DerivInOut &dxdt, time_type t, time_type dt, Err &xerr) |
| The method performs one step with the stepper passed by Stepper. More...
|
|
template<class System , class StateIn , class StateOut , class Err > |
void | do_step (System system, const StateIn &in, time_type t, StateOut &out, time_type dt, Err &xerr) |
| The method performs one step with the stepper passed by Stepper. More...
|
|
template<class System , class StateIn , class DerivIn , class StateOut , class DerivOut , class Err > |
void | do_step (System system, const StateIn &in, const DerivIn &dxdt_in, time_type t, StateOut &out, DerivOut &dxdt_out, time_type dt, Err &xerr) |
| The method performs one step with the stepper passed by Stepper. More...
|
|
template<class StateIn > |
void | adjust_size (const StateIn &x) |
| Adjust the size of all temporaries in the stepper manually. More...
|
|
void | reset (void) |
| Resets the internal state of this stepper. More...
|
|
template<class DerivIn > |
void | initialize (const DerivIn &deriv) |
| Initializes the internal state of the stepper. More...
|
|
template<class System , class StateIn > |
void | initialize (System system, const StateIn &x, time_type t) |
| Initializes the internal state of the stepper. More...
|
|
bool | is_initialized (void) const |
| Returns if the stepper is already initialized. More...
|
|
algebra_type & | algebra () |
|
const algebra_type & | algebra () const |
|
template<class Stepper, unsigned short Order, unsigned short StepperOrder, unsigned short ErrorOrder, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
class boost::numeric::odeint::explicit_error_stepper_fsal_base< Stepper, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >
Base class for explicit steppers with error estimation and stepper fulfilling the FSAL (first-same-as-last) property.
This class can be used with controlled steppers for step size control.
This class serves as the base class for all explicit steppers with algebra and operations and which fulfill the FSAL property. In contrast to explicit_stepper_base it also estimates the error and can be used in a controlled stepper to provide step size control.
The FSAL property means that the derivative of the system at t+dt is already used in the current step going from t to t +dt. Therefore, some more do_steps method can be introduced and the controlled steppers can explicitly make use of this property.
- Note
- This stepper provides
do_step
methods with and without error estimation. It has therefore three orders, one for the order of a step if the error is not estimated. The other two orders are the orders of the step and the error step if the error estimation is performed.
explicit_error_stepper_fsal_base is used as the interface in a CRTP (currently recurring template pattern). In order to work correctly the parent class needs to have a method do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt , xerr )
. explicit_error_stepper_fsal_base derives from algebra_stepper_base.
This class can have an intrinsic state depending on the explicit usage of the do_step
method. This means that some do_step
methods are expected to be called in order. For example the do_step( sys , x , t , dt , xerr )
will keep track of the derivative of x
which is the internal state. The first call of this method is recognized such that one does not explicitly initialize the internal state, so it is safe to use this method like
stepper.do_step( sys ,
x ,
t , dt , xerr );
stepper.do_step( sys ,
x ,
t , dt , xerr );
stepper.do_step( sys ,
x ,
t , dt , xerr );
But it is unsafe to call this method with different system functions after each other. Do do so, one must initialize the internal state with the initialize
method or reset the internal state with the reset
method.
explicit_error_stepper_fsal_base provides several overloaded do_step
methods, see the list below. Only two of them are needed to fulfill the Error Stepper concept. The other ones are for convenience and for better performance. Some of them simply update the state out-of-place, while other expect that the first derivative at t
is passed to the stepper.
do_step( sys , x , t , dt )
- The classical do_step
method needed to fulfill the Error Stepper concept. The state is updated in-place. A type modelling a Boost.Range can be used for x.
do_step( sys , x , dxdt , t , dt )
- This method updates the state x and the derivative dxdt in-place. It is expected that dxdt has the value of the derivative of x at time t.
do_step( sys , in , t , out , dt )
- This method updates the state out-of-place, hence the result of the step is stored in out
.
do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )
- This method updates the state and the derivative out-of-place. It expects that the derivative at the point t
is explicitly passed in dxdt_in
.
do_step( sys , x , t , dt , xerr )
- This do_step
method is needed to fulfill the Error Stepper concept. The state is updated in-place and an error estimate is calculated. A type modelling a Boost.Range can be used for x.
do_step( sys , x , dxdt , t , dt , xerr )
- This method updates the state and the derivative in-place. It is assumed that the dxdt has the value of the derivative of x at time t. An error estimate is calculated.
do_step( sys , in , t , out , dt , xerr )
- This method updates the state out-of-place and estimates the error during the step.
do_step( sys , in , dxdt_in , t , out , dxdt_out , dt , xerr )
- This methods updates the state and the derivative out-of-place and estimates the error during the step. It is assumed the dxdt_in is derivative of in at time t.
- Note
- The system is always passed as value, which might result in poor performance if it contains data. In this case it can be used with
boost::ref
or std::ref
, for example stepper.do_step( boost::ref( sys ) , x , t , dt );
-
The time
t
is not advanced by the stepper. This has to done manually, or by the appropriate integrate
routines or iterator
s.
- Template Parameters
-
Stepper | The stepper on which this class should work. It is used via CRTP, hence explicit_stepper_base provides the interface for the Stepper. |
Order | The order of a stepper if the stepper is used without error estimation. |
StepperOrder | The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have the same value. |
ErrorOrder | The order of the error step if the stepper is used with error estimation. |
State | The state type for the stepper. |
Value | The value type for the stepper. This should be a floating point type, like float, double, or a multiprecision type. It must not necessary be the value_type of the State. For example the State can be a vector< complex< double > > in this case the Value must be double. The default value is double. |
Deriv | The type representing time derivatives of the state type. It is usually the same type as the state type, only if used with Boost.Units both types differ. |
Time | The type representing the time. Usually the same type as the value type. When Boost.Units is used, this type has usually a unit. |
Algebra | The algebra type which must fulfill the Algebra Concept. |
Operations | The type for the operations which must fulfill the Operations Concept. |
Resizer | The resizer policy class. |
template<class Stepper, unsigned short Order, unsigned short StepperOrder, unsigned short ErrorOrder, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateInOut , class DerivInOut >
boost::numeric::odeint::explicit_error_stepper_fsal_base< Stepper, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step |
( |
System |
system, |
|
|
StateInOut & |
x, |
|
|
DerivInOut & |
dxdt, |
|
|
time_type |
t, |
|
|
time_type |
dt |
|
) |
| |
|
inline |
The method performs one step with the stepper passed by Stepper.
Additionally to the other methods the derivative of x is also passed to this method. Therefore, dxdt must be evaluated initially:
for( ... )
{
stepper.do_step( ode ,
x , dxdt ,
t , dt );
}
- Note
- This method does NOT use the initial state, since the first derivative is explicitly passed to this method.
The result is updated in place in x as well as the derivative dxdt. This method is disabled if Time and StateInOut are of the same type. In this case the method could not be distinguished from other do_step
versions.
- Note
- This method does not solve the forwarding problem.
- Parameters
-
system | The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept. |
x | The state of the ODE which should be solved. After calling do_step the result is updated in x. |
dxdt | The derivative of x at t. After calling do_step dxdt is updated to the new value. |
t | The value of the time, at which the step should be performed. |
dt | The step size. |
template<class Stepper, unsigned short Order, unsigned short StepperOrder, unsigned short ErrorOrder, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateIn , class StateOut >
boost::numeric::odeint::explicit_error_stepper_fsal_base< Stepper, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step |
( |
System |
system, |
|
|
const StateIn & |
in, |
|
|
time_type |
t, |
|
|
StateOut & |
out, |
|
|
time_type |
dt |
|
) |
| |
|
inline |
The method performs one step with the stepper passed by Stepper.
The state of the ODE is updated out-of-place. This method is disabled if StateIn and Time are the same type. In this case the method can not be distinguished from other do_step
variants.
- Note
- This method uses the internal state of the stepper.
-
This method does not solve the forwarding problem.
- Parameters
-
system | The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept. |
in | The state of the ODE which should be solved. in is not modified in this method |
t | The value of the time, at which the step should be performed. |
out | The result of the step is written in out. |
dt | The step size. |
template<class Stepper, unsigned short Order, unsigned short StepperOrder, unsigned short ErrorOrder, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateIn , class DerivIn , class StateOut , class DerivOut >
boost::numeric::odeint::explicit_error_stepper_fsal_base< Stepper, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step |
( |
System |
system, |
|
|
const StateIn & |
in, |
|
|
const DerivIn & |
dxdt_in, |
|
|
time_type |
t, |
|
|
StateOut & |
out, |
|
|
DerivOut & |
dxdt_out, |
|
|
time_type |
dt |
|
) |
| |
|
inline |
The method performs one step with the stepper passed by Stepper.
The state of the ODE is updated out-of-place. Furthermore, the derivative of x at t is passed to the stepper and updated by the stepper to its new value at t+dt.
- Note
- This method does not solve the forwarding problem.
-
This method does NOT use the internal state of the stepper.
- Parameters
-
system | The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept. |
in | The state of the ODE which should be solved. in is not modified in this method |
dxdt_in | The derivative of x at t. |
t | The value of the time, at which the step should be performed. |
out | The result of the step is written in out. |
dxdt_out | The updated derivative of out at t+dt . |
dt | The step size. |
template<class Stepper, unsigned short Order, unsigned short StepperOrder, unsigned short ErrorOrder, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateInOut , class DerivInOut , class Err >
boost::numeric::odeint::explicit_error_stepper_fsal_base< Stepper, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step |
( |
System |
system, |
|
|
StateInOut & |
x, |
|
|
DerivInOut & |
dxdt, |
|
|
time_type |
t, |
|
|
time_type |
dt, |
|
|
Err & |
xerr |
|
) |
| |
|
inline |
The method performs one step with the stepper passed by Stepper.
Additionally to the other method the derivative of x is also passed to this method and updated by this method.
- Note
- This method does NOT use the internal state of the stepper.
The result is updated in place in x. This method is disabled if Time and Deriv are of the same type. In this case the method could not be distinguished from other do_step
versions. This method is disabled if StateInOut and Time are of the same type.
- Note
- This method does NOT use the internal state of the stepper.
-
This method does not solve the forwarding problem.
- Parameters
-
system | The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept. |
x | The state of the ODE which should be solved. After calling do_step the result is updated in x. |
dxdt | The derivative of x at t. After calling do_step this value is updated to the new value at t+dt . |
t | The value of the time, at which the step should be performed. |
dt | The step size. |
xerr | The error estimate is stored in xerr. |
template<class Stepper, unsigned short Order, unsigned short StepperOrder, unsigned short ErrorOrder, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateIn , class StateOut , class Err >
boost::numeric::odeint::explicit_error_stepper_fsal_base< Stepper, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step |
( |
System |
system, |
|
|
const StateIn & |
in, |
|
|
time_type |
t, |
|
|
StateOut & |
out, |
|
|
time_type |
dt, |
|
|
Err & |
xerr |
|
) |
| |
|
inline |
The method performs one step with the stepper passed by Stepper.
The state of the ODE is updated out-of-place. Furthermore, the error is estimated.
- Note
- This method uses the internal state of the stepper.
-
This method does not solve the forwarding problem.
- Parameters
-
system | The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept. |
in | The state of the ODE which should be solved. in is not modified in this method |
t | The value of the time, at which the step should be performed. |
out | The result of the step is written in out. |
dt | The step size. |
xerr | The error estimate. |
template<class Stepper, unsigned short Order, unsigned short StepperOrder, unsigned short ErrorOrder, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateIn , class DerivIn , class StateOut , class DerivOut , class Err >
boost::numeric::odeint::explicit_error_stepper_fsal_base< Stepper, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step |
( |
System |
system, |
|
|
const StateIn & |
in, |
|
|
const DerivIn & |
dxdt_in, |
|
|
time_type |
t, |
|
|
StateOut & |
out, |
|
|
DerivOut & |
dxdt_out, |
|
|
time_type |
dt, |
|
|
Err & |
xerr |
|
) |
| |
|
inline |
The method performs one step with the stepper passed by Stepper.
The state of the ODE is updated out-of-place. Furthermore, the derivative of x at t is passed to the stepper and the error is estimated.
- Note
- This method does NOT use the internal state of the stepper.
-
This method does not solve the forwarding problem.
- Parameters
-
system | The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept. |
in | The state of the ODE which should be solved. in is not modified in this method |
dxdt_in | The derivative of x at t. |
t | The value of the time, at which the step should be performed. |
out | The result of the step is written in out. |
dxdt_out | The new derivative at t+dt is written into this variable. |
dt | The step size. |
xerr | The error estimate. |