Base class for explicit steppers without step size control and without dense output.
More...
|
| | explicit_stepper_base (const algebra_type &algebra=algebra_type()) |
| | Constructs a explicit_stepper_base class. More...
|
| |
| order_type | 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 DerivIn > |
boost::disable_if
< boost::is_same< DerivIn,
time_type >, void >::type | do_step (System system, StateInOut &x, const DerivIn &dxdt, time_type t, time_type dt) |
| | The method performs one step. More...
|
| |
| template<class System , class StateIn , class StateOut > |
| void | do_step (System system, const StateIn &in, time_type t, StateOut &out, time_type dt) |
| | The method performs one step. More...
|
| |
| template<class System , class StateIn , class DerivIn , class StateOut > |
| void | do_step (System system, const StateIn &in, const DerivIn &dxdt, time_type t, StateOut &out, time_type dt) |
| | The method performs one step. More...
|
| |
| template<class StateIn > |
| void | adjust_size (const StateIn &x) |
| | Adjust the size of all temporaries in the stepper manually. More...
|
| |
| algebra_type & | algebra () |
| |
| const algebra_type & | algebra () const |
| |
template<class Stepper, unsigned short Order, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
class boost::numeric::odeint::explicit_stepper_base< Stepper, Order, State, Value, Deriv, Time, Algebra, Operations, Resizer >
Base class for explicit steppers without step size control and without dense output.
This class serves as the base class for all explicit steppers with algebra and operations. Step size control and error estimation as well as dense output are not provided. explicit_stepper_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 , dt ). This is method is used by explicit_stepper_base. explicit_stepper_base derives from algebra_stepper_base. An example how this class can be used is
template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resizer >
class custom_euler :
public explicit_stepper_base< 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
{
public:
typedef explicit_stepper_base< 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer > base_type;
custom_euler(
const Algebra &
algebra = Algebra() ) { }
template< class Sys , class StateIn , class DerivIn , class StateOut >
void do_step_impl( Sys sys ,
const StateIn &
in ,
const DerivIn &dxdt , Time
t , StateOut &
out , Time dt )
{
m_algebra.for_each3( out , in , dxdt , Operations::scale_sum2< Value , Time >( 1.0 , dt );
}
template< class State >
{
base_type::adjust_size( x );
}
};
For the Stepper concept only the do_step( sys , x , t , dt ) needs to be implemented. But this class provides additional do_step variants since the stepper is explicit. These methods can be used to increase the performance in some situation, for example if one needs to analyze dxdt during each step. In this case one can use
stepper.do_step( sys ,
x , dxdt , t , dt );
t += dt;
In detail explicit_stepper_base provides the following do_step variants
do_step( sys , x , t , dt ) - The classical do_step method needed to fulfill the Stepper concept. The state is updated in-place. A type modelling a Boost.Range can be used for x.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 , x , dxdt , t , dt ) - This method updates the state in-place, but the derivative at the point t must be explicitly passed in dxdt. For an example see the code snippet above.do_step( sys , in , dxdt , t , out , dt ) - This method update the state out-of-place and expects that the derivative at the point t is explicitly passed in dxdt. It is a combination of the two do_step methods above.
- 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 iterators.
- 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 the stepper. |
| 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, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateInOut >
| boost::numeric::odeint::explicit_stepper_base< Stepper, Order, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step |
( |
System |
system, |
|
|
StateInOut & |
x, |
|
|
time_type |
t, |
|
|
time_type |
dt |
|
) |
| |
|
inline |
template<class Stepper, unsigned short Order, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateInOut , class DerivIn >
| boost::numeric::odeint::explicit_stepper_base< Stepper, Order, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step |
( |
System |
system, |
|
|
StateInOut & |
x, |
|
|
const DerivIn & |
dxdt, |
|
|
time_type |
t, |
|
|
time_type |
dt |
|
) |
| |
|
inline |
The method performs one step.
Additionally to the other method the derivative of x is also passed to this method. It is supposed to be used in the following way:
stepper.do_step( sys ,
x , dxdt , t , dt );
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.
- 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. |
| t | The value of the time, at which the step should be performed. |
| dt | The step size. |
template<class Stepper, unsigned short Order, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateIn , class StateOut >
| void boost::numeric::odeint::explicit_stepper_base< Stepper, Order, 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.
The state of the ODE is updated out-of-place.
- 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. |
| 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, class State, class Value, class Deriv, class Time, class Algebra, class Operations, class Resizer>
template<class System , class StateIn , class DerivIn , class StateOut >
| void boost::numeric::odeint::explicit_stepper_base< Stepper, Order, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step |
( |
System |
system, |
|
|
const StateIn & |
in, |
|
|
const DerivIn & |
dxdt, |
|
|
time_type |
t, |
|
|
StateOut & |
out, |
|
|
time_type |
dt |
|
) |
| |
|
inline |
The method performs one step.
The state of the ODE is updated out-of-place. Furthermore, the derivative of x at t is passed to the stepper. It is supposed to be used in the following way:
sys( in , dxdt , t );
stepper.do_step( sys , in , dxdt , t , out , dt );
- 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. |
| in | The state of the ODE which should be solved. in is not modified in this method |
| dxdt | 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. |
| dt | The step size. |
1.8.8