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