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 an old version of Boost. Click here to view this page for the latest version.
Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Class template symplectic_euler

boost::numeric::odeint::symplectic_euler — Implementation of the symplectic Euler method.

Synopsis

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

template<typename Coor, typename Momentum = Coor, typename Value = double, 
         typename CoorDeriv = Coor, typename MomentumDeriv = Coor, 
         typename Time = Value, typename Algebra = range_algebra, 
         typename Operations = default_operations, 
         typename Resizer = initially_resizer> 
class symplectic_euler : public boost::numeric::odeint::symplectic_nystroem_stepper_base< NumOfStages, Order, Coor, Momentum, Value, CoorDeriv, MomentumDeriv, Time, Algebra, Operations, Resizer >
{
public:
  // types
  typedef stepper_base_type::algebra_type algebra_type;
  typedef stepper_base_type::value_type   value_type;  

  // construct/copy/destruct
  symplectic_euler(const algebra_type & = algebra_type());

  // public member functions
  order_type order(void) const;
  template<typename System, typename StateInOut> 
    void do_step(System, const StateInOut &, time_type, time_type);
  template<typename System, typename StateInOut> 
    void do_step(System, StateInOut &, time_type, time_type);
  template<typename System, typename CoorInOut, typename MomentumInOut> 
    void do_step(System, CoorInOut &, MomentumInOut &, time_type, time_type);
  template<typename System, typename CoorInOut, typename MomentumInOut> 
    void do_step(System, const CoorInOut &, const MomentumInOut &, time_type, 
                 time_type);
  template<typename System, typename StateIn, typename StateOut> 
    void do_step(System, const StateIn &, time_type, StateOut &, time_type);
  template<typename StateType> void adjust_size(const StateType &);
  const coef_type & coef_a(void) const;
  const coef_type & coef_b(void) const;
  algebra_type & algebra();
  const algebra_type & algebra() const;
};

Description

The method is of first order and has one stage. It is described HERE.

Template Parameters

  1. typename Coor

    The type representing the coordinates q.

  2. typename Momentum = Coor

    The type representing the coordinates p.

  3. typename Value = double

    The basic value type. Should be something like float, double or a high-precision type.

  4. typename CoorDeriv = Coor

    The type representing the time derivative of the coordinate dq/dt.

  5. typename MomentumDeriv = Coor
  6. typename Time = Value

    The type representing the time t.

  7. typename Algebra = range_algebra

    The algebra.

  8. typename Operations = default_operations

    The operations.

  9. typename Resizer = initially_resizer

    The resizer policy.

symplectic_euler public construct/copy/destruct

  1. symplectic_euler(const algebra_type & algebra = algebra_type());
    Constructs the symplectic_euler. This constructor can be used as a default constructor if the algebra has a default constructor.

    Parameters:

    algebra

    A copy of algebra is made and stored inside explicit_stepper_base.

symplectic_euler public member functions

  1. order_type order(void) const;

    Returns:

    Returns the order of the stepper.

  2. template<typename System, typename StateInOut> 
      void do_step(System system, const StateInOut & state, time_type t, 
                   time_type dt);
    This method performs one step. The system can be either a pair of two function object describing the momentum part and the coordinate part or one function object describing only the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state is updated in-place.
    [Note] Note

    boost::ref or std::ref can be used for the system as well as for the state. So, it is correct to write stepper.do_step( make_pair( std::ref( fq ) , std::ref( fp ) ) , make_pair( std::ref( q ) , std::ref( p ) ) , t , dt ).

    This method solves the forwarding problem.

    Parameters:

    dt

    The time step.

    state

    The state of the ODE. It is a pair of Coor and Momentum. The state is updated in-place, therefore, the new value of the state will be written into this variable.

    system

    The system, can be represented as a pair of two function object or one function object. See above.

    t

    The time of the ODE. It is not advanced by this method.

  3. template<typename System, typename StateInOut> 
      void do_step(System system, StateInOut & state, time_type t, time_type dt);
    Same function as above. It differs only in a different const specifier in order to solve the forwarding problem, can be used with Boost.Range.
  4. template<typename System, typename CoorInOut, typename MomentumInOut> 
      void do_step(System system, CoorInOut & q, MomentumInOut & p, time_type t, 
                   time_type dt);
    This method performs one step. The system can be either a pair of two function object describing the momentum part and the coordinate part or one function object describing only the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state is updated in-place.
    [Note] Note

    boost::ref or std::ref can be used for the system. So, it is correct to write stepper.do_step( make_pair( std::ref( fq ) , std::ref( fp ) ) , q , p , t , dt ).

    This method solves the forwarding problem.

    Parameters:

    dt

    The time step.

    p

    The momentum of the ODE. It is updated in-place. Therefore, the new value of the momentum will be written info this variable.

    q

    The coordinate of the ODE. It is updated in-place. Therefore, the new value of the coordinate will be written into this variable.

    system

    The system, can be represented as a pair of two function object or one function object. See above.

    t

    The time of the ODE. It is not advanced by this method.

  5. template<typename System, typename CoorInOut, typename MomentumInOut> 
      void do_step(System system, const CoorInOut & q, const MomentumInOut & p, 
                   time_type t, time_type dt);
    Same function as do_step( system , q , p , t , dt ). It differs only in a different const specifier in order to solve the forwarding problem, can be called with Boost.Range.
  6. template<typename System, typename StateIn, typename StateOut> 
      void do_step(System system, const StateIn & in, time_type t, StateOut & out, 
                   time_type dt);
    This method performs one step. The system can be either a pair of two function object describing the momentum part and the coordinate part or one function object describing only the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state is updated out-of-place.
    [Note] Note

    boost::ref or std::ref can be used for the system. So, it is correct to write stepper.do_step( make_pair( std::ref( fq ) , std::ref( fp ) ) , x_in , t , x_out , dt ).

    This method NOT solve the forwarding problem.

    Parameters:

    dt

    The time step.

    in

    The state of the ODE, which is a pair of coordinate and momentum. The state is updated out-of-place, therefore the new value is written into out

    out

    The new state of the ODE.

    system

    The system, can be represented as a pair of two function object or one function object. See above.

    t

    The time of the ODE. It is not advanced by this method.

  7. 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.

  8. const coef_type & coef_a(void) const;
    Returns the coefficients a.
  9. const coef_type & coef_b(void) const;
    Returns the coefficients b.
  10. algebra_type & algebra();

    Returns:

    A reference to the algebra which is held by this class.

  11. const algebra_type & algebra() const;

    Returns:

    A const reference to the algebra which is held by this class.


PrevUpHomeNext