| Home | Libraries | People | FAQ | More

## 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 = range_algebra,
             typename Operations = default_operations,
             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 ABBuf>
        void do_step(System, StateInOut &, time_type, time_type, const ABBuf &);
      template<typename System, typename StateInOut, typename ABBuf>
        void do_step(System, const StateInOut &, time_type, time_type,
                     const ABBuf &);
      template<typename System, typename StateIn, typename StateOut,
               typename ABBuf>
        void do_step(System, const StateIn &, time_type, StateOut &, time_type,
                     const ABBuf &);
      template<typename System, typename StateIn, typename StateOut,
               typename ABBuf>
        void do_step(System, const StateIn &, 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 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 ABBuf>
         void do_step(System system, StateInOut & in, time_type t, time_type dt,
                      const ABBuf & buf);

3.     template<typename System, typename StateInOut, typename ABBuf>
         void do_step(System system, const StateInOut & in, time_type t,
                      time_type dt, const ABBuf & buf);

4.     template<typename System, typename StateIn, typename StateOut, typename ABBuf>
         void do_step(System system, const StateIn & in, time_type t, StateOut & out,
                      time_type dt, const ABBuf & buf);

5.     template<typename System, typename StateIn, typename StateOut, typename ABBuf>
         void do_step(System system, const StateIn & in, 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 StateIn> bool resize_impl(const StateIn & x);