Class template implicit_euler

| Home | Libraries | People | FAQ | More

## Class template implicit_euler

boost::numeric::odeint::implicit_euler

## Synopsis

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

    template<typename ValueType, typename Resizer = initially_resizer>
    class implicit_euler {
    public:
      // types
      typedef ValueType                                           value_type;
      typedef value_type                                          time_type;
      typedef boost::numeric::ublas::vector< value_type >         state_type;
      typedef state_wrapper< state_type >                         wrapped_state_type;
      typedef state_type                                          deriv_type;
      typedef state_wrapper< deriv_type >                         wrapped_deriv_type;
      typedef boost::numeric::ublas::matrix< value_type >         matrix_type;
      typedef state_wrapper< matrix_type >                        wrapped_matrix_type;
      typedef boost::numeric::ublas::permutation_matrix< size_t > pmatrix_type;
      typedef state_wrapper< pmatrix_type >                       wrapped_pmatrix_type;
      typedef Resizer                                             resizer_type;
      typedef stepper_tag                                         stepper_category;
      typedef implicit_euler< ValueType, Resizer >                stepper_type;

      // construct/copy/destruct
      implicit_euler(value_type = 1E-6);

      // public member functions
      template<typename System>
        void do_step(System, state_type &, time_type, time_type);
      template<typename StateType> void adjust_size(const StateType &);

      // private member functions
      template<typename StateIn> bool resize_impl(const StateIn &);
      void solve(state_type &, matrix_type &);
    };

## Description

### `implicit_euler` public construct/copy/destruct

1.     implicit_euler(value_type epsilon = 1E-6);

### `implicit_euler` public member functions

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

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

### `implicit_euler` private member functions

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

2.     void solve(state_type & x, matrix_type & m);