taynpg/cxxLibrary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

整理

Browse Source
This commit is contained in:
taynpg
2026-03-23 20:54:41 +08:00
commit e13b3650e9
4596 changed files with 1015768 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
include/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp Normal file
View File

@@ -0,0 +1,91 @@
/*
[auto_generated]
boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp
[begin_description]
Base class for all steppers with an algebra and operations.
[end_description]
Copyright 2012-2013 Karsten Ahnert
Copyright 2012 Mario Mulansky
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or
copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_ALGEBRA_STEPPER_BASE_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_ALGEBRA_STEPPER_BASE_HPP_INCLUDED
namespace boost {
namespace numeric {
namespace odeint {
template< class Algebra , class Operations >
class algebra_stepper_base
{
public:
typedef Algebra algebra_type;
typedef Operations operations_type;
algebra_stepper_base( const algebra_type &algebra = algebra_type() )
: m_algebra( algebra ) { }
algebra_type& algebra()
{
return m_algebra;
}
const algebra_type& algebra() const
{
return m_algebra;
}
protected:
algebra_type m_algebra;
};
/******* DOXYGEN *******/
/**
* \class algebra_stepper_base
* \brief Base class for all steppers with algebra and operations.
*
* This class serves a base class for all steppers with algebra and operations. It holds the
* algebra and provides access to the algebra. The operations are not instantiated, since they are
* static classes inside the operations class.
*
* \tparam Algebra The type of the algebra. Must fulfill the Algebra Concept, at least partially to work
* with the stepper.
* \tparam Operations The type of the operations. Must fulfill the Operations Concept, at least partially
* to work with the stepper.
*/
/**
* \fn algebra_stepper_base::algebra_stepper_base( const algebra_type &algebra = algebra_type() )
* \brief Constructs a algebra_stepper_base and creates the algebra. This constructor can be used as a default
* constructor if the algebra has a default constructor.
* \param algebra The algebra_stepper_base stores and uses a copy of algebra.
*/
/**
* \fn algebra_type& algebra_stepper_base::algebra()
* \return A reference to the algebra which is held by this class.
*/
/**
* \fn const algebra_type& algebra_stepper_base::algebra() const
* \return A const reference to the algebra which is held by this class.
*/
} // odeint
} // numeric
} // boost
#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_ALGEBRA_STEPPER_BASE_HPP_INCLUDED

588
include/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp Normal file
View File

@@ -0,0 +1,588 @@
/*
[auto_generated]
boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
[begin_description]
Base class for all explicit Runge Kutta stepper which are also error steppers.
[end_description]
Copyright 2010-2013 Karsten Ahnert
Copyright 2010-2012 Mario Mulansky
Copyright 2012 Christoph Koke
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or
copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/numeric/odeint/util/bind.hpp>
#include <boost/numeric/odeint/util/unwrap_reference.hpp>
#include <boost/numeric/odeint/util/state_wrapper.hpp>
#include <boost/numeric/odeint/util/is_resizeable.hpp>
#include <boost/numeric/odeint/util/resizer.hpp>
#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
namespace boost {
namespace numeric {
namespace odeint {
/*
* base class for explicit stepper and error steppers
* models the stepper AND the error stepper concept
*
* this class provides the following do_step variants:
* do_step( sys , x , t , dt )
* do_step( sys , x , dxdt , t , dt )
* do_step( sys , in , t , out , dt )
* do_step( sys , in , dxdt , t , out , dt )
* do_step( sys , x , t , dt , xerr )
* do_step( sys , x , dxdt , t , dt , xerr )
* do_step( sys , in , t , out , dt , xerr )
* do_step( sys , in , dxdt , t , out , dt , xerr )
*/
template<
class Stepper ,
unsigned short Order ,
unsigned short StepperOrder ,
unsigned short ErrorOrder ,
class State ,
class Value ,
class Deriv ,
class Time ,
class Algebra ,
class Operations ,
class Resizer
>
class explicit_error_stepper_base : public algebra_stepper_base< Algebra , Operations >
{
public:
typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
typedef typename algebra_stepper_base_type::algebra_type algebra_type;
typedef State state_type;
typedef Value value_type;
typedef Deriv deriv_type;
typedef Time time_type;
typedef Resizer resizer_type;
typedef Stepper stepper_type;
typedef explicit_error_stepper_tag stepper_category;
#ifndef DOXYGEN_SKIP
typedef state_wrapper< state_type > wrapped_state_type;
typedef state_wrapper< deriv_type > wrapped_deriv_type;
typedef explicit_error_stepper_base< Stepper , Order , StepperOrder , ErrorOrder ,
State , Value , Deriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
#endif
typedef unsigned short order_type;
static const order_type order_value = Order;
static const order_type stepper_order_value = StepperOrder;
static const order_type error_order_value = ErrorOrder;
explicit_error_stepper_base( const algebra_type &algebra = algebra_type() )
: algebra_stepper_base_type( algebra )
{ }
order_type order( void ) const
{
return order_value;
}
order_type stepper_order( void ) const
{
return stepper_order_value;
}
order_type error_order( void ) const
{
return error_order_value;
}
/*
* Version 1 : do_step( sys , x , t , dt )
*
* the two overloads are needed in order to solve the forwarding problem
*/
template< class System , class StateInOut >
void do_step( System system , StateInOut &x , time_type t , time_type dt )
{
do_step_v1( system , x , t , dt );
}
/**
* \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
*/
template< class System , class StateInOut >
void do_step( System system , const StateInOut &x , time_type t , time_type dt )
{
do_step_v1( system , x , t , dt );
}
/*
* Version 2 : do_step( sys , x , dxdt , t , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*
* the disable is needed to avoid ambiguous overloads if state_type = time_type
*/
template< class System , class StateInOut , class DerivIn >
typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
}
/*
* named Version 2: do_step_dxdt_impl( sys , in , dxdt , t , dt )
*
* this version is needed when this stepper is used for initializing
* multistep stepper like adams-bashforth. Hence we provide an explicitely
* named version that is not disabled. Meant for internal use only.
*/
template < class System, class StateInOut, class DerivIn >
void do_step_dxdt_impl( System system, StateInOut &x, const DerivIn &dxdt,
time_type t, time_type dt )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
}
/*
* Version 3 : do_step( sys , in , t , out , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*
* the disable is needed to avoid ambiguous overloads if state_type = time_type
*/
template< class System , class StateIn , class StateOut >
typename boost::disable_if< boost::is_same< StateIn , time_type > , void >::type
do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
{
typename odeint::unwrap_reference< System >::type &sys = system;
m_resizer.adjust_size(in, [this](auto&& arg) { return this->resize_impl<StateIn>(std::forward<decltype(arg)>(arg)); });
sys( in , m_dxdt.m_v ,t );
this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , dt );
}
/*
* Version 4 :do_step( sys , in , dxdt , t , out , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*
* the disable is needed to avoid ambiguous overloads if state_type = time_type
*/
template< class System , class StateIn , class DerivIn , class StateOut >
typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
}
/*
* named Version 4: do_step_dxdt_impl( sys , in , dxdt , t , out, dt )
*
* this version is needed when this stepper is used for initializing
* multistep stepper like adams-bashforth. Hence we provide an explicitely
* named version that is not disabled. Meant for internal use only.
*/
template < class System, class StateIn, class DerivIn, class StateOut >
void do_step_dxdt_impl( System system, const StateIn &in,
const DerivIn &dxdt, time_type t, StateOut &out,
time_type dt )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
}
/*
* Version 5 :do_step( sys , x , t , dt , xerr )
*
* the two overloads are needed in order to solve the forwarding problem
*/
template< class System , class StateInOut , class Err >
void do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
{
do_step_v5( system , x , t , dt , xerr );
}
/**
* \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
*/
template< class System , class StateInOut , class Err >
void do_step( System system , const StateInOut &x , time_type t , time_type dt , Err &xerr )
{
do_step_v5( system , x , t , dt , xerr );
}
/*
* Version 6 :do_step( sys , x , dxdt , t , dt , xerr )
*
* this version does not solve the forwarding problem, boost.range can not be used
*
* the disable is needed to avoid ambiguous overloads if state_type = time_type
*/
template< class System , class StateInOut , class DerivIn , class Err >
typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt , Err &xerr )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt , xerr );
}
/*
* Version 7 : do_step( sys , in , t , out , dt , xerr )
*
* this version does not solve the forwarding problem, boost.range can not be used
*/
template< class System , class StateIn , class StateOut , class Err >
void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
{
typename odeint::unwrap_reference< System >::type &sys = system;
m_resizer.adjust_size(in, [this](auto&& arg) { return this->resize_impl<StateIn>(std::forward<decltype(arg)>(arg)); });
sys( in , m_dxdt.m_v ,t );
this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , dt , xerr );
}
/*
* Version 8 : do_step( sys , in , dxdt , t , out , dt , xerr )
*
* this version does not solve the forwarding problem, boost.range can not be used
*/
template< class System , class StateIn , class DerivIn , class StateOut , class Err >
void do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt , xerr );
}
template< class StateIn >
void adjust_size( const StateIn &x )
{
resize_impl( x );
}
private:
template< class System , class StateInOut >
void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
{
typename odeint::unwrap_reference< System >::type &sys = system;
m_resizer.adjust_size(x, [this](auto&& arg) { return this->resize_impl<StateInOut>(std::forward<decltype(arg)>(arg)); });
sys( x , m_dxdt.m_v , t );
this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt );
}
template< class System , class StateInOut , class Err >
void do_step_v5( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
{
typename odeint::unwrap_reference< System >::type &sys = system;
m_resizer.adjust_size(x, [this](auto&& arg) { return this->resize_impl<StateInOut>(std::forward<decltype(arg)>(arg)); });
sys( x , m_dxdt.m_v ,t );
this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt , xerr );
}
template< class StateIn >
bool resize_impl( const StateIn &x )
{
return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
}
stepper_type& stepper( void )
{
return *static_cast< stepper_type* >( this );
}
const stepper_type& stepper( void ) const
{
return *static_cast< const stepper_type* >( this );
}
resizer_type m_resizer;
protected:
wrapped_deriv_type m_dxdt;
};
/******** DOXYGEN *******/
/**
* \class explicit_error_stepper_base
* \brief Base class for explicit steppers with error estimation. This class can used with
* controlled steppers for step size control.
*
* This class serves as the base class for all explicit steppers with algebra and operations. In contrast to
* explicit_stepper_base it also estimates the error and can be used in a controlled stepper to provide
* step size control.
*
* \note This stepper provides `do_step` methods with and without error estimation. It has therefore three orders,
* one for the order of a step if the error is not estimated. The other two orders are the orders of the step and
* the error step if the error estimation is performed.
*
* explicit_error_stepper_base is used as the interface in a CRTP (currently recurring template
* pattern). In order to work correctly the parent class needs to have a method
* `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 fulfill the Error Stepper concept. The other ones 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 fulfill 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 explicitly 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 explicitly 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 fulfill 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.
* \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 state type for the stepper.
* \tparam Value The value type for the stepper. This should be a floating point type, like float,
* double, or a multiprecision type. It must not necessary be the value_type of the State. For example
* the State can be a `vector< complex< double > >` in this case the Value must be double.
* The default value is double.
* \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
* state type, only if used with Boost.Units both types differ.
* \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
* used, this type has usually a unit.
* \tparam Algebra The algebra type which must fulfill the Algebra Concept.
* \tparam Operations The type for the operations which must fulfill the Operations Concept.
* \tparam Resizer The resizer policy class.
*/
/**
* \fn explicit_error_stepper_base::explicit_error_stepper_base( const algebra_type &algebra = algebra_type() )
*
* \brief Constructs a explicit_error_stepper_base 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.
*/
/**
* \fn explicit_error_stepper_base::order( void ) const
* \return Returns the order of the stepper if it used without error estimation.
*/
/**
* \fn explicit_error_stepper_base::stepper_order( void ) const
* \return Returns the order of a step if the stepper is used without error estimation.
*/
/**
* \fn explicit_error_stepper_base::error_order( void ) const
* \return Returns the order of an error step if the stepper is used without error estimation.
*/
/**
* \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
* \brief This method performs one step. It transforms the result in-place.
*
* \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.
* \param dt The step size.
*/
/**
* \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
* \brief The method performs one step with the stepper passed by Stepper. Additionally to the other method
* the derivative of x is also passed to this method. It is supposed to be used in the following way:
*
* \code
* sys( x , dxdt , t );
* stepper.do_step( sys , x , dxdt , t , dt );
* \endcode
*
* The result is updated in place in x. This method is disabled if Time and Deriv are of the same type. In this
* case the method could not be distinguished from other `do_step` versions.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t.
* \param t The value of the time, at which the step should be performed.
* \param dt The step size.
*/
/**
* \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
* This method is disabled if StateIn and Time are the same type. In this case the method can not be distinguished from
* other `do_step` variants.
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in 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.
*/
/**
* \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
* Furthermore, the derivative of x at t is passed to the stepper. It is supposed to be used in the following way:
*
* \code
* sys( in , dxdt , t );
* stepper.do_step( sys , in , dxdt , t , out , dt );
* \endcode
*
* This method is disabled if DerivIn and Time are of same type.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill 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.
*/
/**
* \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
* \brief The method performs one step with the stepper passed by Stepper and estimates the error. The state of the ODE
* is updated in-place.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \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 dt The step size.
* \param xerr The estimation of the error is stored in xerr.
*/
/**
* \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt , Err &xerr )
* \brief The method performs one step with the stepper passed by Stepper. Additionally to the other method
* the derivative of x is also passed to this method. It is supposed to be used in the following way:
*
* \code
* sys( x , dxdt , t );
* stepper.do_step( sys , x , dxdt , t , dt , xerr );
* \endcode
*
* The result is updated in place in x. This method is disabled if Time and DerivIn are of the same type. In this
* case the method could not be distinguished from other `do_step` versions.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t.
* \param t The value of the time, at which the step should be performed.
* \param dt The step size.
* \param xerr The error estimate is stored in xerr.
*/
/**
* \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
* Furthermore, the error is estimated.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in 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 error estimate.
*/
/**
* \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
* Furthermore, the derivative of x at t is passed to the stepper and the error is estimated. It is supposed to be used in the following way:
*
* \code
* sys( in , dxdt , t );
* stepper.do_step( sys , in , dxdt , t , out , dt );
* \endcode
*
* This method is disabled if DerivIn and Time are of same type.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill 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 error estimate.
*/
/**
* \fn explicit_error_stepper_base::adjust_size( const StateIn &x )
* \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.
*/
} // odeint
} // numeric
} // boost
#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED

677
include/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp Normal file
View File

@@ -0,0 +1,677 @@
/*
[auto_generated]
boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp
[begin_description]
Base class for all explicit first-same-as-last Runge Kutta steppers.
[end_description]
Copyright 2010-2013 Karsten Ahnert
Copyright 2010-2012 Mario Mulansky
Copyright 2012 Christoph Koke
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or
copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_FSAL_BASE_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_FSAL_BASE_HPP_INCLUDED
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/numeric/odeint/util/bind.hpp>
#include <boost/numeric/odeint/util/unwrap_reference.hpp>
#include <boost/numeric/odeint/util/state_wrapper.hpp>
#include <boost/numeric/odeint/util/is_resizeable.hpp>
#include <boost/numeric/odeint/util/resizer.hpp>
#include <boost/numeric/odeint/util/copy.hpp>
#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
namespace boost {
namespace numeric {
namespace odeint {
/*
* base class for explicit stepper and error steppers with the fsal property
* models the stepper AND the error stepper fsal concept
*
* this class provides the following do_step overloads
* do_step( sys , x , t , dt )
* do_step( sys , x , dxdt , t , dt )
* do_step( sys , in , t , out , dt )
* do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )
* do_step( sys , x , t , dt , xerr )
* do_step( sys , x , dxdt , t , dt , xerr )
* do_step( sys , in , t , out , dt , xerr )
* do_step( sys , in , dxdt_in , t , out , dxdt_out , dt , xerr )
*/
template<
class Stepper ,
unsigned short Order ,
unsigned short StepperOrder ,
unsigned short ErrorOrder ,
class State ,
class Value ,
class Deriv ,
class Time ,
class Algebra ,
class Operations ,
class Resizer
>
class explicit_error_stepper_fsal_base : public algebra_stepper_base< Algebra , Operations >
{
public:
typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
typedef typename algebra_stepper_base_type::algebra_type algebra_type;
typedef State state_type;
typedef Value value_type;
typedef Deriv deriv_type;
typedef Time time_type;
typedef Resizer resizer_type;
typedef Stepper stepper_type;
typedef explicit_error_stepper_fsal_tag stepper_category;
#ifndef DOXYGEN_SKIP
typedef state_wrapper< state_type > wrapped_state_type;
typedef state_wrapper< deriv_type > wrapped_deriv_type;
typedef explicit_error_stepper_fsal_base< Stepper , Order , StepperOrder , ErrorOrder ,
State , Value , Deriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
#endif
typedef unsigned short order_type;
static const order_type order_value = Order;
static const order_type stepper_order_value = StepperOrder;
static const order_type error_order_value = ErrorOrder;
explicit_error_stepper_fsal_base( const algebra_type &algebra = algebra_type() )
: algebra_stepper_base_type( algebra ) , m_first_call( true )
{ }
order_type order( void ) const
{
return order_value;
}
order_type stepper_order( void ) const
{
return stepper_order_value;
}
order_type error_order( void ) const
{
return error_order_value;
}
/*
* version 1 : do_step( sys , x , t , dt )
*
* the two overloads are needed in order to solve the forwarding problem
*/
template< class System , class StateInOut >
void do_step( System system , StateInOut &x , time_type t , time_type dt )
{
do_step_v1( system , x , t , dt );
}
/**
* \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
*/
template< class System , class StateInOut >
void do_step( System system , const StateInOut &x , time_type t , time_type dt )
{
do_step_v1( system , x , t , dt );
}
/*
* version 2 : do_step( sys , x , dxdt , t , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*
* the disable is needed to avoid ambiguous overloads if state_type = time_type
*/
template< class System , class StateInOut , class DerivInOut >
typename boost::disable_if< boost::is_same< StateInOut , time_type > , void >::type
do_step( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt )
{
m_first_call = true;
this->stepper().do_step_impl( system , x , dxdt , t , x , dxdt , dt );
}
/*
* named Version 2: do_step_dxdt_impl( sys , in , dxdt , t , dt )
*
* this version is needed when this stepper is used for initializing
* multistep stepper like adams-bashforth. Hence we provide an explicitely
* named version that is not disabled. Meant for internal use only.
*/
template< class System , class StateInOut , class DerivInOut >
void do_step_dxdt_impl( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt )
{
m_first_call = true;
this->stepper().do_step_impl( system , x , dxdt , t , x , dxdt , dt );
}
/*
* version 3 : do_step( sys , in , t , out , dt )
*
* this version does not solve the forwarding problem, boost.range can not
* be used.
*
* the disable is needed to avoid ambiguous overloads if
* state_type = time_type
*/
template< class System , class StateIn , class StateOut >
typename boost::disable_if< boost::is_same< StateIn , time_type > , void >::type
do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
{
if( m_resizer.adjust_size(in, [this](auto&& arg) { return this->resize_impl<StateIn>(std::forward<decltype(arg)>(arg)); }) || m_first_call )
{
initialize( system , in , t );
}
this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , m_dxdt.m_v , dt );
}
/*
* version 4 : do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*/
template< class System, class StateIn, class DerivIn, class StateOut,
class DerivOut >
void do_step( System system, const StateIn &in, const DerivIn &dxdt_in,
time_type t, StateOut &out, DerivOut &dxdt_out, time_type dt )
{
m_first_call = true;
this->stepper().do_step_impl( system, in, dxdt_in, t, out, dxdt_out,
dt );
}
/*
* version 5 : do_step( sys , x , t , dt , xerr )
*
* the two overloads are needed in order to solve the forwarding problem
*/
template< class System , class StateInOut , class Err >
void do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
{
do_step_v5( system , x , t , dt , xerr );
}
/**
* \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
*/
template< class System , class StateInOut , class Err >
void do_step( System system , const StateInOut &x , time_type t , time_type dt , Err &xerr )
{
do_step_v5( system , x , t , dt , xerr );
}
/*
* version 6 : do_step( sys , x , dxdt , t , dt , xerr )
*
* this version does not solve the forwarding problem, boost.range can not be used
*
* the disable is needed to avoid ambiguous overloads if state_type = time_type
*/
template< class System , class StateInOut , class DerivInOut , class Err >
typename boost::disable_if< boost::is_same< StateInOut , time_type > , void >::type
do_step( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt , Err &xerr )
{
m_first_call = true;
this->stepper().do_step_impl( system , x , dxdt , t , x , dxdt , dt , xerr );
}
/*
* version 7 : do_step( sys , in , t , out , dt , xerr )
*
* this version does not solve the forwarding problem, boost.range can not be used
*/
template< class System , class StateIn , class StateOut , class Err >
void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
{
if( m_resizer.adjust_size(in, [this](auto&& arg) { return this->resize_impl<StateIn>(std::forward<decltype(arg)>(arg)); }) || m_first_call )
{
initialize( system , in , t );
}
this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , m_dxdt.m_v , dt , xerr );
}
/*
* version 8 : do_step( sys , in , dxdt_in , t , out , dxdt_out , dt , xerr )
*
* this version does not solve the forwarding problem, boost.range can not be used
*/
template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut , class Err >
void do_step( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t ,
StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr )
{
m_first_call = true;
this->stepper().do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt , xerr );
}
template< class StateIn >
void adjust_size( const StateIn &x )
{
resize_impl( x );
}
void reset( void )
{
m_first_call = true;
}
template< class DerivIn >
void initialize( const DerivIn &deriv )
{
boost::numeric::odeint::copy( deriv , m_dxdt.m_v );
m_first_call = false;
}
template< class System , class StateIn >
void initialize( System system , const StateIn &x , time_type t )
{
typename odeint::unwrap_reference< System >::type &sys = system;
sys( x , m_dxdt.m_v , t );
m_first_call = false;
}
bool is_initialized( void ) const
{
return ! m_first_call;
}
private:
template< class System , class StateInOut >
void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
{
if( m_resizer.adjust_size(x, [this](auto&& arg) { return this->resize_impl<StateInOut>(std::forward<decltype(arg)>(arg)); }) || m_first_call )
{
initialize( system , x , t );
}
this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , m_dxdt.m_v , dt );
}
template< class System , class StateInOut , class Err >
void do_step_v5( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
{
if( m_resizer.adjust_size(x, [this](auto&& arg) { return this->resize_impl<StateInOut>(std::forward<decltype(arg)>(arg)); }) || m_first_call )
{
initialize( system , x , t );
}
this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , m_dxdt.m_v , dt , xerr );
}
template< class StateIn >
bool resize_impl( const StateIn &x )
{
return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
}
stepper_type& stepper( void )
{
return *static_cast< stepper_type* >( this );
}
const stepper_type& stepper( void ) const
{
return *static_cast< const stepper_type* >( this );
}
resizer_type m_resizer;
bool m_first_call;
protected:
wrapped_deriv_type m_dxdt;
};
/******* DOXYGEN *******/
/**
* \class explicit_error_stepper_fsal_base
* \brief Base class for explicit steppers with error estimation and stepper fulfilling the FSAL (first-same-as-last)
* property. This class can be used with controlled steppers for step size control.
*
* This class serves as the base class for all explicit steppers with algebra and operations and which fulfill the FSAL
* property. In contrast to explicit_stepper_base it also estimates the error and can be used in a controlled stepper
* to provide step size control.
*
* The FSAL property means that the derivative of the system at t+dt is already used in the current step going from
* t to t +dt. Therefore, some more do_steps method can be introduced and the controlled steppers can explicitly make use
* of this property.
*
* \note This stepper provides `do_step` methods with and without error estimation. It has therefore three orders,
* one for the order of a step if the error is not estimated. The other two orders are the orders of the step and
* the error step if the error estimation is performed.
*
* explicit_error_stepper_fsal_base is used as the interface in a CRTP (currently recurring template
* pattern). In order to work correctly the parent class needs to have a method
* `do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt , xerr )`.
* explicit_error_stepper_fsal_base derives from algebra_stepper_base.
*
* This class can have an intrinsic state depending on the explicit usage of the `do_step` method. This means that some
* `do_step` methods are expected to be called in order. For example the `do_step( sys , x , t , dt , xerr )` will keep track
* of the derivative of `x` which is the internal state. The first call of this method is recognized such that one
* does not explicitly initialize the internal state, so it is safe to use this method like
*
* \code
* stepper_type stepper;
* stepper.do_step( sys , x , t , dt , xerr );
* stepper.do_step( sys , x , t , dt , xerr );
* stepper.do_step( sys , x , t , dt , xerr );
* \endcode
*
* But it is unsafe to call this method with different system functions after each other. Do do so, one must initialize the
* internal state with the `initialize` method or reset the internal state with the `reset` method.
*
* explicit_error_stepper_fsal_base provides several overloaded `do_step` methods, see the list below. Only two of them are needed
* to fulfill the Error Stepper concept. The other ones are for convenience and for better 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 fulfill 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 x and the derivative dxdt in-place. It is expected
* that dxdt has the value of the derivative of x at time t.
* - `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_in , t , out , dxdt_out , dt )` - This method updates the state and the derivative
* out-of-place. It expects that the derivative at the point `t` is explicitly passed in `dxdt_in`.
* - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fulfill 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 and the derivative in-place. It is assumed
* that the dxdt has the value of the derivative of x at time t. 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_in , t , out , dxdt_out , dt , xerr )` - This methods updates the state and the derivative
* out-of-place and estimates the error during the step. It is assumed the dxdt_in is derivative of in at time t.
*
* \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.
* \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 state type for the stepper.
* \tparam Value The value type for the stepper. This should be a floating point type, like float,
* double, or a multiprecision type. It must not necessary be the value_type of the State. For example
* the State can be a `vector< complex< double > >` in this case the Value must be double.
* The default value is double.
* \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
* state type, only if used with Boost.Units both types differ.
* \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
* used, this type has usually a unit.
* \tparam Algebra The algebra type which must fulfill the Algebra Concept.
* \tparam Operations The type for the operations which must fulfill the Operations Concept.
* \tparam Resizer The resizer policy class.
*/
/**
* \fn explicit_error_stepper_fsal_base::explicit_error_stepper_fsal_base( const algebra_type &algebra )
* \brief Constructs a explicit_stepper_fsal_base 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.
*/
/**
* \fn explicit_error_stepper_fsal_base::order( void ) const
* \return Returns the order of the stepper if it used without error estimation.
*/
/**
* \fn explicit_error_stepper_fsal_base::stepper_order( void ) const
* \return Returns the order of a step if the stepper is used without error estimation.
*/
/**
* \fn explicit_error_stepper_fsal_base::error_order( void ) const
* \return Returns the order of an error step if the stepper is used without error estimation.
*/
/**
* \fn explicit_error_stepper_fsal_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
* \brief This method performs one step. It transforms the result in-place.
*
* \note This method uses the internal state of the stepper.
*
* \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.
* \param dt The step size.
*/
/**
* \fn explicit_error_stepper_fsal_base::do_step( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt )
* \brief The method performs one step with the stepper passed by Stepper. Additionally to the other methods
* the derivative of x is also passed to this method. Therefore, dxdt must be evaluated initially:
*
* \code
* ode( x , dxdt , t );
* for( ... )
* {
* stepper.do_step( ode , x , dxdt , t , dt );
* t += dt;
* }
* \endcode
*
* \note This method does NOT use the initial state, since the first derivative is explicitly passed to this method.
*
* The result is updated in place in x as well as the derivative dxdt. This method is disabled if
* Time and StateInOut are of the same type. In this case the method could not be distinguished from other `do_step`
* versions.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t. After calling `do_step` dxdt is updated to the new value.
* \param t The value of the time, at which the step should be performed.
* \param dt The step size.
*/
/**
* \fn explicit_error_stepper_fsal_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
* This method is disabled if StateIn and Time are the same type. In this case the method can not be distinguished from
* other `do_step` variants.
*
* \note This method uses the internal state of the stepper.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in 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.
*/
/**
* \fn explicit_error_stepper_fsal_base::do_step( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
* Furthermore, the derivative of x at t is passed to the stepper and updated by the stepper to its new value at
* t+dt.
*
* \note This method does not solve the forwarding problem.
*
* \note This method does NOT use the internal state of the stepper.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt_in 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 dxdt_out The updated derivative of `out` at `t+dt`.
* \param dt The step size.
*/
/**
* \fn explicit_error_stepper_fsal_base::do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
* \brief The method performs one step with the stepper passed by Stepper and estimates the error. The state of the ODE
* is updated in-place.
*
*
* \note This method uses the internal state of the stepper.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \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 dt The step size.
* \param xerr The estimation of the error is stored in xerr.
*/
/**
* \fn explicit_error_stepper_fsal_base::do_step( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt , Err &xerr )
* \brief The method performs one step with the stepper passed by Stepper. Additionally to the other method
* the derivative of x is also passed to this method and updated by this method.
*
* \note This method does NOT use the internal state of the stepper.
*
* The result is updated in place in x. This method is disabled if Time and Deriv are of the same type. In this
* case the method could not be distinguished from other `do_step` versions. This method is disabled if StateInOut and
* Time are of the same type.
*
* \note This method does NOT use the internal state of the stepper.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t. After calling `do_step` this value is updated to the new value at `t+dt`.
* \param t The value of the time, at which the step should be performed.
* \param dt The step size.
* \param xerr The error estimate is stored in xerr.
*/
/**
* \fn explicit_error_stepper_fsal_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
* Furthermore, the error is estimated.
*
* \note This method uses the internal state of the stepper.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in 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 error estimate.
*/
/**
* \fn explicit_error_stepper_fsal_base::do_step( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
* Furthermore, the derivative of x at t is passed to the stepper and the error is estimated.
*
* \note This method does NOT use the internal state of the stepper.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt_in 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 dxdt_out The new derivative at `t+dt` is written into this variable.
* \param dt The step size.
* \param xerr The error estimate.
*/
/**
* \fn explicit_error_stepper_fsal_base::adjust_size( const StateIn &x )
* \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.
*/
/**
* \fn explicit_error_stepper_fsal_base::reset( void )
* \brief Resets the internal state of this stepper. After calling this method it is safe to use all
* `do_step` method without explicitly initializing the stepper.
*/
/**
* \fn explicit_error_stepper_fsal_base::initialize( const DerivIn &deriv )
* \brief Initializes the internal state of the stepper.
* \param deriv The derivative of x. The next call of `do_step` expects that the derivative of `x` passed to `do_step`
* has the value of `deriv`.
*/
/**
* \fn explicit_error_stepper_fsal_base::initialize( System system , const StateIn &x , time_type t )
* \brief Initializes the internal state of the stepper.
*
* This method is equivalent to
* \code
* Deriv dxdt;
* system( x , dxdt , t );
* stepper.initialize( dxdt );
* \endcode
*
* \param system The system function for the next calls of `do_step`.
* \param x The current state of the ODE.
* \param t The current time of the ODE.
*/
/**
* \fn explicit_error_stepper_fsal_base::is_initialized( void ) const
* \brief Returns if the stepper is already initialized. If the stepper is not initialized, the first
* call of `do_step` will initialize the state of the stepper. If the stepper is already initialized
* the system function can not be safely exchanged between consecutive `do_step` calls.
*/
} // odeint
} // numeric
} // boost
#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_FSAL_BASE_HPP_INCLUDED

415
include/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp Normal file
View File

@@ -0,0 +1,415 @@
/*
[auto_generated]
boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
[begin_description]
Base class for all explicit Runge Kutta steppers.
[end_description]
Copyright 2010-2013 Karsten Ahnert
Copyright 2010-2012 Mario Mulansky
Copyright 2012 Christoph Koke
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or
copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_STEPPER_BASE_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_STEPPER_BASE_HPP_INCLUDED
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/numeric/odeint/util/bind.hpp>
#include <boost/numeric/odeint/util/unwrap_reference.hpp>
#include <boost/numeric/odeint/util/state_wrapper.hpp>
#include <boost/numeric/odeint/util/resizer.hpp>
#include <boost/numeric/odeint/util/is_resizeable.hpp>
#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
namespace boost {
namespace numeric {
namespace odeint {
/*
* base class for explicit steppers
* models the stepper concept
*
* this class provides the following overloads
* do_step( sys , x , t , dt )
* do_step( sys , in , t , out , dt )
* do_step( sys , x , dxdt_in , t , dt )
* do_step( sys , in , dxdt_in , t , out , dt )
*/
template<
class Stepper ,
unsigned short Order ,
class State ,
class Value ,
class Deriv ,
class Time ,
class Algebra ,
class Operations ,
class Resizer
>
class explicit_stepper_base : public algebra_stepper_base< Algebra , Operations >
{
public:
#ifndef DOXYGEN_SKIP
typedef explicit_stepper_base< Stepper , Order , State , Value , Deriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
#endif // DOXYGEN_SKIP
typedef State state_type;
typedef Value value_type;
typedef Deriv deriv_type;
typedef Time time_type;
typedef Resizer resizer_type;
typedef Stepper stepper_type;
typedef stepper_tag stepper_category;
typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
typedef typename algebra_stepper_base_type::algebra_type algebra_type;
typedef typename algebra_stepper_base_type::operations_type operations_type;
typedef unsigned short order_type;
#ifndef DOXYGEN_SKIP
typedef state_wrapper< state_type > wrapped_state_type;
typedef state_wrapper< deriv_type > wrapped_deriv_type;
#endif // DOXYGEN_SKIP
static const order_type order_value = Order;
explicit_stepper_base( const algebra_type &algebra = algebra_type() )
: algebra_stepper_base_type( algebra )
{ }
/**
* \return Returns the order of the stepper.
*/
order_type order( void ) const
{
return order_value;
}
/*
* Version 1 : do_step( sys , x , t , dt )
*
* the two overloads are needed in order to solve the forwarding problem
*/
template< class System , class StateInOut >
void do_step( System system , StateInOut &x , time_type t , time_type dt )
{
do_step_v1( system , x , t , dt );
}
/**
* \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
*/
template< class System , class StateInOut >
void do_step( System system , const StateInOut &x , time_type t , time_type dt )
{
do_step_v1( system , x , t , dt );
}
/*
* Version 2 : do_step( sys , x , dxdt , t , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*
* the disable is needed to avoid ambiguous overloads if state_type = time_type
*/
template< class System , class StateInOut , class DerivIn >
typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
}
/*
* named Version 2: do_step_dxdt_impl( sys , in , dxdt , t , dt )
*
* this version is needed when this stepper is used for initializing
* multistep stepper like adams-bashforth. Hence we provide an explicitely
* named version that is not disabled. Meant for internal use only.
*/
template < class System, class StateInOut, class DerivIn >
void do_step_dxdt_impl( System system, StateInOut &x, const DerivIn &dxdt,
time_type t, time_type dt )
{
this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
}
/*
* Version 3 : do_step( sys , in , t , out , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*/
template< class System , class StateIn , class StateOut >
void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
{
typename odeint::unwrap_reference< System >::type &sys = system;
m_resizer.adjust_size(in, [this](auto&& arg) { return this->resize_impl<StateIn>(std::forward<decltype(arg)>(arg)); });
sys( in , m_dxdt.m_v ,t );
this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , dt );
}
/*
* Version 4 : do_step( sys , in , dxdt , t , out , dt )
*
* this version does not solve the forwarding problem, boost.range can not be used
*/
template< class System , class StateIn , class DerivIn , class StateOut >
void do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
}
/*
* named Version 4: do_step_dxdt_impl( sys , in , dxdt , t , out, dt )
*
* this version is needed when this stepper is used for initializing
* multistep stepper like adams-bashforth. Hence we provide an explicitely
* named version. Meant for internal use only.
*/
template < class System, class StateIn, class DerivIn, class StateOut >
void do_step_dxdt_impl( System system, const StateIn &in,
const DerivIn &dxdt, time_type t, StateOut &out,
time_type dt )
{
this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
}
template< class StateIn >
void adjust_size( const StateIn &x )
{
resize_impl( x );
}
private:
stepper_type& stepper( void )
{
return *static_cast< stepper_type* >( this );
}
const stepper_type& stepper( void ) const
{
return *static_cast< const stepper_type* >( this );
}
template< class StateIn >
bool resize_impl( const StateIn &x )
{
return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
}
template< class System , class StateInOut >
void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
{
typename odeint::unwrap_reference< System >::type &sys = system;
m_resizer.adjust_size(x, [this](auto&& arg) { return this->resize_impl<StateInOut>(std::forward<decltype(arg)>(arg)); });
sys( x , m_dxdt.m_v ,t );
this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt );
}
resizer_type m_resizer;
protected:
wrapped_deriv_type m_dxdt;
};
/******* DOXYGEN *********/
/**
* \class explicit_stepper_base
* \brief Base class for explicit steppers without step size control and without dense output.
*
* This class serves as the base class for all explicit steppers with algebra and operations.
* Step size control and error estimation as well as dense output are not provided. explicit_stepper_base
* is used as the interface in a CRTP (currently recurring template pattern). In order to work
* correctly the parent class needs to have a method `do_step_impl( system , in , dxdt_in , t , out , dt )`.
* This is method is used by explicit_stepper_base. explicit_stepper_base derives from
* algebra_stepper_base. An example how this class can be used is
*
* \code
* template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resizer >
* class custom_euler : public explicit_stepper_base< 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
* {
* public:
*
* typedef explicit_stepper_base< 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer > base_type;
*
* custom_euler( const Algebra &algebra = Algebra() ) { }
*
* template< class Sys , class StateIn , class DerivIn , class StateOut >
* void do_step_impl( Sys sys , const StateIn &in , const DerivIn &dxdt , Time t , StateOut &out , Time dt )
* {
* m_algebra.for_each3( out , in , dxdt , Operations::scale_sum2< Value , Time >( 1.0 , dt );
* }
*
* template< class State >
* void adjust_size( const State &x )
* {
* base_type::adjust_size( x );
* }
* };
* \endcode
*
* For the Stepper concept only the `do_step( sys , x , t , dt )` needs to be implemented. But this class
* provides additional `do_step` variants since the stepper is explicit. These methods can be used to increase
* the performance in some situation, for example if one needs to analyze `dxdt` during each step. In this case
* one can use
*
* \code
* sys( x , dxdt , t );
* 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 )` - The classical `do_step` method needed to fulfill 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
* explicitly 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 explicitly 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.
* \tparam Order The order of the stepper.
* \tparam State The state type for the stepper.
* \tparam Value The value type for the stepper. This should be a floating point type, like float,
* double, or a multiprecision type. It must not necessary be the value_type of the State. For example
* the State can be a `vector< complex< double > >` in this case the Value must be double.
* The default value is double.
* \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
* state type, only if used with Boost.Units both types differ.
* \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
* used, this type has usually a unit.
* \tparam Algebra The algebra type which must fulfill the Algebra Concept.
* \tparam Operations The type for the operations which must fulfill the Operations Concept.
* \tparam Resizer The resizer policy class.
*/
/**
* \fn explicit_stepper_base::explicit_stepper_base( const algebra_type &algebra )
* \brief Constructs a explicit_stepper_base 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.
*/
/**
* \fn explicit_stepper_base::order_type order( void ) const
* \return Returns the order of the stepper.
*/
/**
* \fn explicit_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
* \brief This method performs one step. It transforms the result in-place.
*
* \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.
* \param dt The step size.
*/
/**
* \fn explicit_stepper_base::do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
* \brief The method performs one step. Additionally to the other method
* the derivative of x is also passed to this method. It is supposed to be used in the following way:
*
* \code
* sys( x , dxdt , t );
* stepper.do_step( sys , x , dxdt , t , dt );
* \endcode
*
* The result is updated in place in x. This method is disabled if Time and Deriv are of the same type. In this
* case the method could not be distinguished from other `do_step` versions.
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t.
* \param t The value of the time, at which the step should be performed.
* \param dt The step size.
*/
/**
* \fn void explicit_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
* \brief The method performs one step. The state of the ODE is updated out-of-place.
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in 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.
*/
/**
* \fn void explicit_stepper_base::do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
* \brief The method performs one step. The state of the ODE is updated out-of-place.
* Furthermore, the derivative of x at t is passed to the stepper.
* It is supposed to be used in the following way:
*
* \code
* sys( in , dxdt , t );
* stepper.do_step( sys , in , dxdt , t , out , dt );
* \endcode
*
* \note This method does not solve the forwarding problem.
*
* \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill 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.
*/
/**
* \fn void explicit_stepper_base::adjust_size( const StateIn &x )
* \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.
*/
} // odeint
} // numeric
} // boost
#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_STEPPER_BASE_HPP_INCLUDED

431
include/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp Normal file
View File

@@ -0,0 +1,431 @@
/*
[auto_generated]
boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp
[begin_description]
Base class for symplectic Runge-Kutta-Nystrom steppers.
[end_description]
Copyright 2011-2013 Karsten Ahnert
Copyright 2011-2013 Mario Mulansky
Copyright 2012 Christoph Koke
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or
copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_SYMPLECTIC_RKN_STEPPER_BASE_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_SYMPLECTIC_RKN_STEPPER_BASE_HPP_INCLUDED
#include <array>
#include <type_traits>
#include <boost/numeric/odeint/util/bind.hpp>
#include <boost/numeric/odeint/util/unwrap_reference.hpp>
#include <boost/numeric/odeint/util/copy.hpp>
#include <boost/numeric/odeint/util/is_pair.hpp>
#include <boost/numeric/odeint/util/state_wrapper.hpp>
#include <boost/numeric/odeint/util/resizer.hpp>
#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
namespace boost {
namespace numeric {
namespace odeint {
template<
size_t NumOfStages ,
unsigned short Order ,
class Coor ,
class Momentum ,
class Value ,
class CoorDeriv ,
class MomentumDeriv ,
class Time ,
class Algebra ,
class Operations ,
class Resizer
>
class symplectic_nystroem_stepper_base : public algebra_stepper_base< Algebra , Operations >
{
public:
typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
typedef typename algebra_stepper_base_type::algebra_type algebra_type;
typedef typename algebra_stepper_base_type::operations_type operations_type;
const static size_t num_of_stages = NumOfStages;
typedef Coor coor_type;
typedef Momentum momentum_type;
typedef std::pair< coor_type , momentum_type > state_type;
typedef CoorDeriv coor_deriv_type;
typedef state_wrapper< coor_deriv_type> wrapped_coor_deriv_type;
typedef MomentumDeriv momentum_deriv_type;
typedef state_wrapper< momentum_deriv_type > wrapped_momentum_deriv_type;
typedef std::pair< coor_deriv_type , momentum_deriv_type > deriv_type;
typedef Value value_type;
typedef Time time_type;
typedef Resizer resizer_type;
typedef stepper_tag stepper_category;
#ifndef DOXYGEN_SKIP
typedef symplectic_nystroem_stepper_base< NumOfStages , Order , Coor , Momentum , Value ,
CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
#endif
typedef unsigned short order_type;
static const order_type order_value = Order;
typedef std::array< value_type , num_of_stages > coef_type;
symplectic_nystroem_stepper_base( const coef_type &coef_a , const coef_type &coef_b , const algebra_type &algebra = algebra_type() )
: algebra_stepper_base_type( algebra ) , m_coef_a( coef_a ) , m_coef_b( coef_b ) ,
m_dqdt_resizer() , m_dpdt_resizer() , m_dqdt() , m_dpdt()
{ }
order_type order( void ) const
{
return order_value;
}
/*
* Version 1 : do_step( system , x , t , dt )
*
* This version does not solve the forwarding problem, boost.range can not be used.
*/
template< class System , class StateInOut >
void do_step( System system , const StateInOut &state , time_type t , time_type dt )
{
typedef typename odeint::unwrap_reference< System >::type system_type;
do_step_impl( system , state , t , state , dt , typename is_pair< system_type >::type() );
}
/**
* \brief 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.
*/
template< class System , class StateInOut >
void do_step( System system , StateInOut &state , time_type t , time_type dt )
{
typedef typename odeint::unwrap_reference< System >::type system_type;
do_step_impl( system , state , t , state , dt , typename is_pair< system_type >::type() );
}
/*
* Version 2 : do_step( system , q , p , t , dt );
*
* For Convenience
*
* The two overloads are needed in order to solve the forwarding problem.
*/
template< class System , class CoorInOut , class MomentumInOut >
void do_step( System system , CoorInOut &q , MomentumInOut &p , time_type t , time_type dt )
{
do_step( system , std::make_pair( std::ref( q ) , std::ref( p ) ) , t , dt );
}
/**
* \brief 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.
*/
template< class System , class CoorInOut , class MomentumInOut >
void do_step( System system , const CoorInOut &q , const MomentumInOut &p , time_type t , time_type dt )
{
do_step( system , std::make_pair( std::ref( q ) , std::ref( p ) ) , t , dt );
}
/*
* Version 3 : do_step( system , in , t , out , dt )
*
* The forwarding problem is not solved in this version
*/
template< class System , class StateIn , class StateOut >
void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
{
typedef typename odeint::unwrap_reference< System >::type system_type;
do_step_impl( system , in , t , out , dt , typename is_pair< system_type >::type() );
}
template< class StateType >
void adjust_size( const StateType &x )
{
resize_dqdt( x );
resize_dpdt( x );
}
/** \brief Returns the coefficients a. */
const coef_type& coef_a( void ) const { return m_coef_a; }
/** \brief Returns the coefficients b. */
const coef_type& coef_b( void ) const { return m_coef_b; }
private:
// stepper for systems with function for dq/dt = f(p) and dp/dt = -f(q)
template< class System , class StateIn , class StateOut >
void do_step_impl( System system , const StateIn &in , time_type /* t */ , StateOut &out , time_type dt , std::integral_constant<bool, true> )
{
typedef typename odeint::unwrap_reference< System >::type system_type;
typedef typename odeint::unwrap_reference< typename system_type::first_type >::type coor_deriv_func_type;
typedef typename odeint::unwrap_reference< typename system_type::second_type >::type momentum_deriv_func_type;
system_type &sys = system;
coor_deriv_func_type &coor_func = sys.first;
momentum_deriv_func_type &momentum_func = sys.second;
typedef typename odeint::unwrap_reference< StateIn >::type state_in_type;
typedef typename odeint::unwrap_reference< typename state_in_type::first_type >::type coor_in_type;
typedef typename odeint::unwrap_reference< typename state_in_type::second_type >::type momentum_in_type;
const state_in_type &state_in = in;
const coor_in_type &coor_in = state_in.first;
const momentum_in_type &momentum_in = state_in.second;
typedef typename odeint::unwrap_reference< StateOut >::type state_out_type;
typedef typename odeint::unwrap_reference< typename state_out_type::first_type >::type coor_out_type;
typedef typename odeint::unwrap_reference< typename state_out_type::second_type >::type momentum_out_type;
state_out_type &state_out = out;
coor_out_type &coor_out = state_out.first;
momentum_out_type &momentum_out = state_out.second;
m_dqdt_resizer.adjust_size(coor_in, [this](auto&& arg) { return this->resize_dqdt<coor_in_type>(std::forward<decltype(arg)>(arg)); });
m_dpdt_resizer.adjust_size(momentum_in, [this](auto&& arg) { return this->resize_dpdt<momentum_in_type>(std::forward<decltype(arg)>(arg)); });
// ToDo: check sizes?
for( size_t l=0 ; l<num_of_stages ; ++l )
{
if( l == 0 )
{
coor_func( momentum_in , m_dqdt.m_v );
this->m_algebra.for_each3( coor_out , coor_in , m_dqdt.m_v ,
typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_a[l] * dt ) );
momentum_func( coor_out , m_dpdt.m_v );
this->m_algebra.for_each3( momentum_out , momentum_in , m_dpdt.m_v ,
typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_b[l] * dt ) );
}
else
{
coor_func( momentum_out , m_dqdt.m_v );
this->m_algebra.for_each3( coor_out , coor_out , m_dqdt.m_v ,
typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_a[l] * dt ) );
momentum_func( coor_out , m_dpdt.m_v );
this->m_algebra.for_each3( momentum_out , momentum_out , m_dpdt.m_v ,
typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_b[l] * dt ) );
}
}
}
// stepper for systems with only function dp /dt = -f(q), dq/dt = p, time not required but still expected for compatibility reasons
template< class System , class StateIn , class StateOut >
void do_step_impl( System system , const StateIn &in , time_type /* t */ , StateOut &out , time_type dt , std::integral_constant<bool, false> )
{
typedef typename odeint::unwrap_reference< System >::type momentum_deriv_func_type;
momentum_deriv_func_type &momentum_func = system;
typedef typename odeint::unwrap_reference< StateIn >::type state_in_type;
typedef typename odeint::unwrap_reference< typename state_in_type::first_type >::type coor_in_type;
typedef typename odeint::unwrap_reference< typename state_in_type::second_type >::type momentum_in_type;
const state_in_type &state_in = in;
const coor_in_type &coor_in = state_in.first;
const momentum_in_type &momentum_in = state_in.second;
typedef typename odeint::unwrap_reference< StateOut >::type state_out_type;
typedef typename odeint::unwrap_reference< typename state_out_type::first_type >::type coor_out_type;
typedef typename odeint::unwrap_reference< typename state_out_type::second_type >::type momentum_out_type;
state_out_type &state_out = out;
coor_out_type &coor_out = state_out.first;
momentum_out_type &momentum_out = state_out.second;
// m_dqdt not required when called with momentum_func only - don't resize
m_dpdt_resizer.adjust_size(momentum_in, [this](auto&& arg) { return this->resize_dpdt<momentum_in_type>(std::forward<decltype(arg)>(arg)); });
// ToDo: check sizes?
// step 0
this->m_algebra.for_each3( coor_out , coor_in , momentum_in ,
typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_a[0] * dt ) );
momentum_func( coor_out , m_dpdt.m_v );
this->m_algebra.for_each3( momentum_out , momentum_in , m_dpdt.m_v ,
typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_b[0] * dt ) );
for( size_t l=1 ; l<num_of_stages ; ++l )
{
this->m_algebra.for_each3( coor_out , coor_out , momentum_out ,
typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_a[l] * dt ) );
momentum_func( coor_out , m_dpdt.m_v );
this->m_algebra.for_each3( momentum_out , momentum_out , m_dpdt.m_v ,
typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_b[l] * dt ) );
}
}
template< class StateIn >
bool resize_dqdt( const StateIn &x )
{
return adjust_size_by_resizeability( m_dqdt , x , typename is_resizeable<coor_deriv_type>::type() );
}
template< class StateIn >
bool resize_dpdt( const StateIn &x )
{
return adjust_size_by_resizeability( m_dpdt , x , typename is_resizeable<momentum_deriv_type>::type() );
}
const coef_type m_coef_a;
const coef_type m_coef_b;
resizer_type m_dqdt_resizer;
resizer_type m_dpdt_resizer;
wrapped_coor_deriv_type m_dqdt;
wrapped_momentum_deriv_type m_dpdt;
};
/********* DOXYGEN *********/
/**
* \class symplectic_nystroem_stepper_base
* \brief Base class for all symplectic steppers of Nystroem type.
*
* This class is the base class for the symplectic Runge-Kutta-Nystroem steppers. Symplectic steppers are usually
* used to solve Hamiltonian systems and they conserve the phase space volume, see
* <a href="http://en.wikipedia.org/wiki/Symplectic_integrator">en.wikipedia.org/wiki/Symplectic_integrator</a>.
* Furthermore, the energy is conserved
* in average. In detail this class of steppers can be used to solve separable Hamiltonian systems which can be written
* in the form H(q,p) = H1(p) + H2(q). q is usually called the coordinate, while p is the momentum. The equations of motion
* are dq/dt = dH1/dp, dp/dt = -dH2/dq.
*
* ToDo : add formula for solver and explanation of the coefficients
*
* symplectic_nystroem_stepper_base uses odeints algebra and operation system. Step size and error estimation are not
* provided for this class of solvers. It derives from algebra_stepper_base. Several `do_step` variants are provided:
*
* - `do_step( sys , x , t , dt )` - The classical `do_step` method. The sys can be either a pair of function objects
* for the coordinate or the momentum part or one function object for the momentum part. `x` is a pair of coordinate
* and momentum. The state is updated in-place.
* - `do_step( sys , q , p , t , dt )` - This method is similar to the method above with the difference that the coordinate
* and the momentum are passed explicitly and not packed into a pair.
* - `do_step( sys , x_in , t , x_out , dt )` - This method transforms the state out-of-place. `x_in` and `x_out` are here pairs
* of coordinate and momentum.
*
* \tparam NumOfStages Number of stages.
* \tparam Order The order of the stepper.
* \tparam Coor The type representing the coordinates q.
* \tparam Momentum The type representing the coordinates p.
* \tparam Value The basic value type. Should be something like float, double or a high-precision type.
* \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
* \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
* \tparam Time The type representing the time t.
* \tparam Algebra The algebra.
* \tparam Operations The operations.
* \tparam Resizer The resizer policy.
*/
/**
* \fn symplectic_nystroem_stepper_base::symplectic_nystroem_stepper_base( const coef_type &coef_a , const coef_type &coef_b , const algebra_type &algebra )
* \brief Constructs a symplectic_nystroem_stepper_base class. The parameters of the specific Nystroem method and the
* algebra have to be passed.
* \param coef_a The coefficients a.
* \param coef_b The coefficients b.
* \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
*/
/**
* \fn symplectic_nystroem_stepper_base::order( void ) const
* \return Returns the order of the stepper.
*/
/**
* \fn symplectic_nystroem_stepper_base::do_step( System system , const StateInOut &state , time_type t , time_type dt )
* \brief 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 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 )`.
*
* \note This method solves the forwarding problem.
*
* \param system The system, can be represented as a pair of two function object or one function object. See above.
* \param 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.
* \param t The time of the ODE. It is not advanced by this method.
* \param dt The time step.
*/
/**
* \fn symplectic_nystroem_stepper_base::do_step( System system , CoorInOut &q , MomentumInOut &p , time_type t , time_type dt )
* \brief 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 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 )`.
*
* \note This method solves the forwarding problem.
*
* \param system The system, can be represented as a pair of two function object or one function object. See above.
* \param q The coordinate of the ODE. It is updated in-place. Therefore, the new value of the coordinate will be written
* into this variable.
* \param p The momentum of the ODE. It is updated in-place. Therefore, the new value of the momentum will be written info
* this variable.
* \param t The time of the ODE. It is not advanced by this method.
* \param dt The time step.
*/
/**
* \fn symplectic_nystroem_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
* \brief 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 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 )`.
*
* \note This method NOT solve the forwarding problem.
*
* \param system The system, can be represented as a pair of two function object or one function object. See above.
* \param 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
* \param t The time of the ODE. It is not advanced by this method.
* \param out The new state of the ODE.
* \param dt The time step.
*/
/**
* \fn symplectic_nystroem_stepper_base::adjust_size( const StateType &x )
* \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.
*/
} // namespace odeint
} // namespace numeric
} // namespace boost
#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_SYMPLECTIC_RKN_STEPPER_BASE_HPP_INCLUDED