| Home | Libraries | People | FAQ | More

## Class template rosenbrock4_dense_output

boost::numeric::odeint::rosenbrock4_dense_output

## Synopsis

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

    template<typename ControlledStepper>
    class rosenbrock4_dense_output {
    public:
      // types
      typedef ControlledStepper                                 controlled_stepper_type;
      typedef unwrap_reference< controlled_stepper_type >::type unwrapped_controlled_stepper_type;
      typedef unwrapped_controlled_stepper_type::stepper_type   stepper_type;
      typedef stepper_type::value_type                          value_type;
      typedef stepper_type::state_type                          state_type;
      typedef stepper_type::wrapped_state_type                  wrapped_state_type;
      typedef stepper_type::time_type                           time_type;
      typedef stepper_type::deriv_type                          deriv_type;
      typedef stepper_type::wrapped_deriv_type                  wrapped_deriv_type;
      typedef stepper_type::resizer_type                        resizer_type;
      typedef dense_output_stepper_tag                          stepper_category;
      typedef rosenbrock4_dense_output< ControlledStepper >     dense_output_stepper_type;

      // public member functions
      rosenbrock4_dense_output(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 &);
      template<typename StateOut> void calc_state(time_type, const StateOut &);
      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

### `rosenbrock4_dense_output` public member functions

1.     rosenbrock4_dense_output(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);

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

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

7.     const state_type & current_state(void) const;

8.     time_type current_time(void) const;

9.     const state_type & previous_state(void) const;

10.     time_type previous_time(void) const;

11.     time_type current_time_step(void) const;

### `rosenbrock4_dense_output` 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);