Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

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

```
order_type order() const;
```
```
order_type stepper_order() const;
```
```
order_type error_order() const;
```

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

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

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

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

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

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

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

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

```
const coeff_type & coeff() const;
```
```
coeff_type & coeff();
```
```
void reset();
```
```
const deriv_type & dxdt() const;
```

`adaptive_adams_bashforth_moulton` private member functions

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

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

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