boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > Class Template Reference

A generic implementation of explicit Runge-Kutta algorithms with error estimation. More...

#include <explicit_error_generic_rk.hpp>

Inheritance diagram for boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >:

Collaboration diagram for boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >:

Public Types
typedef explicit_error_stepper_base < explicit_error_generic_rk < StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >	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 explicit_error_generic_rk < StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >	stepper_type
typedef detail::generic_rk_algorithm < StageCount, Value, Algebra, Operations >	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
typedef algebra_stepper_base < Algebra, Operations >	algebra_stepper_base_type
typedef explicit_error_stepper_tag	stepper_category
typedef explicit_error_stepper_base < explicit_error_generic_rk < StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >	internal_stepper_base_type
typedef unsigned short	order_type

Public Member Functions
	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. More...
template<class System , class StateIn , class DerivIn , class StateOut , class 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. More...
template<class System , class StateIn , class DerivIn , class 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. More...
template<class StateIn >
void	adjust_size (const StateIn &x)
	Adjust the size of all temporaries in the stepper manually. More...
order_type	order (void) const
order_type	stepper_order (void) const
order_type	error_order (void) const
void	do_step (System system, StateInOut &x, time_type t, time_type dt)
	This method performs one step. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
algebra_type &	algebra ()
const algebra_type &	algebra () const

Static Public Attributes
static const size_t	stage_count = StageCount
static const order_type	order_value
static const order_type	stepper_order_value
static const order_type	error_order_value

Protected Attributes
wrapped_deriv_type	m_dxdt
algebra_type	m_algebra

Detailed Description

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>
class boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >

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.

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

StageCount	The number of stages of the Runge-Kutta algorithm.
Order	The order of a stepper if the stepper is used without error estimation.
StepperOrder	The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have the same value.
ErrorOrder	The order of the error step if the stepper is used with error estimation.
State	The type representing the state of the ODE.
Value	The floating point type which is used in the computations.
Time	The type representing the independent variable - the time - of the ODE.
Algebra	The algebra type.
Operations	The operations type.
Resizer	The resizer policy type.

Member Typedef Documentation

typedef algebra_stepper_base< Algebra , Operations > boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::algebra_stepper_base_type

inherited

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef stepper_base_type::algebra_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::algebra_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef rk_algorithm_type::coef_a_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::coef_a_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef rk_algorithm_type::coef_b_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::coef_b_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef rk_algorithm_type::coef_c_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::coef_c_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef stepper_base_type::deriv_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::deriv_type

typedef explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra , Operations , Resizer > boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::internal_stepper_base_type

inherited

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef stepper_base_type::operations_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::operations_type

typedef unsigned short boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::order_type

inherited

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef stepper_base_type::resizer_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::resizer_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef detail::generic_rk_algorithm< StageCount , Value , Algebra , Operations > boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::rk_algorithm_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef stepper_base_type::state_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::state_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef explicit_error_stepper_base< explicit_error_generic_rk< StageCount , Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra , Operations , Resizer > , Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra , Operations , Resizer > boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::stepper_base_type

typedef explicit_error_stepper_tag boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::stepper_category

inherited

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef explicit_error_generic_rk< StageCount , Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra , Operations , Resizer > boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::stepper_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef stepper_base_type::time_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::time_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef stepper_base_type::value_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::value_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef stepper_base_type::wrapped_deriv_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::wrapped_deriv_type

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

typedef stepper_base_type::wrapped_state_type boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::wrapped_state_type

Constructor & Destructor Documentation

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::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()  )

inline

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.
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.
algebra	A copy of algebra is made and stored inside explicit_stepper_base.

Member Function Documentation

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

template<class StateIn >

boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::adjust_size ( const StateIn &  x )

inline

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.

template<class Algebra, class Operations>

algebra_type & boost::numeric::odeint::algebra_stepper_base< Algebra, Operations >::algebra ( )

inlineinherited

Returns

A reference to the algebra which is held by this class.

template<class Algebra, class Operations>

const algebra_type & boost::numeric::odeint::algebra_stepper_base< Algebra, Operations >::algebra ( ) const

inlineinherited

Returns

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

void boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, StateInOut &  x, time_type  t, time_type  dt  )

inlineinherited

This method performs one step.

It transforms the result in-place.

Parameters

system	The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the Simple System concept.
x	The state of the ODE which should be solved. After calling do_step the result is updated in x.
t	The value of the time, at which the step should be performed.
dt	The step size.

void boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, const StateInOut &  x, time_type  t, time_type  dt  )

inlineinherited

Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.

boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, StateInOut &  x, const DerivIn &  dxdt, time_type  t, time_type  dt  )

inlineinherited

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

system	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
x	The state of the ODE which should be solved. After calling do_step the result is updated in x.
dxdt	The derivative of x at t.
t	The value of the time, at which the step should be performed.
dt	The step size.

boost::disable_if< boost::is_same< StateIn , time_type > , void >::type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, const StateIn &  in, time_type  t, StateOut &  out, time_type  dt  )

inlineinherited

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

system	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
in	The state of the ODE which should be solved. in is not modified in this method
t	The value of the time, at which the step should be performed.
out	The result of the step is written in out.
dt	The step size.

boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, const StateIn &  in, const DerivIn &  dxdt, time_type  t, StateOut &  out, time_type  dt  )

inlineinherited

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

system	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
in	The state of the ODE which should be solved. in is not modified in this method
dxdt	The derivative of x at t.
t	The value of the time, at which the step should be performed.
out	The result of the step is written in out.
dt	The step size.

void boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, StateInOut &  x, time_type  t, time_type  dt, Err &  xerr  )

inlineinherited

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

system	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
x	The state of the ODE which should be solved. x is updated by this method.
t	The value of the time, at which the step should be performed.
dt	The step size.
xerr	The estimation of the error is stored in xerr.

void boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, const StateInOut &  x, time_type  t, time_type  dt, Err &  xerr  )

inlineinherited

Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.

boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, StateInOut &  x, const DerivIn &  dxdt, time_type  t, time_type  dt, Err &  xerr  )

inlineinherited

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

system	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
x	The state of the ODE which should be solved. After calling do_step the result is updated in x.
dxdt	The derivative of x at t.
t	The value of the time, at which the step should be performed.
dt	The step size.
xerr	The error estimate is stored in xerr.

void boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, const StateIn &  in, time_type  t, StateOut &  out, time_type  dt, Err &  xerr  )

inlineinherited

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

system	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
in	The state of the ODE which should be solved. in is not modified in this method
t	The value of the time, at which the step should be performed.
out	The result of the step is written in out.
dt	The step size.
xerr	The error estimate.

void boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step ( System  system, const StateIn &  in, const DerivIn &  dxdt, time_type  t, StateOut &  out, time_type  dt, Err &  xerr  )

inlineinherited

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

system	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
in	The state of the ODE which should be solved. in is not modified in this method
dxdt	The derivative of x at t.
t	The value of the time, at which the step should be performed.
out	The result of the step is written in out.
dt	The step size.
xerr	The error estimate.

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

template<class System , class StateIn , class DerivIn , class StateOut , class Err >

boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl ( System  system, const StateIn &  in, const DerivIn &  dxdt, time_type  t, StateOut &  out, time_type  dt, Err &  xerr  )

inline

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

system	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
in	The state of the ODE which should be solved. in is not modified in this method
dxdt	The derivative of x at t.
t	The value of the time, at which the step should be performed.
out	The result of the step is written in out.
dt	The step size.
xerr	The result of the error estimation is written in xerr.

Referenced by boost::numeric::odeint::explicit_error_generic_rk< 6, 5, 5, 4, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl().

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

template<class System , class StateIn , class DerivIn , class StateOut >

boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl ( System  system, const StateIn &  in, const DerivIn &  dxdt, time_type  t, StateOut &  out, time_type  dt  )

inline

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

system	The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.
in	The state of the ODE which should be solved. in is not modified in this method
dxdt	The derivative of x at t.
t	The value of the time, at which the step should be performed.
out	The result of the step is written in out.
dt	The step size.

order_type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::error_order ( void  ) const

inlineinherited

Returns

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

order_type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::order ( void  ) const

inlineinherited

Returns

Returns the order of the stepper if it used without error estimation.

order_type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::stepper_order ( void  ) const

inlineinherited

Returns

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

Member Data Documentation

const order_type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::error_order_value

staticinherited

template<class Algebra, class Operations>

algebra_type boost::numeric::odeint::algebra_stepper_base< Algebra, Operations >::m_algebra

protectedinherited

Referenced by boost::numeric::odeint::algebra_stepper_base< algebra_type, operations_type >::algebra(), boost::numeric::odeint::euler< State, Value, Deriv, Time, Algebra, Operations, Resizer >::calc_state(), boost::numeric::odeint::runge_kutta_dopri5< State, Value, Deriv, Time, Algebra, Operations, Resizer >::calc_state(), boost::numeric::odeint::velocity_verlet< Coor, Velocity, Value, Acceleration, Time, TimeSq, Algebra, Operations, Resizer >::do_step(), boost::numeric::odeint::euler< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::numeric::odeint::modified_midpoint< state_type, value_type, deriv_type, time_type, algebra_type, operations_type, resizer_type >::do_step_impl(), boost::numeric::odeint::runge_kutta4_classic< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::numeric::odeint::runge_kutta_dopri5< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::numeric::odeint::runge_kutta_cash_karp54_classic< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::numeric::odeint::explicit_error_generic_rk< 6, 5, 5, 4, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), and boost::numeric::odeint::explicit_generic_rk< 4, 4, State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl().

wrapped_deriv_type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::m_dxdt

protectedinherited

const order_type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::order_value

staticinherited

template<size_t StageCount, size_t Order, size_t StepperOrder, size_t ErrorOrder, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer>

const size_t boost::numeric::odeint::explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::stage_count = StageCount

static

const order_type boost::numeric::odeint::explicit_error_stepper_base< explicit_error_generic_rk< StageCount, Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer > , Order, StepperOrder, ErrorOrder, State, Value, Deriv, Time, Algebra, Operations, Resizer >::stepper_order_value

staticinherited

---

The documentation for this class was generated from the following file:

• boost_1_57_0/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp