| Home | Libraries | People | FAQ | More

## Class template adams_bashforth_moulton

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

## Synopsis

    // In header: <boost/numeric/odeint/stepper/adams_bashforth_moulton.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 = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer > >
    class adams_bashforth_moulton {
    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 Algebra                     algebra_type;
      typedef Operations                  operations_type;
      typedef Resizer                     resizer_type;
      typedef stepper_tag                 stepper_category;
      typedef InitializingStepper         initializing_stepper_type;
      typedef unsigned short              order_type;

      // public member functions
      adams_bashforth_moulton(void);
      adams_bashforth_moulton(const algebra_type &);
      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, const StateOut &,
                     time_type);
      template<typename System, typename StateIn, typename StateOut>
        void do_step(System, const StateIn &, time_type, StateOut &, time_type);
      template<typename StateType> void adjust_size(const StateType &);
      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);

      // private member functions
      template<typename System, typename StateInOut>
        void do_step_impl1(System, StateInOut &, time_type, time_type);
      template<typename System, typename StateIn, typename StateInOut>
        void do_step_impl2(System, StateIn const &, time_type, StateInOut &,
                           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 predictor-corrector 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

1.     size_t Steps

   The number of steps (maximal 8).

2.     typename State

   The state type.

3.     typename Value = double

   The value type.

4.     typename Deriv = State

   The type representing the time derivative of the state.

5.     typename Time = Value

   The time representing the independent variable - the time.

6.     typename Algebra = typename algebra_dispatcher< State >::algebra_type

   The algebra type.

7.     typename Operations = typename operations_dispatcher< State >::operations_type

   The operations type.

8.     typename Resizer = initially_resizer

   The resizer policy type.

9.     typename InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >

   The stepper for the first two steps.

### `adams_bashforth_moulton` public member functions

1.     adams_bashforth_moulton(void);

   Constructs the adams_bashforth class.

2.     adams_bashforth_moulton(const algebra_type & algebra);

   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.

3.     order_type order(void) const;

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

   Returns: | order of the method.

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

   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.

5.     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.

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

   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.

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

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

8.     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.

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

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

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

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

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

    Initialized the stepper. Does Steps-1 steps using the standard initializing stepper of the underlying adams_bashforth stepper.

    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.

11.     void reset(void);

    Resets the internal buffers of the stepper.

### `adams_bashforth_moulton` private member functions

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

2.     template<typename System, typename StateIn, typename StateInOut>
         void do_step_impl2(System system, StateIn const & in, time_type t,
                            StateInOut & out, time_type dt);

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