PrevUpHomeNext

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;       

  // construct/copy/destruct
  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());

  // 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 &);

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

  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.

    algebra

    A copy of algebra is made and stored inside explicit_stepper_base.

    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.

explicit_error_generic_rk 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);
  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);
  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.

explicit_error_generic_rk private member functions

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

PrevUpHomeNext