Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for a snapshot of the develop branch, built from commit 47461eefaa.
Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

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

  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 = 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

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

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

    Returns:

    order of the method.

  2. 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:

    dt

    The step size.

    system

    The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the Simple System concept.

    t

    The value of the time, at which the step should be performed.

    x

    The state of the ODE which should be solved. After calling do_step the result is updated in x.

  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, 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:

    dt

    The step size.

    in

    The state of the ODE which should be solved. in is not modified in this method

    out

    The result of the step is written in out.

    system

    The system function to solve, hence the r.h.s. of the ODE. It must fulfill the Simple System concept.

    t

    The value of the time, at which the step should be performed.

  5. 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.
  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. const step_storage_type & step_storage(void) const;
    Returns the storage of intermediate results.

    Returns:

    The storage of intermediate results.

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

    Returns:

    The storage of intermediate results.

  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.

    Parameters:

    dt

    The step size.

    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.

    t

    The value of the time, at which the step should be performed.

    x

    The state of the ODE which should be solved. After calling do_step the result is updated in x.

  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 with an internal instance of InitializingStepper to fill the buffer.
    [Note] Note

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

    Parameters:

    dt

    The step size.

    system

    The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the Simple System concept.

    t

    The initial value of the time, updated in this method.

    x

    The initial state of the ODE which should be solved, updated in this method.

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

    Returns:

    bool true if stepper is initialized, false otherwise

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

    Returns:

    initializing_stepper

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

    Returns:

    initializing_stepper

adams_bashforth private member functions

  1. template<typename System, typename StateIn, typename StateOut> 
      void do_step_impl(System system, const StateIn & in, time_type t, 
                        StateOut & out, time_type dt);
  2. template<typename StateIn> bool resize_impl(const StateIn & x);

PrevUpHomeNext