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 adaptive_adams_bashforth_moulton

boost::numeric::odeint::adaptive_adams_bashforth_moulton

Synopsis

// In header: <boost/numeric/odeint/stepper/adaptive_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> 
class adaptive_adams_bashforth_moulton :
  public algebra_stepper_base< Algebra, Operations >
{
public:
  // types
  typedef unsigned short                                                                                     order_type;               
  typedef State                                                                                              state_type;               
  typedef Value                                                                                              value_type;               
  typedef Deriv                                                                                              deriv_type;               
  typedef Time                                                                                               time_type;                
  typedef state_wrapper< state_type >                                                                        wrapped_state_type;       
  typedef state_wrapper< deriv_type >                                                                        wrapped_deriv_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 Resizer                                                                                            resizer_type;             
  typedef error_stepper_tag                                                                                  stepper_category;         
  typedef unspecified                                                                                        coeff_type;               
  typedef adaptive_adams_bashforth_moulton< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer > stepper_type;             

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

  // public member functions
  order_type order() const;
  order_type stepper_order() const;
  order_type error_order() const;
  template<typename System> 
    void do_step(System, state_type &, time_type, time_type);
  template<typename System> 
    void do_step(System, const state_type &, time_type, state_type &, 
                 time_type);
  template<typename System> 
    void do_step(System, state_type &, time_type, time_type, state_type &);
  template<typename System> 
    void do_step(System, const state_type &, time_type, state_type &, 
                 time_type, state_type &);
  template<typename ExplicitStepper, typename System> 
    void initialize(ExplicitStepper, System, state_type &, time_type &, 
                    time_type);
  template<typename System> 
    void initialize(System, state_type &, time_type &, time_type);
  template<typename System> 
    void do_step_impl(System, const state_type &, time_type, state_type &, 
                      time_type &, state_type &);
  const coeff_type & coeff() const;
  coeff_type & coeff();
  void reset();
  const deriv_type & dxdt() const;

  // private member functions
  template<typename StateType> bool resize_dxdt_impl(const StateType &);
  template<typename StateType> bool resize_xnew_impl(const StateType &);
  template<typename StateType> bool resize_xerr_impl(const StateType &);

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

Description

adaptive_adams_bashforth_moulton public construct/copy/destruct

  1. adaptive_adams_bashforth_moulton(const algebra_type & algebra = algebra_type());

adaptive_adams_bashforth_moulton public member functions

  1. order_type order() const;
  2. order_type stepper_order() const;
  3. order_type error_order() const;
  4. template<typename System> 
      void do_step(System system, state_type & inOut, time_type t, time_type dt);
  5. template<typename System> 
      void do_step(System system, const state_type & in, time_type t, 
                   state_type & out, time_type dt);
  6. template<typename System> 
      void do_step(System system, state_type & inOut, time_type t, time_type dt, 
                   state_type & xerr);
  7. template<typename System> 
      void do_step(System system, const state_type & in, time_type t, 
                   state_type & out, time_type dt, state_type & xerr);
  8. template<typename ExplicitStepper, typename System> 
      void initialize(ExplicitStepper stepper, System system, state_type & inOut, 
                      time_type & t, time_type dt);
  9. template<typename System> 
      void initialize(System system, state_type & inOut, time_type & t, 
                      time_type dt);
  10. template<typename System> 
      void do_step_impl(System system, const state_type & in, time_type t, 
                        state_type & out, time_type & dt, state_type & xerr);
  11. const coeff_type & coeff() const;
  12. coeff_type & coeff();
  13. void reset();
  14. const deriv_type & dxdt() const;

adaptive_adams_bashforth_moulton private member functions

  1. template<typename StateType> bool resize_dxdt_impl(const StateType & x);
  2. template<typename StateType> bool resize_xnew_impl(const StateType & x);
  3. template<typename StateType> bool resize_xerr_impl(const StateType & x);

PrevUpHomeNext