Class template runge_kutta4

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

```
typename State
```
The state type.
```
typename Value = double
```
The value type.
```
typename Deriv = State
```
The type representing the time derivative of the state.
```
typename Time = Value
```
The time representing the independent variable - the time.

typename Algebra = typename algebra_dispatcher< State >::algebra_type

The algebra type.

typename Operations = typename operations_dispatcher< State >::operations_type

The operations type.

```
typename Resizer = initially_resizer
```
The resizer policy type.

`runge_kutta4_classic` public construct/copy/destruct

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

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.

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

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