Class template explicit_error_stepper_base

boost::numeric::odeint::explicit_error_stepper_base — Base class for explicit steppers with error estimation. This class can used with controlled steppers for step size control.

Synopsis

// In header: <boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp>

template<typename Stepper, unsigned short Order, unsigned short StepperOrder, 
         unsigned short ErrorOrder, typename State, typename Value, 
         typename Deriv, typename Time, typename Algebra, typename Operations, 
         typename Resizer> 
class explicit_error_stepper_base :
  public boost::numeric::odeint::algebra_stepper_base< Algebra, Operations >
{
public:
  // types
  typedef algebra_stepper_base< Algebra, Operations > algebra_stepper_base_type;
  typedef algebra_stepper_base_type::algebra_type     algebra_type;             
  typedef State                                       state_type;               
  typedef Value                                       value_type;               
  typedef Deriv                                       deriv_type;               
  typedef Time                                        time_type;                
  typedef Resizer                                     resizer_type;             
  typedef Stepper                                     stepper_type;             
  typedef explicit_error_stepper_tag                  stepper_category;         
  typedef unsigned short                              order_type;               

  // construct/copy/destruct
  explicit_error_stepper_base(const algebra_type & = algebra_type());

  // public member functions
  order_type order(void) const;
  order_type stepper_order(void) const;
  order_type error_order(void) const;
  template<typename System, typename StateInOut> 
    void do_step(System, StateInOut &, time_type, time_type);
  template<typename System, typename StateInOut> 
    void do_step(System, const StateInOut &, time_type, time_type);
  template<typename System, typename StateInOut, typename DerivIn> 
    boost::disable_if< boost::is_same< DerivIn, time_type >, void >::type 
    do_step(System, StateInOut &, const DerivIn &, time_type, time_type);
  template<typename System, typename StateIn, typename StateOut> 
    boost::disable_if< boost::is_same< StateIn, time_type >, void >::type 
    do_step(System, const StateIn &, time_type, StateOut &, time_type);
  template<typename System, typename StateIn, typename DerivIn, 
           typename StateOut> 
    boost::disable_if< boost::is_same< DerivIn, time_type >, void >::type 
    do_step(System, const StateIn &, const DerivIn &, time_type, StateOut &, 
            time_type);
  template<typename System, typename StateInOut, typename Err> 
    void do_step(System, StateInOut &, time_type, time_type, Err &);
  template<typename System, typename StateInOut, typename Err> 
    void do_step(System, const StateInOut &, time_type, time_type, Err &);
  template<typename System, typename StateInOut, typename DerivIn, 
           typename Err> 
    boost::disable_if< boost::is_same< DerivIn, time_type >, void >::type 
    do_step(System, StateInOut &, const DerivIn &, time_type, time_type, 
            Err &);
  template<typename System, typename StateIn, typename StateOut, typename Err> 
    void do_step(System, const StateIn &, time_type, StateOut &, time_type, 
                 Err &);
  template<typename System, typename StateIn, typename DerivIn, 
           typename StateOut, typename Err> 
    void do_step(System, const StateIn &, const DerivIn &, time_type, 
                 StateOut &, time_type, Err &);
  template<typename StateIn> void adjust_size(const StateIn &);
  algebra_type & algebra();
  const algebra_type & algebra() const;

  // private member functions
  template<typename System, typename StateInOut> 
    void do_step_v1(System, StateInOut &, time_type, time_type);
  template<typename System, typename StateInOut, typename Err> 
    void do_step_v5(System, StateInOut &, time_type, time_type, Err &);
  template<typename StateIn> bool resize_impl(const StateIn &);
  stepper_type & stepper(void);
  const stepper_type & stepper(void) const;

  // public data members
  static const order_type order_value;
  static const order_type stepper_order_value;
  static const order_type error_order_value;
};

Description

This class serves as the base class for all explicit steppers with algebra and operations. In contrast to explicit_stepper_base it also estimates the error and can be used in a controlled stepper to provide step size control.

	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_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 , xerr ). explicit_error_stepper_base derives from algebra_stepper_base.

explicit_error_stepper_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 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 in-place, but the derivative at the point t must be explicitly passed in dxdt.
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 , 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.
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 in-place, but the derivative at the point t must be passed in dxdt. 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 , t , out , dt , xerr ) - This methods updates the state out-of-place and estimates the error during the step. Furthermore, the derivative at t must be passed in dxdt.

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

```
typename Stepper
```
The stepper on which this class should work. It is used via CRTP, hence explicit_stepper_base provides the interface for the Stepper.
```
unsigned short Order
```
The order of a stepper if the stepper is used without error estimation.
```
unsigned short StepperOrder
```
The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have the same value.
```
unsigned short ErrorOrder
```
The order of the error step if the stepper is used with error estimation.
```
typename State
```
The state type for the stepper.
```
typename 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.
```
typename 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.
```
typename 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.
```
typename Algebra
```
The algebra type which must fulfill the Algebra Concept.
```
typename Operations
```
The type for the operations which must fulfill the Operations Concept.
```
typename Resizer
```
The resizer policy class.

`explicit_error_stepper_base` public construct/copy/destruct

```
explicit_error_stepper_base(const algebra_type & algebra = algebra_type());
```
Constructs a explicit_error_stepper_base class. This constructor can be used as a default constructor if the algebra has a default constructor.

Parameters:

algebra

A copy of algebra is made and stored inside explicit_stepper_base.

`explicit_error_stepper_base` public member functions

```
order_type order(void) const;
```
Returns:

Returns the order of the stepper if it used without error estimation.
```
order_type stepper_order(void) const;
```
Returns:

Returns the order of a step if the stepper is used without error estimation.
```
order_type error_order(void) const;
```
Returns:

Returns the order of an error step if the stepper is used without error estimation.

template<typename System, typename StateInOut> 
  void do_step(System system, StateInOut & x, time_type t, time_type dt);

This method performs one step. It transforms the result in-place.

Parameters:

`dt`	The step size.
`system`	The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the Simple System concept.
`t`	The value of the time, at which the step should be performed.
`x`	The state of the ODE which should be solved. After calling do_step the result is updated in x.

template<typename System, typename 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.

template<typename System, typename StateInOut, typename 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 with the stepper passed by Stepper. 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:

sys( x , dxdt , t );
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:

`dt`	The step size.
`dxdt`	The derivative of x at t.
`system`	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
`t`	The value of the time, at which the step should be performed.
`x`	The state of the ODE which should be solved. After calling do_step the result is updated in x.

template<typename System, typename StateIn, typename 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. 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 does not solve the forwarding problem.

Parameters:

`dt`	The step size.
`in`	The state of the ODE which should be solved. in is not modified in this method
`out`	The result of the step is written in out.
`system`	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
`t`	The value of the time, at which the step should be performed.

template<typename System, typename StateIn, typename DerivIn, 
         typename StateOut> 
  boost::disable_if< boost::is_same< DerivIn, time_type >, void >::type 
  do_step(System system, const StateIn & in, const DerivIn & dxdt, 
          time_type t, StateOut & out, time_type dt);

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. It is supposed to be used in the following way:

sys( in , dxdt , t );
stepper.do_step( sys , in , dxdt , t , out , dt );

This method is disabled if DerivIn and Time are of same type.

	Note
	This method does not solve the forwarding problem.

Parameters:

`dt`	The step size.
`dxdt`	The derivative of x at t.
`in`	The state of the ODE which should be solved. in is not modified in this method
`out`	The result of the step is written in out.
`system`	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
`t`	The value of the time, at which the step should be performed.

template<typename System, typename StateInOut, typename 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. The state of the ODE is updated in-place.

Parameters:

`dt`	The step size.
`system`	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
`t`	The value of the time, at which the step should be performed.
`x`	The state of the ODE which should be solved. x is updated by this method.
`xerr`	The estimation of the error is stored in xerr.

template<typename System, typename StateInOut, typename 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.

template<typename System, typename StateInOut, typename DerivIn, typename Err> 
  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, Err & xerr);

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. It is supposed to be used in the following way:

sys( x , dxdt , t );
stepper.do_step( sys , x , dxdt , t , dt , xerr );

The result is updated in place in x. This method is disabled if Time and DerivIn 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:

`dt`	The step size.
`dxdt`	The derivative of x at t.
`system`	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
`t`	The value of the time, at which the step should be performed.
`x`	The state of the ODE which should be solved. After calling do_step the result is updated in x.
`xerr`	The error estimate is stored in xerr.

template<typename System, typename StateIn, typename StateOut, typename 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. The state of the ODE is updated out-of-place. Furthermore, the error is estimated.

	Note
	This method does not solve the forwarding problem.

Parameters:

`dt`	The step size.
`in`	The state of the ODE which should be solved. in is not modified in this method
`out`	The result of the step is written in out.
`system`	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
`t`	The value of the time, at which the step should be performed.
`xerr`	The error estimate.

template<typename System, typename StateIn, typename DerivIn, 
         typename StateOut, typename Err> 
  void do_step(System system, const StateIn & in, const DerivIn & dxdt, 
               time_type t, StateOut & out, time_type dt, Err & xerr);

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. It is supposed to be used in the following way:

sys( in , dxdt , t );
stepper.do_step( sys , in , dxdt , t , out , dt );

This method is disabled if DerivIn and Time are of same type.

	Note
	This method does not solve the forwarding problem.

Parameters:

`dt`	The step size.
`dxdt`	The derivative of x at t.
`in`	The state of the ODE which should be solved. in is not modified in this method
`out`	The result of the step is written in out.
`system`	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
`t`	The value of the time, at which the step should be performed.
`xerr`	The error estimate.

```
template<typename StateIn> void adjust_size(const StateIn & x);
```
Adjust the size of all temporaries in the stepper manually.

Parameters:

x

A state from which the size of the temporaries to be resized is deduced.
```
algebra_type & algebra();
```
Returns:

A reference to the algebra which is held by this class.
```
const algebra_type & algebra() const;
```
Returns:

A const reference to the algebra which is held by this class.

`explicit_error_stepper_base` private member functions

template<typename System, typename StateInOut> 
  void do_step_v1(System system, StateInOut & x, time_type t, time_type dt);

template<typename System, typename StateInOut, typename Err> 
  void do_step_v5(System system, StateInOut & x, time_type t, time_type dt, 
                  Err & xerr);

template<typename StateIn> bool resize_impl(const StateIn & x);

```
stepper_type & stepper(void);
```

const stepper_type & stepper(void) const;

Boost C++ Libraries