PrevUpHomeNext

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;               

  // construct/copy/destruct
  adams_bashforth_moulton(void);
  adams_bashforth_moulton(const 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, 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);

  // 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 construct/copy/destruct

  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.

adams_bashforth_moulton public member functions

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

  2. template<typename System, typename StateInOut> 
      void do_step(System system, StateInOut & x, time_type t, time_type dt);
  3. 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.
  4. template<typename System, typename StateIn, typename StateOut> 
      void do_step(System system, const StateIn & in, time_type t, 
                   const StateOut & out, time_type dt);
  5. 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.
  6. 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.

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

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);

PrevUpHomeNext