Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for a snapshot of the develop branch, built from commit 47461eefaa.
Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Class template runge_kutta_cash_karp54_classic

boost::numeric::odeint::runge_kutta_cash_karp54_classic — The Runge-Kutta Cash-Karp method implemented without the generic Runge-Kutta algorithm.

Synopsis

// In header: <boost/numeric/odeint/stepper/runge_kutta_cash_karp54_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_kutta_cash_karp54_classic : public explicit_error_stepper_base {
public:
  // types
  typedef explicit_error_stepper_base< runge_kutta_cash_karp54_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_kutta_cash_karp54_classic(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 &);

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

Description

The Runge-Kutta Cash-Karp method is one of the standard methods for solving ordinary differential equations, see en.wikipedia.org/wiki/Cash-Karp_method. 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). This class implements the method directly, hence the generic Runge-Kutta algorithm is not used.

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_kutta_cash_karp54_classic public construct/copy/destruct

  1. runge_kutta_cash_karp54_classic(const algebra_type & algebra = algebra_type());
    Constructs the runge_kutta_cash_karp54_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_kutta_cash_karp54_classic 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. Access to this step functionality is provided by explicit_error_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.

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

runge_kutta_cash_karp54_classic private member functions

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

PrevUpHomeNext