| Home | Libraries | People | FAQ | More

## Class template runge_kutta_fehlberg78

boost::numeric::odeint::runge_kutta_fehlberg78 — The Runge-Kutta Fehlberg 78 method.

## Synopsis

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

    template<typename State, typename Value = double, typename Deriv = State,
             typename Time = Value, typename Algebra = range_algebra,
             typename Operations = default_operations,
             typename Resizer = initially_resizer>
    class runge_kutta_fehlberg78 : public boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >
    {
    public:
      // types
      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_kutta_fehlberg78(const algebra_type & = algebra_type());

      // public member functions
      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 &);
      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 &);
      const algebra_type & algebra() const;
    };

## Description

The Runge-Kutta Fehlberg 78 method is a standard method for high-precision applications. The method is explicit and fulfills the Error Stepper concept. Step size control is provided but continuous output is not available for this method.

This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern). Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation. For more details see explicit_error_stepper_base and explicit_error_generic_rk.

### 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 = range_algebra

   The algebra type.

6.     typename Operations = default_operations

   The operations type.

7.     typename Resizer = initially_resizer

   The resizer policy type.

### `runge_kutta_fehlberg78` public construct/copy/destruct

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

   Constructs the runge_kutta_cash_fehlberg78 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_kutta_fehlberg78` public member functions

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

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

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

4.     order_type stepper_order(void) const;

   Returns: | Returns the order of a step if the stepper is used without error estimation.

5.     order_type error_order(void) const;

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

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

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

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

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

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

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

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

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

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

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

16.     const algebra_type & algebra() const;

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