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_moulton

boost::numeric::odeint::adams_moulton

Synopsis

// In header: <boost/numeric/odeint/stepper/adams_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 adams_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 adams_moulton< Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer > stepper_type;      
  typedef unsigned short                                                                  order_type;        
  typedef unspecified                                                                     step_storage_type; 

  // construct/copy/destruct
  adams_moulton();
  adams_moulton(algebra_type &);
  adams_moulton & operator=(const adams_moulton &);

  // public member functions
  order_type order(void) const;
  template<typename System, typename StateInOut, typename StateIn, 
           typename ABBuf> 
    void do_step(System, StateInOut &, StateIn const &, time_type, time_type, 
                 const ABBuf &);
  template<typename System, typename StateInOut, typename StateIn, 
           typename ABBuf> 
    void do_step(System, const StateInOut &, StateIn const &, time_type, 
                 time_type, const ABBuf &);
  template<typename System, typename StateIn, typename PredIn, 
           typename StateOut, typename ABBuf> 
    void do_step(System, const StateIn &, const PredIn &, time_type, 
                 StateOut &, time_type, const ABBuf &);
  template<typename System, typename StateIn, typename PredIn, 
           typename StateOut, typename ABBuf> 
    void do_step(System, const StateIn &, const PredIn &, time_type, 
                 const StateOut &, time_type, const ABBuf &);
  template<typename StateType> void adjust_size(const StateType &);
  algebra_type & algebra();
  const algebra_type & algebra() const;

  // private member functions
  template<typename System, typename StateIn, typename PredIn, 
           typename StateOut, typename ABBuf> 
    void do_step_impl(System, const StateIn &, const PredIn &, time_type, 
                      StateOut &, time_type, const ABBuf &);
  template<typename StateIn> bool resize_impl(const StateIn &);

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

Description

adams_moulton public construct/copy/destruct

  1. adams_moulton();
  2. adams_moulton(algebra_type & algebra);
  3. adams_moulton & operator=(const adams_moulton & stepper);

adams_moulton public member functions

  1. order_type order(void) const;
  2. template<typename System, typename StateInOut, typename StateIn, 
             typename ABBuf> 
      void do_step(System system, StateInOut & x, StateIn const & pred, 
                   time_type t, time_type dt, const ABBuf & buf);
  3. template<typename System, typename StateInOut, typename StateIn, 
             typename ABBuf> 
      void do_step(System system, const StateInOut & x, StateIn const & pred, 
                   time_type t, time_type dt, const ABBuf & buf);
  4. template<typename System, typename StateIn, typename PredIn, 
             typename StateOut, typename ABBuf> 
      void do_step(System system, const StateIn & in, const PredIn & pred, 
                   time_type t, StateOut & out, time_type dt, const ABBuf & buf);
  5. template<typename System, typename StateIn, typename PredIn, 
             typename StateOut, typename ABBuf> 
      void do_step(System system, const StateIn & in, const PredIn & pred, 
                   time_type t, const StateOut & out, time_type dt, 
                   const ABBuf & buf);
  6. template<typename StateType> void adjust_size(const StateType & x);
  7. algebra_type & algebra();
  8. const algebra_type & algebra() const;

adams_moulton private member functions

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

PrevUpHomeNext