| Home | Libraries | People | FAQ | More

## Class template controlled_adams_bashforth_moulton

boost::numeric::odeint::controlled_adams_bashforth_moulton

## Synopsis

    // In header: <boost/numeric/odeint/stepper/controlled_adams_bashforth_moulton.hpp>

    template<typename ErrorStepper, typename StepAdjuster = unspecified,
             typename OrderAdjuster = default_order_adjuster< ErrorStepper::order_value, typename ErrorStepper::state_type, typename ErrorStepper::value_type, typename ErrorStepper::algebra_type >,
             typename Resizer = initially_resizer>
    class controlled_adams_bashforth_moulton {
    public:
      // types
      typedef ErrorStepper                                                                             stepper_type;
      typedef stepper_type::state_type                                                                 state_type;
      typedef stepper_type::value_type                                                                 value_type;
      typedef stepper_type::deriv_type                                                                 deriv_type;
      typedef stepper_type::time_type                                                                  time_type;
      typedef stepper_type::algebra_type                                                               algebra_type;
      typedef stepper_type::operations_type                                                            operations_type;
      typedef Resizer                                                                                  resizer_type;
      typedef StepAdjuster                                                                             step_adjuster_type;
      typedef OrderAdjuster                                                                            order_adjuster_type;
      typedef controlled_stepper_tag                                                                   stepper_category;
      typedef stepper_type::wrapped_state_type                                                         wrapped_state_type;
      typedef stepper_type::wrapped_deriv_type                                                         wrapped_deriv_type;
      typedef std::array< wrapped_state_type, 4 >                                                      error_storage_type;
      typedef stepper_type::coeff_type                                                                 coeff_type;
      typedef controlled_adams_bashforth_moulton< ErrorStepper, StepAdjuster, OrderAdjuster, Resizer > controlled_stepper_type;

      // public member functions
      controlled_adams_bashforth_moulton(step_adjuster_type = step_adjuster_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 ExplicitStepper, typename System>
        void initialize_controlled(ExplicitStepper, System, state_type &,
                                   time_type &, time_type &);
      template<typename System>
        controlled_step_result
        try_step(System, state_type &, time_type &, time_type &);
      template<typename System>
        controlled_step_result
        try_step(System, const state_type &, time_type &, state_type &,
                 time_type &);
      void reset();

      // private member functions
      template<typename StateType> bool resize_dxdt_impl(const StateType &);
      template<typename StateType> bool resize_xerr_impl(const StateType &);
      template<typename StateType> bool resize_xnew_impl(const StateType &);

      // public data members
      static const stepper_type::order_type order_value;
    };

## Description

### `controlled_adams_bashforth_moulton` public member functions

1.     controlled_adams_bashforth_moulton(step_adjuster_type step_adjuster = step_adjuster_type());

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

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

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

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

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

7.     void reset();

### `controlled_adams_bashforth_moulton` private member functions

1.     template<typename StateType> bool resize_dxdt_impl(const StateType & x);

2.     template<typename StateType> bool resize_xerr_impl(const StateType & x);

3.     template<typename StateType> bool resize_xnew_impl(const StateType & x);