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 dense_output_runge_kutta<Stepper, stepper_tag>

boost::numeric::odeint::dense_output_runge_kutta<Stepper, stepper_tag> — The class representing dense-output Runge-Kutta steppers.

Synopsis

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

template<typename Stepper> 
class dense_output_runge_kutta<Stepper, stepper_tag> {
public:
  // types
  typedef Stepper                             stepper_type;             
  typedef stepper_type::state_type            state_type;               
  typedef stepper_type::wrapped_state_type    wrapped_state_type;       
  typedef stepper_type::value_type            value_type;               
  typedef stepper_type::deriv_type            deriv_type;               
  typedef stepper_type::wrapped_deriv_type    wrapped_deriv_type;       
  typedef stepper_type::time_type             time_type;                
  typedef stepper_type::algebra_type          algebra_type;             
  typedef stepper_type::operations_type       operations_type;          
  typedef stepper_type::resizer_type          resizer_type;             
  typedef dense_output_stepper_tag            stepper_category;         
  typedef dense_output_runge_kutta< Stepper > dense_output_stepper_type;

  // construct/copy/destruct
  dense_output_runge_kutta(const stepper_type & = stepper_type());

  // public member functions
  template<typename StateType> 
    void initialize(const StateType &, time_type, time_type);
  template<typename System> std::pair< time_type, time_type > do_step(System);
  template<typename StateOut> void calc_state(time_type, StateOut &) const;
  template<typename StateOut> 
    void calc_state(time_type, const StateOut &) const;
  template<typename StateType> void adjust_size(const StateType &);
  const state_type & current_state(void) const;
  time_type current_time(void) const;
  const state_type & previous_state(void) const;
  time_type previous_time(void) const;
  time_type current_time_step(void) const;

  // private member functions
  state_type & get_current_state(void);
  const state_type & get_current_state(void) const;
  state_type & get_old_state(void);
  const state_type & get_old_state(void) const;
  void toggle_current_state(void);
  template<typename StateIn> bool resize_impl(const StateIn &);
};

Description

[Note] Note

In this stepper, the initialize method has to be called before using the do_step method.

The dense-output functionality allows to interpolate the solution between subsequent integration points using intermediate results obtained during the computation. This version works based on a normal stepper without step-size control.

Template Parameters

  1. typename Stepper

    The stepper type of the underlying algorithm.

dense_output_runge_kutta public construct/copy/destruct

  1. dense_output_runge_kutta(const stepper_type & stepper = stepper_type());
    Constructs the dense_output_runge_kutta class. An instance of the underlying stepper can be provided.

    Parameters:

    stepper

    An instance of the underlying stepper.

dense_output_runge_kutta public member functions

  1. template<typename StateType> 
      void initialize(const StateType & x0, time_type t0, time_type dt0);
    Initializes the stepper. Has to be called before do_step can be used to set the initial conditions and the step size.

    Parameters:

    dt0

    The step size.

    t0

    The initial time, at which the step should be performed.

    x0

    The initial state of the ODE which should be solved.

  2. template<typename System> 
      std::pair< time_type, time_type > do_step(System system);
    Does one time step.
    [Note] Note

    initialize has to be called before using this method to set the initial conditions x,t and the stepsize.

    Parameters:

    system

    The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the Simple System concept.

    Returns:

    Pair with start and end time of the integration step.

  3. template<typename StateOut> void calc_state(time_type t, StateOut & x) const;
    Calculates the solution at an intermediate point.

    Parameters:

    t

    The time at which the solution should be calculated, has to be in the current time interval.

    x

    The output variable where the result is written into.

  4. template<typename StateOut> 
      void calc_state(time_type t, const StateOut & x) const;
    Calculates the solution at an intermediate point. Solves the forwarding problem.

    Parameters:

    t

    The time at which the solution should be calculated, has to be in the current time interval.

    x

    The output variable where the result is written into, can be a boost range.

  5. template<typename StateType> void adjust_size(const StateType & x);
    Adjust the size of all temporaries in the stepper manually.

    Parameters:

    x

    A state from which the size of the temporaries to be resized is deduced.

  6. const state_type & current_state(void) const;
    Returns the current state of the solution.

    Returns:

    The current state of the solution x(t).

  7. time_type current_time(void) const;
    Returns the current time of the solution.

    Returns:

    The current time of the solution t.

  8. const state_type & previous_state(void) const;
    Returns the last state of the solution.

    Returns:

    The last state of the solution x(t-dt).

  9. time_type previous_time(void) const;
    Returns the last time of the solution.

    Returns:

    The last time of the solution t-dt.

  10. time_type current_time_step(void) const;
    Returns the current time step.

    Returns:

    dt.

dense_output_runge_kutta private member functions

  1. state_type & get_current_state(void);
  2. const state_type & get_current_state(void) const;
  3. state_type & get_old_state(void);
  4. const state_type & get_old_state(void) const;
  5. void toggle_current_state(void);
  6. template<typename StateIn> bool resize_impl(const StateIn & x);

PrevUpHomeNext