| Home | Libraries | People | FAQ | More

## Class template runge_kutta4_classic

boost::numeric::odeint::runge_kutta4_classic — The classical Runge-Kutta stepper of fourth order.

## Synopsis

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

    template<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 runge_kutta4_classic : public explicit_stepper_base {
    public:
      // types
      typedef explicit_stepper_base< runge_kutta4_classic< ... >,... > stepper_base_type;
      typedef stepper_base_type::state_type                            state_type;
      typedef stepper_base_type::value_type                            value_type;
      typedef stepper_base_type::deriv_type                            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;

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

      // public member functions
      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 StateType> void adjust_size(const StateType &);

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

## Description

The Runge-Kutta method of fourth order is one standard method for solving ordinary differential equations and is widely used, see also en.wikipedia.org/wiki/Runge-Kutta_methods The method is explicit and fulfills the Stepper concept. Step size control or continuous output are not provided. This class implements the method directly, hence the generic Runge-Kutta algorithm is not used.

This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern). For more details see explicit_stepper_base.

### Template Parameters

1.     typename State

   The state type.

2.     typename Value = double

   The value type.

3.     typename Deriv = State

   The type representing the time derivative of the state.

4.     typename Time = Value

   The time representing the independent variable - the time.

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

   The algebra type.

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

   The operations type.

7.     typename Resizer = initially_resizer

   The resizer policy type.

### `runge_kutta4_classic` public construct/copy/destruct

1.     runge_kutta4_classic(const algebra_type & algebra = algebra_type());

   Constructs the `runge_kutta4_classic` 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.

### `runge_kutta4_classic` public member functions

1.     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:

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

2.     template<typename StateType> void adjust_size(const StateType & 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.

### `runge_kutta4_classic` private member functions

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