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);
  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);
  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);
  10. template<typename System, typename StateIn> 
      void initialize(System system, StateIn & x, time_type & t, time_type dt);
  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