...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
Home | Libraries | People | FAQ | More |
boost::numeric::odeint::explicit_generic_rk — A generic implementation of explicit Runge-Kutta algorithms. This class is as a base class for all explicit Runge-Kutta steppers.
// In header: <boost/numeric/odeint/stepper/explicit_generic_rk.hpp> template<size_t StageCount, size_t Order, typename State, typename Value, typename Deriv, typename Time, typename Algebra, typename Operations, typename Resizer> class explicit_generic_rk : public explicit_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_generic_rk(const coef_a_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> 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 &); };
This class implements the explicit Runge-Kutta algorithms without 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_stepper_base which provides the stepper interface.
size_t StageCount
The number of stages of the Runge-Kutta algorithm.
size_t Order
The order of the stepper.
typename State
The type representing the state of the ODE.
typename Value
The floating point type which is used in the computations.
typename Deriv
typename Time
The type representing the independent variable - the time - of the ODE.
typename Algebra
The algebra type.
typename Operations
The operations type.
typename Resizer
The resizer policy type.
explicit_generic_rk
public
construct/copy/destructexplicit_generic_rk(const coef_a_type & a, const coef_b_type & b, const coef_c_type & c, const algebra_type & algebra = algebra_type());Constructs the
explicit_generic_rk
class. See examples section for details on the coefficients.
Parameters: |
|
explicit_generic_rk
public member functionstemplate<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: |
|
template<typename StateIn> void adjust_size(const StateIn & x);Adjust the size of all temporaries in the stepper manually.
Parameters: |
|