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

This is the documentation for a snapshot of the develop branch, built from commit 47461eefaa.
Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Class template extrapolation_stepper

boost::numeric::odeint::extrapolation_stepper — Extrapolation stepper with configurable order, and error estimation.

Synopsis

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

template<unsigned short Order, 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 extrapolation_stepper : public explicit_error_stepper_base {
public:
  // types
  typedef explicit_error_stepper_base< extrapolation_stepper< ... >,... > stepper_base_type;
  typedef stepper_base_type::state_type                                   state_type;       
  typedef stepper_base_type::value_type                                   value_type;       
  typedef stepper_base_type::deriv_type                                   deriv_type;       
  typedef stepper_base_type::time_type                                    time_type;        
  typedef stepper_base_type::algebra_type                                 algebra_type;     
  typedef stepper_base_type::operations_type                              operations_type;  
  typedef stepper_base_type::resizer_type                                 resizer_type;     
  typedef unsigned short                                                  order_type;       

  // construct/copy/destruct
  extrapolation_stepper(const algebra_type & = algebra_type());

  // private member functions
   BOOST_STATIC_ASSERT_MSG(((Order % 2)==0) &&(Order > 2), 
                           "extrapolation_stepper requires even Order larger than 2");
  template<typename StateIn> bool resize_impl(const StateIn &);
  template<typename StateIn> bool resize_m_xout(const StateIn &);
  template<typename StateInOut> 
    void extrapolate(size_t, state_table_type &, const value_matrix &, 
                     StateInOut &);

  // public member functions
  template<typename System, typename StateIn, typename DerivIn, 
           typename StateOut, typename Err> 
    void do_step_impl(System, const StateIn &, const DerivIn &, time_type, 
                      StateOut &, time_type, Err &);
  template<typename System, typename StateInOut, typename DerivIn, 
           typename Err> 
    void do_step_impl_io(System, StateInOut &, const DerivIn &, time_type, 
                         time_type, Err &);
  template<typename System, typename StateIn, typename DerivIn, 
           typename StateOut> 
    void do_step_impl(System, const StateIn &, const DerivIn &, time_type, 
                      StateOut &, time_type);
  template<typename System, typename StateInOut, typename DerivIn> 
    void do_step_impl_io(System, StateInOut &, const DerivIn &, time_type, 
                         time_type);
  template<typename System, typename StateInOut, typename DerivIn> 
    void do_step_dxdt_impl(System, StateInOut &, const DerivIn &, time_type, 
                           time_type);
  template<typename System, typename StateIn, typename DerivIn, 
           typename StateOut> 
    void do_step_dxdt_impl(System, const StateIn &, const DerivIn &, 
                           time_type, StateOut &, time_type);
  template<typename StateIn> void adjust_size(const StateIn &);

  // public data members
  static const order_type order_value;
  static const order_type stepper_order_value;
  static const order_type error_order_value;
  static const size_t m_k_max;
};

Description

The extrapolation stepper is a stepper with error estimation and configurable order. The order is given as template parameter and needs to be an odd number. The stepper is based on several executions of the modified midpoint method and a Richardson extrapolation. This is essentially the same technique as for bulirsch_stoer, but without the variable order.

[Note] Note

The Order parameter has to be an even number greater 2.

extrapolation_stepper public construct/copy/destruct

  1. extrapolation_stepper(const algebra_type & algebra = algebra_type());

extrapolation_stepper private member functions

  1.  BOOST_STATIC_ASSERT_MSG(((Order % 2)==0) &&(Order > 2), 
                             "extrapolation_stepper requires even Order larger than 2");
  2. template<typename StateIn> bool resize_impl(const StateIn & x);
  3. template<typename StateIn> bool resize_m_xout(const StateIn & x);
  4. template<typename StateInOut> 
      void extrapolate(size_t k, state_table_type & table, 
                       const value_matrix & coeff, StateInOut & xest);

extrapolation_stepper public member functions

  1. template<typename System, typename StateIn, typename DerivIn, 
             typename StateOut, typename Err> 
      void do_step_impl(System system, const StateIn & in, const DerivIn & dxdt, 
                        time_type t, StateOut & out, time_type dt, Err & xerr);
  2. template<typename System, typename StateInOut, typename DerivIn, typename Err> 
      void do_step_impl_io(System system, StateInOut & inout, 
                           const DerivIn & dxdt, time_type t, time_type dt, 
                           Err & xerr);
  3. template<typename System, typename StateIn, typename DerivIn, 
             typename StateOut> 
      void do_step_impl(System system, const StateIn & in, const DerivIn & dxdt, 
                        time_type t, StateOut & out, time_type dt);
  4. template<typename System, typename StateInOut, typename DerivIn> 
      void do_step_impl_io(System system, StateInOut & inout, 
                           const DerivIn & dxdt, time_type t, time_type dt);
  5. template<typename System, typename StateInOut, typename DerivIn> 
      void do_step_dxdt_impl(System system, StateInOut & x, const DerivIn & dxdt, 
                             time_type t, time_type dt);
  6. template<typename System, typename StateIn, typename DerivIn, 
             typename StateOut> 
      void do_step_dxdt_impl(System system, const StateIn & in, 
                             const DerivIn & dxdt, time_type t, StateOut & out, 
                             time_type dt);
  7. template<typename StateIn> void adjust_size(const StateIn & x);

PrevUpHomeNext