Class template adams

Class template adams_bashforth

boost::numeric::odeint::adams_bashforth — The Adams-Bashforth multistep algorithm.

Synopsis

// In header: <boost/numeric/odeint/stepper/adams_bashforth.hpp>

template<size_t Steps, 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, 
         typename InitializingStepper = extrapolation_stepper< order_helper<Steps>::value,                                                    State, Value, Deriv, Time,                                                   Algebra, Operations, Resizer > > 
class adams_bashforth : public algebra_stepper_base< Algebra, Operations > {
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 unsigned short                              order_type;               
  typedef unspecified                                 step_storage_type;        

  // construct/copy/destruct
  adams_bashforth(const algebra_type & = algebra_type());

  // public member functions
  order_type order(void) const;
  template<typename System, typename StateInOut> 
    void do_step(System, StateInOut &, time_type, time_type);
  template<typename System, typename StateInOut> 
    void do_step(System, const StateInOut &, time_type, time_type);
  template<typename System, typename StateIn, typename StateOut> 
    void do_step(System, const StateIn &, time_type, StateOut &, time_type);
  template<typename System, typename StateIn, typename StateOut> 
    void do_step(System, const StateIn &, time_type, const StateOut &, 
                 time_type);
  template<typename StateType> void adjust_size(const StateType &);
  const step_storage_type & step_storage(void) const;
  step_storage_type & step_storage(void);
  template<typename ExplicitStepper, typename System, typename StateIn> 
    void initialize(ExplicitStepper, System, StateIn &, time_type &, 
                    time_type);
  template<typename System, typename StateIn> 
    void initialize(System, StateIn &, time_type &, time_type);
  void reset(void);
  bool is_initialized(void) const;
  const initializing_stepper_type & initializing_stepper(void) const;
  initializing_stepper_type & initializing_stepper(void);

  // private member functions
  template<typename System, typename StateIn, typename StateOut> 
    void do_step_impl(System, const StateIn &, time_type, StateOut &, 
                      time_type);
  template<typename StateIn> bool resize_impl(const StateIn &);

  // public data members
  static const size_t steps;
  static const order_type order_value;
};

Description

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

```
size_t Steps
```
The number of steps (maximal 8).
```
typename State
```
The state type.
```
typename Value = double
```
The value type.
```
typename Deriv = State
```
The type representing the time derivative of the state.
```
typename Time = Value
```
The time representing the independent variable - the time.

typename Algebra = typename algebra_dispatcher< State >::algebra_type

The algebra type.

typename Operations = typename operations_dispatcher< State >::operations_type

The operations type.

```
typename Resizer = initially_resizer
```
The resizer policy type.

typename InitializingStepper = extrapolation_stepper< order_helper<Steps>::value,                                                    State, Value, Deriv, Time,                                                   Algebra, Operations, Resizer >

The stepper for the first two steps.

`adams_bashforth` public construct/copy/destruct

```
adams_bashforth(const algebra_type & algebra = algebra_type());
```
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.

`adams_bashforth` public member functions

```
order_type order(void) const;
```
Returns the order of the algorithm, which is equal to the number of steps.

Returns:

order of the method.

template<typename System, typename StateInOut> 
  void do_step(System system, StateInOut & x, time_type t, time_type dt);

template<typename System, typename 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.

template<typename System, typename StateIn, typename StateOut> 
  void do_step(System system, const StateIn & in, time_type t, StateOut & out, 
               time_type dt);

template<typename System, typename StateIn, typename 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.

```
template<typename StateType> void adjust_size(const StateType & 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.
```
const step_storage_type & step_storage(void) const;
```
Returns the storage of intermediate results.

Returns:

The storage of intermediate results.
```
step_storage_type & step_storage(void);
```
Returns the storage of intermediate results.

Returns:

The storage of intermediate results.

template<typename ExplicitStepper, typename System, typename StateIn> 
  void initialize(ExplicitStepper explicit_stepper, System system, 
                  StateIn & x, time_type & t, time_type dt);

template<typename System, typename StateIn> 
  void initialize(System system, StateIn & x, time_type & t, time_type dt);

```
void reset(void);
```
Resets the internal buffer of the stepper.
```
bool is_initialized(void) const;
```
Returns true if the stepper has been initialized.

Returns:

bool true if stepper is initialized, false otherwise
```
const initializing_stepper_type & initializing_stepper(void) const;
```
Returns the internal initializing stepper instance.

Returns:

initializing_stepper
```
initializing_stepper_type & initializing_stepper(void);
```
Returns the internal initializing stepper instance.

Returns:

initializing_stepper

`adams_bashforth` private member functions

template<typename System, typename StateIn, typename StateOut> 
  void do_step_impl(System system, const StateIn & in, time_type t, 
                    StateOut & out, time_type dt);

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