boost/odeint
2
0
Fork 0
mirror of https://github.com/boostorg/odeint.git synced 2026-01-30 20:12:19 +00:00
Code Issues Projects Releases Wiki Activity

continues with reference

Browse Source
This commit is contained in:
Karsten Ahnert
2012-10-19 15:47:22 +02:00
parent aaf87adfad
commit 452ca84cf8
9 changed files with 304 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
View File

@@ -69,6 +69,30 @@ namespace odeint {
* `do_step_impl( system , in , dxdt_in , t , out , dt , xerr )`.
* explicit_error_stepper_base derives from algebra_stepper_base.
*
* explicit_error_stepper_base provides several overloaded `do_step` methods, see the list below. Only two of them are needed
* to fullfil the Error Stepper concept. The other one are for convenience and for performance. Some of them simply update the
* state out-of-place, while other expect that the first derivative at `t` is passed to the stepper.
*
* - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fullfil the Error Stepper concept. The state is updated in-place.
* A type modelling a Boost.Range can be used for x.
* - `do_step( sys , x , dxdt , t , dt )` - This method updates the state in-place, but the derivative at the point `t` must be
* explicitely passed in `dxdt`.
* - `do_step( sys , in , t , out , dt )` - This method updates the state out-of-place, hence the result of the step is stored in `out`.
* - `do_step( sys , in , dxdt , t , out , dt )` - This method update the state out-of-place and expects that the derivative at the point
* `t` is explicitely passed in `dxdt`. It is a combination of the two `do_step` methods above.
* - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fullfil the Error Stepper concept. The state is updated in-place
* and an error estimate is calculated. A type modelling a Boost.Range can be used for x.
* - `do_step( sys , x , dxdt , t , dt , xerr )` - This method updates the state in-place, but the derivative at the point `t` must be passed
* in `dxdt`. An error estimate is calculated.
* - `do_step( sys , in , t , out , dt , xerr )` - This method updates the state out-of-place and estimates the error during the step.
* - `do_step( sys , in , dxdt , t , out , dt , xerr )` - This methods updates the state out-of-place and estimates the error during the step.
* Furthermore, the derivative at `t` must be passed in `dxdt`.
*
* \note The system is always passed as value, which might result in poor performance if it contains data. In this case it can be used with `boost::ref`
* or `std::ref`, for example `stepper.do_step( boost::ref( sys ) , x , t , dt );`
*
* \note The time `t` is not advanced by the stepper. This has to done manually, or by the appropriate `integrate` routines or `iterator`s.
*
* \tparam Stepper The stepper on which this class should work. It is used via CRTP, hence explicit_stepper_base
* provides the interface for the Stepper.
* \tparam Order The order of a stepper if the stepper is used without error estimation.
@@ -321,10 +345,8 @@ public:
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
* \param x The state of the ODE which should be solved. x is updated by this method.
* \param t The value of the time, at which the step should be performed.
* \param out The result of the step is written in out.
* \param dt The step size.
* \param xerr The estimation of the error is stored in xerr.
*/
@@ -342,10 +364,8 @@ public:
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
* \param x The state of the ODE which should be solved. x is updated by this method.
* \param t The value of the time, at which the step should be performed.
* \param out The result of the step is written in out.
* \param dt The step size.
* \param xerr The estimation of the error is stored in xerr.
*/

27
boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
View File

@@ -90,15 +90,23 @@ namespace odeint {
*
* \code
* sys( x , dxdt , t );
* stepper.do_step( sys , x , dxdt , t , dt ); // the value of dxdt is used in the performance of the step
* stepper.do_step( sys , x , dxdt , t , dt ); // the value of dxdt is used here
* t += dt;
* \endcode
*
* In detail explicit_stepper_base provides the following `do_step` variants
* - `do_step( sys , x , t , dt )` - bla
* - `do_step( sys , in , t , out , dt )` - blub
* - `do_step( sys , x , dxdt , t , dt )` - bla
* - `do_step( sys , in , dxdt , t , out , dt )` -blub
* - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fullfil the Stepper concept. The state is updated in-place.
* A type modelling a Boost.Range can be used for x.
* - `do_step( sys , in , t , out , dt )` - This method updates the state out-of-place, hence the result of the step is stored in `out`.
* - `do_step( sys , x , dxdt , t , dt )` - This method updates the state in-place, but the derivative at the point `t` must be
* explicitely passed in `dxdt`. For an example see the code snippet above.
* - `do_step( sys , in , dxdt , t , out , dt )` - This method update the state out-of-place and expects that the derivative at the point
* `t` is explicitely passed in `dxdt`. It is a combination of the two `do_step` methods above.
*
* \note The system is always passed as value, which might result in poor performance if it contains data. In this case it can be used with `boost::ref`
* or `std::ref`, for example `stepper.do_step( boost::ref( sys ) , x , t , dt );`
*
* \note The time `t` is not advanced by the stepper. This has to done manually, or by the appropriate `integrate` routines or `iterator`s.
*
* \tparam Stepper The stepper on which this class should work. It is used via CRTP, hence explicit_stepper_base
* provides the interface for the Stepper.
@@ -308,6 +316,15 @@ public:
}
/**
* \brief Adjust the size of all temporaries in the stepper manually.
* \param x A state from which the size of the temporaries to be resized is deduced.
*/
template< class StateIn >
void adjust_size( const StateIn &x )
{
resize_impl( x );
}
private:

72
boost/numeric/odeint/stepper/euler.hpp
View File

@@ -29,9 +29,27 @@ namespace boost {
namespace numeric {
namespace odeint {
template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resizer >
class dense_output_explicit_euler;
/**
* \class euler
* \brief An implementation of the Euler method.
*
* The Euler method is a very simply solver for ordinary differential equations. This method should not be used
* for real applications. It is only useful for demonstration purposes. Step size control is not provided but
* trivial continous output is available.
*
* This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern),
* see explicit_stepper_base
*
* \tparam State The state type.
* \tparam Value The value type.
* \tparam Deriv The type representing the time derivative of the state.
* \tparam Time The time representing the independent variable - the time.
* \tparam Algebra The algebra type.
* \tparam Operations The operations type.
* \tparam Resizer The resizer policy type.
*/
template<
class State ,
class Value = double ,
@@ -41,31 +59,58 @@ class Algebra = range_algebra ,
class Operations = default_operations ,
class Resizer = initially_resizer
>
#ifndef DOXYGEN_SKIP
class euler
: public explicit_stepper_base<
euler< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
1 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
#else
class euler : public explicit_stepper_base< euler< ... > , ... >
#endif
{
public :
friend class dense_output_explicit_euler< State , Value , Deriv , Time , Algebra , Operations , Resizer >;
#ifndef DOXYGEN_SKIP
typedef explicit_stepper_base< euler< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type;
#else
typedef explicit_stepper_base< euler< ... > , ... > stepper_base_type;
#endif
typedef typename stepper_base_type::state_type state_type;
typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
typedef typename stepper_base_type::value_type value_type;
typedef typename stepper_base_type::deriv_type deriv_type;
typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
typedef typename stepper_base_type::time_type time_type;
typedef typename stepper_base_type::algebra_type algebra_type;
typedef typename stepper_base_type::operations_type operations_type;
typedef typename stepper_base_type::resizer_type resizer_type;
#ifndef DOXYGEN_SKIP
typedef typename stepper_base_type::stepper_type stepper_type;
typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
#endif
/**
* \brief Constructs the euler class. This constructor can be used as a default
* constructor of the algebra has a default constructor.
* \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
*/
euler( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra )
{ }
/**
* \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
* The result is updated out of place, hence the input is in `in` and the output in `out`. `do_step_impl` is
* used by explicit_stepper_base.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
* \param t The value of the time, at which the step should be performed.
* \param out The result of the step is written in out.
* \param dt The step size.
*/
template< class System , class StateIn , class DerivIn , class StateOut >
void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
{
@@ -74,6 +119,11 @@ public :
}
/**
* \brief This method is used for continous output and it calculates the state `x` at a time `t` from the
* knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`.
*/
template< class StateOut , class StateIn1 , class StateIn2 >
void calc_state( StateOut &x , time_type t , const StateIn1 &old_state , time_type t_old , const StateIn2 &current_state , time_type t_new )
{
@@ -82,7 +132,15 @@ public :
typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , delta ) );
}
/**
* \brief Adjust the size of all temporaries in the stepper manually.
* \param x A state from which the size of the temporaries to be resized is deduced.
*/
template< class StateType >
void adjust_size( const StateType &x )
{
stepper_base_type::adjust_size( x );
}
};

59
boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp
View File

@@ -36,6 +36,30 @@ namespace boost {
namespace numeric {
namespace odeint {
/**
* \class explicit_error_generic_rk
* \brief A generic implementation of explicit Runge-Kutta algorithms with error estimation. This class is as a
* base class for all explicit Runge-Kutta steppers with error estimateion.
*
* This class implements the explicit Runge-Kutta algorithms with error estimation in a generic way.
* The Butcher tableau is passed to the stepper which constructs the stepper scheme with the help of a
* template-metaprogramming algorithm. ToDo : Add example!
*
* This class derives explicit_error_stepper_base which provides the stepper interface.
*
* \tparam StageCount The number of stages of the Runge-Kutta algorithm.
* \tparam Order The order of a stepper if the stepper is used without error estimation.
* \tparam StepperOrder The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have
* the same value.
* \tparam ErrorOrder The order of the error step if the stepper is used with error estimation.
* \tparam State The type representing the state of the ODE.
* \tparam Value The floating point type which is used in the computations.
* \tparam Time The type representing the independent variable - the time - of the ODE.
* \tparam Algebra The algebra type.
* \tparam Operations The operations type.
* \tparam Resizer The resizer policy type.
*/
template<
size_t StageCount,
size_t Order,
@@ -102,6 +126,21 @@ public:
{ }
/**
* \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
* The result is updated out-of-place, hence the input is in `in` and the output in `out`. Futhermore, an
* estimation of the error is stored in `xerr`. `do_step_impl` is used by explicit_error_stepper_base.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
* \param t The value of the time, at which the step should be performed.
* \param out The result of the step is written in out.
* \param dt The step size.
* \param xerr The result of the error estimation is written in xerr.
*/
template< class System , class StateIn , class DerivIn , class StateOut , class Err >
void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt ,
time_type t , StateOut &out , time_type dt , Err &xerr )
@@ -114,6 +153,20 @@ public:
xerr , dxdt , m_F , detail::generic_rk_scale_sum_err< StageCount , operations_type , value_type , time_type >( m_b2 , dt) );
}
/**
* \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
* The result is updated out-of-place, hence the input is in `in` and the output in `out`. `do_step_impl` is
* used by explicit_error_stepper_base.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
* \param t The value of the time, at which the step should be performed.
* \param out The result of the step is written in out.
* \param dt The step size.
*/
template< class System , class StateIn , class DerivIn , class StateOut >
void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt ,
time_type t , StateOut &out , time_type dt )
@@ -124,6 +177,12 @@ public:
m_rk_algorithm.do_step( stepper_base_type::m_algebra , system , in , dxdt , t , out , dt , m_x_tmp.m_v , m_F );
}
/**
* \brief Adjust the size of all temporaries in the stepper manually.
* \param x A state from which the size of the temporaries to be resized is deduced.
*/
template< class StateType >
void adjust_size( const StateType &x )
{

13
boost/numeric/odeint/stepper/runge_kutta4.hpp
View File

@@ -102,12 +102,13 @@ struct rk4_coefficients_c : boost::array< Value , 4 >
* \brief The classical Runge-Kutta stepper of fourth order.
*
* The Runge-Kutta method of fourth order is one standard method for
* solving ordinary differential equations and is widely used. The method is
* explicit and fullfils the Stepper concept. Step size control or continous
* output are not provided. This class uses the generic Runge-Kutta algorithm.
* solving ordinary differential equations and is widely used, see also
* <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods">en.wikipedia.org/wiki/Runge-Kutta_methods</a>
* The method is explicit and fullfils the Stepper concept. Step size control
* or continous output are not provided.
*
* This class derives from explicit_stepper_base and explicit_generic_rk and inherits
* its interface via CRTP (current recurring template pattern). For more details see
* This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern).
* Furthermore, it derivs from explicit_generic_rk which is a generic Runge-Kutta algorithm. For more details see
* explicit_stepper_base and explicit_generic_rk.
*
* \tparam State The state type.
@@ -116,7 +117,7 @@ struct rk4_coefficients_c : boost::array< Value , 4 >
* \tparam Time The time representing the independent variable - the time.
* \tparam Algebra The algebra type.
* \tparam Operations The operations type.
* \tparam The resizer policy type.
* \tparam Resizer The resizer policy type.
*/
template<
class State ,

20
boost/numeric/odeint/stepper/runge_kutta4_classic.hpp
View File

@@ -37,9 +37,10 @@ namespace odeint {
* \brief The classical Runge-Kutta stepper of fourth order.
*
* The Runge-Kutta method of fourth order is one standard method for
* solving ordinary differential equations and is widely used. The method is
* explicit and fullfils the Stepper concept. Step size control or continous
* output are not provided. This class implements the method directly, hence the
* solving ordinary differential equations and is widely used, see also
* <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods">en.wikipedia.org/wiki/Runge-Kutta_methods</a>
* The method is explicit and fullfils the Stepper concept. Step size control
* or continous output are not provided. This class implements the method directly, hence the
* generic Runge-Kutta algorithm is not used.
*
* This class derives from explicit_stepper_base and inherits its interface via
@@ -52,7 +53,7 @@ namespace odeint {
* \tparam Time The time representing the independent variable - the time.
* \tparam Algebra The algebra type.
* \tparam Operations The operations type.
* \tparam The resizer policy type.
* \tparam Resizer The resizer policy type.
*/
template<
class State ,
@@ -63,17 +64,26 @@ class Algebra = range_algebra ,
class Operations = default_operations ,
class Resizer = initially_resizer
>
#ifndef DOXYGEN_SKIP
class runge_kutta4_classic
: public explicit_stepper_base<
runge_kutta4_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
4 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
#else
class runge_kutta4_classic
: public explicit_stepper_base< runge_kutta4_classic< ... > , ... >
#endif
{
public :
#ifndef DOXYGEN_SKIP
typedef explicit_stepper_base<
runge_kutta4_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type;
#else
typedef explicit_stepper_base< runge_kutta4_classic< ... > , ... > stepper_base_type;
#endif
typedef typename stepper_base_type::state_type state_type;
typedef typename stepper_base_type::value_type value_type;
@@ -82,9 +92,9 @@ public :
typedef typename stepper_base_type::algebra_type algebra_type;
typedef typename stepper_base_type::operations_type operations_type;
typedef typename stepper_base_type::resizer_type resizer_type;
typedef typename stepper_base_type::stepper_type stepper_type;
#ifndef DOXYGEN_SKIP
typedef typename stepper_base_type::stepper_type stepper_type;
typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
#endif // DOXYGEN_SKIP

32
boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp
View File

@@ -38,6 +38,8 @@ namespace boost {
namespace numeric {
namespace odeint {
#ifndef DOXYGEN_SKIP
template< class Value = double >
struct rk54_ck_coefficients_a1 : boost::array< Value , 1 >
{
@@ -136,7 +138,31 @@ struct rk54_ck_coefficients_c : boost::array< Value , 6 >
(*this)[5] = static_cast<Value>( 7 )/static_cast<Value>( 8 );
}
};
#endif
/**
* \class runge_kutta_cash_karp54
* \brief The Runge-Kutta Cash-Karp method.
*
* The Runge-Kutta Cash-Karp method is one of the standard methods for
* solving ordinary differential equations, see
* <a href="http://en.wikipedia.org/wiki/Cash%E2%80%93Karp_methods">en.wikipedia.org/wiki/Cash-Karp_methods</a>.
* The method is explicit and fullfils the Error Stepper concept. Step size control
* is provided but continous output is not available for this method.
*
* This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern).
* Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation.
* For more details see explicit_error_stepper_base and explicit_error_generic_rk.
*
* \tparam State The state type.
* \tparam Value The value type.
* \tparam Deriv The type representing the time derivative of the state.
* \tparam Time The time representing the independent variable - the time.
* \tparam Algebra The algebra type.
* \tparam Operations The operations type.
* \tparam Resizer The resizer policy type.
*/
template<
class State ,
class Value = double ,
@@ -166,6 +192,12 @@ public:
typedef typename stepper_base_type::resizer_type resizer_typ;
typedef typename stepper_base_type::stepper_type stepper_type;
/**
* \brief Constructs the runge_kutta_cash_karp54 class. This constructor can be used as a default
* constructor if the algebra has a default constructor.
* \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
*/
runge_kutta_cash_karp54( const algebra_type &algebra = algebra_type() ) : stepper_base_type(
boost::fusion::make_vector( rk54_ck_coefficients_a1<Value>() ,
rk54_ck_coefficients_a2<Value>() ,

76
boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp
View File

@@ -36,9 +36,26 @@ namespace odeint {
/*
* ToDo: Check orders rk_ckc
/**
* \class runge_kutta_cash_karp54_classic
* \brief The Runge-Kutta Cash-Karp method implemented without the generic Runge-Kutta algorithm.
*
* The Runge-Kutta Cash-Karp method is one of the standard methods for
* solving ordinary differential equations, see
* <a href="http://en.wikipedia.org/wiki/Cash%E2%80%93Karp_method">en.wikipedia.org/wiki/Cash-Karp_method</a>.
* The method is explicit and fullfils the Error Stepper concept. Step size control
* is provided but continous output is not available for this method.
*
* This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring
* template pattern). This class implements the method directly, hence the generic Runge-Kutta algorithm is not used.
*
* \tparam State The state type.
* \tparam Value The value type.
* \tparam Deriv The type representing the time derivative of the state.
* \tparam Time The time representing the independent variable - the time.
* \tparam Algebra The algebra type.
* \tparam Operations The operations type.
* \tparam Resizer The resizer policy type.
*/
template<
class State ,
@@ -49,35 +66,67 @@ class Algebra = range_algebra ,
class Operations = default_operations ,
class Resizer = initially_resizer
>
#ifndef DOXYGEN_SKIP
class runge_kutta_cash_karp54_classic
: public explicit_error_stepper_base<
runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
#else
class runge_kutta_cash_karp54_classic
: public explicit_error_stepper_base< runge_kutta_cash_karp54_classic< ... > , ... >
#endif
{
public :
#ifndef DOXYGEN_SKIP
typedef explicit_error_stepper_base<
runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type;
#else
typedef explicit_error_stepper_base< runge_kutta_cash_karp54_classic< ... > , ... > stepper_base_type;
#endif
typedef typename stepper_base_type::state_type state_type;
typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
typedef typename stepper_base_type::value_type value_type;
typedef typename stepper_base_type::deriv_type deriv_type;
typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
typedef typename stepper_base_type::time_type time_type;
typedef typename stepper_base_type::algebra_type algebra_type;
typedef typename stepper_base_type::operations_type operations_type;
typedef typename stepper_base_type::resizer_type resizer_type;
#ifndef DOXYGEN_SKIP
typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
typedef typename stepper_base_type::stepper_type stepper_type;
#endif
/**
* \brief Constructs the runge_kutta_cash_karp54_classic class. This constructor can be used as a default
* constructor if the algebra has a default constructor.
* \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
*/
runge_kutta_cash_karp54_classic( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra )
{ }
/**
* \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
* The result is updated out-of-place, hence the input is in `in` and the output in `out`. Futhermore, an
* estimation of the error is stored in `xerr`. `do_step_impl` is used by explicit_error_stepper_base.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
* \param t The value of the time, at which the step should be performed.
* \param out The result of the step is written in out.
* \param dt The step size.
* \param xerr The result of the error estimation is written in xerr.
*/
template< class System , class StateIn , class DerivIn , class StateOut , class Err >
void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
{
@@ -102,6 +151,19 @@ public :
/**
* \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
* The result is updated out-of-place, hence the input is in `in` and the output in `out`. `do_step_impl` is
* used by explicit_error_stepper_base.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
* \param t The value of the time, at which the step should be performed.
* \param out The result of the step is written in out.
* \param dt The step size.
*/
template< class System , class StateIn , class DerivIn , class StateOut >
void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
{
@@ -164,6 +226,10 @@ public :
}
/**
* \brief Adjust the size of all temporaries in the stepper manually.
* \param x A state from which the size of the temporaries to be resized is deduced.
*/
template< class StateIn >
void adjust_size( const StateIn &x )
{

14
libs/numeric/odeint/doc/Jamfile
View File

@@ -49,15 +49,15 @@ else
doxygen reference
:
[ glob ../../../../boost/numeric/odeint/*.hpp ]
# [ glob ../../../../boost/numeric/odeint/*.hpp ]
[ glob ../../../../boost/numeric/odeint/stepper/*.hpp ]
[ glob ../../../../boost/numeric/odeint/stepper/base/*.hpp ]
[ glob ../../../../boost/numeric/odeint/stepper/generation/*.hpp ]
[ glob ../../../../boost/numeric/odeint/integrate/*.hpp ]
[ glob ../../../../boost/numeric/odeint/iterator/*.hpp ]
[ glob ../../../../boost/numeric/odeint/algebra/*.hpp ]
[ glob ../../../../boost/numeric/odeint/util/*.hpp ]
../../../../boost/numeric/odeint.hpp
# [ glob ../../../../boost/numeric/odeint/stepper/generation/*.hpp ]
# [ glob ../../../../boost/numeric/odeint/integrate/*.hpp ]
# [ glob ../../../../boost/numeric/odeint/iterator/*.hpp ]
# [ glob ../../../../boost/numeric/odeint/algebra/*.hpp ]
# [ glob ../../../../boost/numeric/odeint/util/*.hpp ]
# ../../../../boost/numeric/odeint.hpp
:
# Lots of parameters passed to Doxygen. You can see these in the doxygen docs, or the Wizard Expert tab displays them.