boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper > Class Template Reference

The Adams-Bashforth multistep algorithm. More...

#include <adams_bashforth.hpp>

Inheritance diagram for boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >:

Collaboration diagram for boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >:

Public Types
typedef State	state_type
typedef state_wrapper< state_type >	wrapped_state_type
typedef Value	value_type
typedef Deriv	deriv_type
typedef state_wrapper< deriv_type >	wrapped_deriv_type
typedef Time	time_type
typedef Resizer	resizer_type
typedef stepper_tag	stepper_category
typedef InitializingStepper	initializing_stepper_type
typedef algebra_stepper_base < Algebra, Operations >	algebra_stepper_base_type
typedef algebra_stepper_base_type::algebra_type	algebra_type
typedef algebra_stepper_base_type::operations_type	operations_type
typedef adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >	stepper_type
typedef unsigned short	order_type
typedef detail::rotating_buffer < wrapped_deriv_type, steps >	step_storage_type

Public Member Functions
order_type	order (void) const
	Returns the order of the algorithm, which is equal to the number of steps. More...
	adams_bashforth (const algebra_type &algebra=algebra_type())
	Constructs the adams_bashforth class. More...
template<class System , class StateInOut >
void	do_step (System system, StateInOut &x, time_type t, time_type dt)
	This method performs one step. More...
template<class System , class 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. More...
template<class System , class StateIn , class StateOut >
void	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...
template<class System , class StateIn , class StateOut >
void	do_step (System system, const StateIn &in, time_type t, const StateOut &out, time_type dt)
	Second version to solve the forwarding problem, can be called with Boost.Range as StateOut. More...
template<class StateType >
void	adjust_size (const StateType &x)
	Adjust the size of all temporaries in the stepper manually. More...
const step_storage_type &	step_storage (void) const
	Returns the storage of intermediate results. More...
step_storage_type &	step_storage (void)
	Returns the storage of intermediate results. More...
template<class ExplicitStepper , class System , class StateIn >
void	initialize (ExplicitStepper explicit_stepper, System system, StateIn &x, time_type &t, time_type dt)
	Initialized the stepper. More...
template<class System , class StateIn >
void	initialize (System system, StateIn &x, time_type &t, time_type dt)
	Initialized the stepper. More...
void	reset (void)
	Resets the internal buffer of the stepper. More...
bool	is_initialized (void) const
	Returns true if the stepper has been initialized. More...
const initializing_stepper_type &	initializing_stepper (void) const
	Returns the internal initializing stepper instance. More...
initializing_stepper_type &	initializing_stepper (void)
	Returns the internal initializing stepper instance. More...
algebra_type &	algebra ()
const algebra_type &	algebra () const

Static Public Attributes
static const size_t	steps = Steps
static const order_type	order_value = steps

Protected Attributes
algebra_type	m_algebra

Detailed Description

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>
class boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >

The Adams-Bashforth multistep algorithm.

The Adams-Bashforth method is a multi-step algorithm with configurable step number. The step number is specified as template parameter Steps and it then uses the result from the previous Steps steps. See also en.wikipedia.org/wiki/Linear_multistep_method. Currently, a maximum of Steps=8 is supported. The method is explicit and fulfills the Stepper concept. Step size control or continuous output are not provided.

This class derives from algebra_base and inherits its interface via CRTP (current recurring template pattern). For more details see algebra_stepper_base.

Template Parameters

Steps	The number of steps (maximal 8).
State	The state type.
Value	The value type.
Deriv	The type representing the time derivative of the state.
Time	The time representing the independent variable - the time.
Algebra	The algebra type.
Operations	The operations type.
Resizer	The resizer policy type.
InitializingStepper	The stepper for the first two steps.

Member Typedef Documentation

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef algebra_stepper_base< Algebra , Operations > boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::algebra_stepper_base_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef algebra_stepper_base_type::algebra_type boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::algebra_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef Deriv boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::deriv_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef InitializingStepper boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::initializing_stepper_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef algebra_stepper_base_type::operations_type boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::operations_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef unsigned short boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::order_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef Resizer boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::resizer_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef State boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::state_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef detail::rotating_buffer< wrapped_deriv_type , steps > boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::step_storage_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef stepper_tag boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::stepper_category

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef adams_bashforth< Steps , State , Value , Deriv , Time , Algebra , Operations , Resizer , InitializingStepper > boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::stepper_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef Time boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::time_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef Value boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::value_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef state_wrapper< deriv_type > boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::wrapped_deriv_type

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

typedef state_wrapper< state_type > boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::wrapped_state_type

Constructor & Destructor Documentation

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::adams_bashforth ( const algebra_type &  algebra = algebra_type() )

inline

Constructs the adams_bashforth 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.

Member Function Documentation

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

template<class StateType >

void boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::adjust_size ( const StateType &  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.

Referenced by boost::numeric::odeint::adams_bashforth_moulton< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer >::adjust_size().

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.

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

template<class System , class StateInOut >

void boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::do_step ( System  system, StateInOut &  x, time_type  t, time_type  dt  )

inline

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.

Referenced by boost::numeric::odeint::adams_bashforth< steps, state_type, value_type, deriv_type, time_type, algebra_type, operations_type, resizer_type >::do_step().

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

template<class System , class StateInOut >

void boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::do_step ( System  system, const StateInOut &  x, time_type  t, time_type  dt  )

inline

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

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

template<class System , class StateIn , class StateOut >

void boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::do_step ( System  system, const StateIn &  in, time_type  t, StateOut &  out, time_type  dt  )

inline

The method performs one step with the stepper passed by Stepper.

The state of the ODE is updated out-of-place.

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.

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

template<class System , class StateIn , class StateOut >

void boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::do_step ( System  system, const StateIn &  in, time_type  t, const StateOut &  out, time_type  dt  )

inline

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

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

template<class ExplicitStepper , class System , class StateIn >

void boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::initialize ( ExplicitStepper  explicit_stepper, System  system, StateIn &  x, time_type &  t, time_type  dt  )

inline

Initialized the stepper.

Does Steps-1 steps with the explicit_stepper to fill the buffer.

Parameters

explicit_stepper	the stepper used to fill the buffer of previous step results
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.

Referenced by boost::numeric::odeint::adams_bashforth_moulton< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer >::initialize(), and boost::numeric::odeint::adams_bashforth< steps, state_type, value_type, deriv_type, time_type, algebra_type, operations_type, resizer_type >::initialize().

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

template<class System , class StateIn >

void boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::initialize ( System  system, StateIn &  x, time_type &  t, time_type  dt  )

inline

Initialized the stepper.

Does Steps-1 steps with an internal instance of InitializingStepper to fill the buffer.

Note

The state x and time t are updated to the values after Steps-1 initial steps.

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 initial state of the ODE which should be solved, updated in this method.
t	The initial value of the time, updated in this method.
dt	The step size.

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

const initializing_stepper_type & boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::initializing_stepper ( void  ) const

inline

Returns the internal initializing stepper instance.

Returns

initializing_stepper

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

initializing_stepper_type & boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::initializing_stepper ( void  )

inline

Returns the internal initializing stepper instance.

Returns

initializing_stepper

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

bool boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::is_initialized ( void  ) const

inline

Returns true if the stepper has been initialized.

Returns

bool true if stepper is initialized, false otherwise

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

order_type boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::order ( void  ) const

inline

Returns the order of the algorithm, which is equal to the number of steps.

Returns

order of the method.

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

void boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::reset ( void  )

inline

Resets the internal buffer of the stepper.

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

const step_storage_type & boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::step_storage ( void  ) const

inline

Returns the storage of intermediate results.

Returns

The storage of intermediate results.

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

step_storage_type & boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::step_storage ( void  )

inline

Returns the storage of intermediate results.

Returns

The storage of intermediate results.

Member Data Documentation

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

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

const order_type boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::order_value = steps

static

Referenced by boost::numeric::odeint::adams_bashforth< steps, state_type, value_type, deriv_type, time_type, algebra_type, operations_type, resizer_type >::order().

template<size_t Steps, 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 InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >>

const size_t boost::numeric::odeint::adams_bashforth< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer, InitializingStepper >::steps = Steps

static

Referenced by boost::numeric::odeint::adams_bashforth< steps, state_type, value_type, deriv_type, time_type, algebra_type, operations_type, resizer_type >::initialize().

---

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

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