Class template adams_moulton

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

```
adams_moulton();
```
```
adams_moulton(algebra_type & algebra);
```

adams_moulton & operator=(const adams_moulton & stepper);

`adams_moulton` public member functions

```
order_type order(void) const;
```

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

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

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

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

template<typename StateType> void adjust_size(const StateType & x);

```
algebra_type & algebra();
```
```
const algebra_type & algebra() const;
```

`adams_moulton` private member functions

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

template<typename StateIn> bool resize_impl(const StateIn & x);