| Home | Libraries | People | FAQ | More

## Class template dense_output_runge_kutta<Stepper, explicit_controlled_stepper_fsal_tag>

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

## Synopsis

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

    template<typename Stepper>
    class dense_output_runge_kutta<Stepper, explicit_controlled_stepper_fsal_tag> {
    public:
      // types
      typedef Stepper                               controlled_stepper_type;
      typedef controlled_stepper_type::stepper_type 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;

      // public member functions
      dense_output_runge_kutta(const controlled_stepper_type & = controlled_stepper_type());
      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 StateIn> bool resize(const StateIn &);
      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;
      deriv_type & get_current_deriv(void);
      const deriv_type & get_current_deriv(void) const;
      deriv_type & get_old_deriv(void);
      const deriv_type & get_old_deriv(void) const;
      void toggle_current_state(void);
    };

## Description

The interface is the same as for dense_output_runge_kutta< Stepper , stepper_tag >. This class provides dense output functionality based on methods with step size controlled

### Template Parameters

1.     typename Stepper

   The stepper type of the underlying algorithm.

### `dense_output_runge_kutta` public member functions

1.     dense_output_runge_kutta(const controlled_stepper_type & stepper = controlled_stepper_type());

2.     template<typename StateType>
         void initialize(const StateType & x0, time_type t0, time_type dt0);

3.     template<typename System>
         std::pair< time_type, time_type > do_step(System system);

4.     template<typename StateOut> void calc_state(time_type t, StateOut & x) const;

5.     template<typename StateOut>
         void calc_state(time_type t, const StateOut & x) const;

6.     template<typename StateIn> bool resize(const StateIn & x);

7.     template<typename StateType> void adjust_size(const StateType & x);

8.     const state_type & current_state(void) const;

9.     time_type current_time(void) const;

10.     const state_type & previous_state(void) const;

11.     time_type previous_time(void) const;

12.     time_type current_time_step(void) const;

### `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.     deriv_type & get_current_deriv(void);

6.     const deriv_type & get_current_deriv(void) const;

7.     deriv_type & get_old_deriv(void);

8.     const deriv_type & get_old_deriv(void) const;

9.     void toggle_current_state(void);