1 /* 2 [auto_generated] 3 boost/numeric/odeint/stepper/euler.hpp 4 5 [begin_description] 6 Implementation of the classical explicit Euler stepper. This method is really simple and should only 7 be used for demonstration purposes. 8 [end_description] 9 10 Copyright 2010-2013 Karsten Ahnert 11 Copyright 2010-2013 Mario Mulansky 12 13 Distributed under the Boost Software License, Version 1.0. 14 (See accompanying file LICENSE_1_0.txt or 15 copy at http://www.boost.org/LICENSE_1_0.txt) 16 */ 17 18 19 #ifndef BOOST_NUMERIC_ODEINT_STEPPER_EULER_HPP_INCLUDED 20 #define BOOST_NUMERIC_ODEINT_STEPPER_EULER_HPP_INCLUDED 21 22 23 #include <boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp> 24 #include <boost/numeric/odeint/util/resizer.hpp> 25 #include <boost/numeric/odeint/algebra/range_algebra.hpp> 26 #include <boost/numeric/odeint/algebra/default_operations.hpp> 27 #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> 28 #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> 29 30 namespace boost { 31 namespace numeric { 32 namespace odeint { 33 34 35 template< 36 class State , 37 class Value = double , 38 class Deriv = State , 39 class Time = Value , 40 class Algebra = typename algebra_dispatcher< State >::algebra_type , 41 class Operations = typename operations_dispatcher< State >::operations_type , 42 class Resizer = initially_resizer 43 > 44 #ifndef DOXYGEN_SKIP 45 class euler 46 : public explicit_stepper_base< 47 euler< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 48 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer > 49 #else 50 class euler : public explicit_stepper_base 51 #endif 52 { 53 public : 54 55 #ifndef DOXYGEN_SKIP 56 typedef explicit_stepper_base< euler< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; 57 #else 58 typedef explicit_stepper_base< euler< ... > , ... > stepper_base_type; 59 #endif 60 typedef typename stepper_base_type::state_type state_type; 61 typedef typename stepper_base_type::value_type value_type; 62 typedef typename stepper_base_type::deriv_type deriv_type; 63 typedef typename stepper_base_type::time_type time_type; 64 typedef typename stepper_base_type::algebra_type algebra_type; 65 typedef typename stepper_base_type::operations_type operations_type; 66 typedef typename stepper_base_type::resizer_type resizer_type; 67 68 #ifndef DOXYGEN_SKIP 69 typedef typename stepper_base_type::stepper_type stepper_type; 70 typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; 71 typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; 72 #endif 73 74 euler(const algebra_type & algebra=algebra_type ())75 euler( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra ) 76 { } 77 78 template< class System , class StateIn , class DerivIn , class StateOut > do_step_impl(System,const StateIn & in,const DerivIn & dxdt,time_type,StateOut & out,time_type dt)79 void do_step_impl( System /* system */ , const StateIn &in , const DerivIn &dxdt , time_type /* t */ , StateOut &out , time_type dt ) 80 { 81 stepper_base_type::m_algebra.for_each3( out , in , dxdt , 82 typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , dt ) ); 83 84 } 85 86 template< class StateOut , class StateIn1 , class StateIn2 > calc_state(StateOut & x,time_type t,const StateIn1 & old_state,time_type t_old,const StateIn2 &,time_type) const87 void calc_state( StateOut &x , time_type t , const StateIn1 &old_state , time_type t_old , const StateIn2 & /*current_state*/ , time_type /* t_new */ ) const 88 { 89 const time_type delta = t - t_old; 90 stepper_base_type::m_algebra.for_each3( x , old_state , stepper_base_type::m_dxdt.m_v , 91 typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , delta ) ); 92 } 93 94 template< class StateType > adjust_size(const StateType & x)95 void adjust_size( const StateType &x ) 96 { 97 stepper_base_type::adjust_size( x ); 98 } 99 }; 100 101 102 103 /********** DOXYGEN ***********/ 104 105 /** 106 * \class euler 107 * \brief An implementation of the Euler method. 108 * 109 * The Euler method is a very simply solver for ordinary differential equations. This method should not be used 110 * for real applications. It is only useful for demonstration purposes. Step size control is not provided but 111 * trivial continuous output is available. 112 * 113 * This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern), 114 * see explicit_stepper_base 115 * 116 * \tparam State The state type. 117 * \tparam Value The value type. 118 * \tparam Deriv The type representing the time derivative of the state. 119 * \tparam Time The time representing the independent variable - the time. 120 * \tparam Algebra The algebra type. 121 * \tparam Operations The operations type. 122 * \tparam Resizer The resizer policy type. 123 */ 124 125 /** 126 * \fn euler::euler( const algebra_type &algebra ) 127 * \brief Constructs the euler class. This constructor can be used as a default 128 * constructor of the algebra has a default constructor. 129 * \param algebra A copy of algebra is made and stored inside explicit_stepper_base. 130 */ 131 132 /** 133 * \fn euler::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) 134 * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. 135 * The result is updated out of place, hence the input is in `in` and the output in `out`. 136 * Access to this step functionality is provided by explicit_stepper_base and 137 * `do_step_impl` should not be called directly. 138 * 139 * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the 140 * Simple System concept. 141 * \param in The state of the ODE which should be solved. in is not modified in this method 142 * \param dxdt The derivative of x at t. 143 * \param t The value of the time, at which the step should be performed. 144 * \param out The result of the step is written in out. 145 * \param dt The step size. 146 */ 147 148 149 /** 150 * \fn euler::calc_state( StateOut &x , time_type t , const StateIn1 &old_state , time_type t_old , const StateIn2 ¤t_state , time_type t_new ) const 151 * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the 152 * knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`. 153 */ 154 155 /** 156 * \fn euler::adjust_size( const StateType &x ) 157 * \brief Adjust the size of all temporaries in the stepper manually. 158 * \param x A state from which the size of the temporaries to be resized is deduced. 159 */ 160 161 } // odeint 162 } // numeric 163 } // boost 164 165 166 #endif // BOOST_NUMERIC_ODEINT_STEPPER_EULER_HPP_INCLUDED 167