| Home | Libraries | People | FAQ | More

## Class template rosenbrock4

boost::numeric::odeint::rosenbrock4

## Synopsis

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

    template<typename Value,
             typename Coefficients = default_rosenbrock_coefficients< Value >,
             typename Resizer = initially_resizer>
    class rosenbrock4 {
    public:
      // types
      typedef Value                                               value_type;
      typedef boost::numeric::ublas::vector< value_type >         state_type;
      typedef state_type                                          deriv_type;
      typedef value_type                                          time_type;
      typedef boost::numeric::ublas::matrix< value_type >         matrix_type;
      typedef boost::numeric::ublas::permutation_matrix< size_t > pmatrix_type;
      typedef Resizer                                             resizer_type;
      typedef Coefficients                                        rosenbrock_coefficients;
      typedef stepper_tag                                         stepper_category;
      typedef unsigned short                                      order_type;
      typedef state_wrapper< state_type >                         wrapped_state_type;
      typedef state_wrapper< deriv_type >                         wrapped_deriv_type;
      typedef state_wrapper< matrix_type >                        wrapped_matrix_type;
      typedef state_wrapper< pmatrix_type >                       wrapped_pmatrix_type;
      typedef rosenbrock4< Value, Coefficients, Resizer >         stepper_type;

      // construct/copy/destruct
      rosenbrock4(void);

      // public member functions
      order_type order() const;
      template<typename System>
        void do_step(System, const state_type &, time_type, state_type &,
                     time_type, state_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);
      template<typename System>
        void do_step(System, state_type &, time_type, time_type);
      void prepare_dense_output();
      void calc_state(time_type, state_type &, const state_type &, time_type,
                      const state_type &, time_type);
      template<typename StateType> void adjust_size(const StateType &);

      // protected member functions
      template<typename StateIn> bool resize_impl(const StateIn &);
      template<typename StateIn> bool resize_x_err(const StateIn &);

      // public data members
      static const order_type stepper_order;
      static const order_type error_order;
    };

## Description

### `rosenbrock4` public construct/copy/destruct

1.     rosenbrock4(void);

### `rosenbrock4` public member functions

1.     order_type order() const;

2.     template<typename System>
         void do_step(System system, const state_type & x, time_type t,
                      state_type & xout, time_type dt, state_type & xerr);

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

4.     template<typename System>
         void do_step(System system, const state_type & x, time_type t,
                      state_type & xout, time_type dt);

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

6.     void prepare_dense_output();

7.     void calc_state(time_type t, state_type & x, const state_type & x_old,
                       time_type t_old, const state_type & x_new, time_type t_new);

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

### `rosenbrock4` protected member functions

1.     template<typename StateIn> bool resize_impl(const StateIn & x);

2.     template<typename StateIn> bool resize_x_err(const StateIn & x);