| Home | Libraries | People | FAQ | More

## Class template explicit_error_generic_rk

boost::numeric::odeint::explicit_error_generic_rk — A generic implementation of explicit Runge-Kutta algorithms with error estimation. This class is as a base class for all explicit Runge-Kutta steppers with error estimation.

## Synopsis

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

    template<size_t StageCount, size_t Order, size_t StepperOrder,
             size_t ErrorOrder, typename State, typename Value = double,
             typename Deriv = State, typename Time = Value,
             typename Algebra = typename algebra_dispatcher< State >::algebra_type,
             typename Operations = typename operations_dispatcher< State >::operations_type,
             typename Resizer = initially_resizer>
    class explicit_error_generic_rk : public explicit_error_stepper_base {
    public:
      // types
      typedef explicit_stepper_base< ... >          stepper_base_type;
      typedef stepper_base_type::state_type         state_type;
      typedef stepper_base_type::wrapped_state_type wrapped_state_type;
      typedef stepper_base_type::value_type         value_type;
      typedef stepper_base_type::deriv_type         deriv_type;
      typedef stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
      typedef stepper_base_type::time_type          time_type;
      typedef stepper_base_type::algebra_type       algebra_type;
      typedef stepper_base_type::operations_type    operations_type;
      typedef stepper_base_type::resizer_type       resizer_type;
      typedef unspecified                           rk_algorithm_type;
      typedef rk_algorithm_type::coef_a_type        coef_a_type;
      typedef rk_algorithm_type::coef_b_type        coef_b_type;
      typedef rk_algorithm_type::coef_c_type        coef_c_type;

      // public member functions
      explicit_error_generic_rk(const coef_a_type &, const coef_b_type &,
                                const coef_b_type &, const coef_c_type &,
                                const algebra_type & = algebra_type());
      template<typename System, typename StateIn, typename DerivIn,
               typename StateOut, typename Err>
        void do_step_impl(System, const StateIn &, const DerivIn &, time_type,
                          StateOut &, time_type, Err &);
      template<typename System, typename StateIn, typename DerivIn,
               typename StateOut>
        void do_step_impl(System, const StateIn &, const DerivIn &, time_type,
                          StateOut &, time_type);
      template<typename StateIn> void adjust_size(const StateIn &);

      // private member functions
      template<typename StateIn> bool resize_impl(const StateIn &);

      // public data members
      static const size_t stage_count;
    };

## Description

This class implements the explicit Runge-Kutta algorithms with error estimation in a generic way. The Butcher tableau is passed to the stepper which constructs the stepper scheme with the help of a template-metaprogramming algorithm. ToDo : Add example!

This class derives explicit_error_stepper_base which provides the stepper interface.

### Template Parameters

1.     size_t StageCount

   The number of stages of the Runge-Kutta algorithm.

2.     size_t Order

   The order of a stepper if the stepper is used without error estimation.

3.     size_t StepperOrder

   The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have the same value.

4.     size_t ErrorOrder

   The order of the error step if the stepper is used with error estimation.

5.     typename State

   The type representing the state of the ODE.

6.     typename Value = double

   The floating point type which is used in the computations.

7.     typename Deriv = State

8.     typename Time = Value

   The type representing the independent variable - the time - of the ODE.

9.     typename Algebra = typename algebra_dispatcher< State >::algebra_type

   The algebra type.

10.     typename Operations = typename operations_dispatcher< State >::operations_type

    The operations type.

11.     typename Resizer = initially_resizer

    The resizer policy type.

### `explicit_error_generic_rk` public member functions

1.     explicit_error_generic_rk(const coef_a_type & a, const coef_b_type & b,
                                 const coef_b_type & b2, const coef_c_type & c,
                                 const algebra_type & algebra = algebra_type());

   Constructs the explicit_error_generik_rk class with the given parameters a, b, b2 and c. See examples section for details on the coefficients.

   Parameters: |
   `a` | Triangular matrix of parameters b in the Butcher tableau.
   `b` | Last row of the butcher tableau.
   `b2` | Parameters for lower-order evaluation to estimate the error.
   `c` | Parameters to calculate the time points in the Butcher tableau.
   `algebra` | A copy of algebra is made and stored inside explicit_stepper_base.

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

   This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. The result is updated out-of-place, hence the input is in `in` and the output in `out`. Futhermore, an estimation of the error is stored in `xerr`. `do_step_impl` is used by explicit_error_stepper_base.

   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.
   `xerr` | The result of the error estimation is written in xerr.

3.     template<typename System, typename StateIn, typename DerivIn,
                typename StateOut>
         void do_step_impl(System system, const StateIn & in, const DerivIn & dxdt,
                           time_type t, StateOut & out, time_type dt);

   This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. The result is updated out-of-place, hence the input is in `in` and the output in `out`. Access to this step functionality is provided by explicit_stepper_base and `do_step_impl` should not be called directly.

   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.

4.     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.

### `explicit_error_generic_rk` private member functions

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