| Home | Libraries | People | FAQ | More

## 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< typename algebra_dispatcher< State >::algebra_type, typename operations_dispatcher< State >::operations_type >
    {
    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;

      // public member functions
      order_type order() const;
      order_type stepper_order() const;
      order_type error_order() const;
      adaptive_adams_bashforth_moulton(const algebra_type & = algebra_type());
      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 member functions

1.     order_type order() const;

2.     order_type stepper_order() const;

3.     order_type error_order() const;

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

5.     template<typename System>
         void do_step(System system, state_type & inOut, time_type t, time_type dt);

6.     template<typename System>
         void do_step(System system, const state_type & in, time_type t,
                      state_type & out, time_type dt);

7.     template<typename System>
         void do_step(System system, state_type & inOut, time_type t, time_type dt,
                      state_type & xerr);

8.     template<typename System>
         void do_step(System system, const state_type & in, time_type t,
                      state_type & out, time_type dt, state_type & xerr);

9.     template<typename ExplicitStepper, typename System>
         void initialize(ExplicitStepper stepper, System system, state_type & inOut,
                         time_type & t, time_type dt);

10.     template<typename System>
          void initialize(System system, state_type & inOut, time_type & t,
                          time_type dt);

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

12.     const coeff_type & coeff() const;

13.     coeff_type & coeff();

14.     void reset();

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