diff options
Diffstat (limited to 'boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp')
| -rw-r--r-- | boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp | 371 |
1 files changed, 371 insertions, 0 deletions
diff --git a/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp b/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp new file mode 100644 index 0000000000..7a2b48d829 --- /dev/null +++ b/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp @@ -0,0 +1,371 @@ +/* + [auto_generated] + boost/numeric/odeint/iterator/detail/times_iterator_impl.hpp + + [begin_description] + tba. + [end_description] + + Copyright 2009-2013 Karsten Ahnert + Copyright 2009-2013 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_ITERATOR_DETAIL_TIMES_ITERATOR_IMPL_HPP_DEFINED +#define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_TIMES_ITERATOR_IMPL_HPP_DEFINED + +#include <boost/utility/enable_if.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/throw_exception.hpp> + +#include <boost/numeric/odeint/util/unit_helper.hpp> +#include <boost/numeric/odeint/util/copy.hpp> +#include <boost/numeric/odeint/stepper/controlled_step_result.hpp> +#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp> + + +namespace boost { +namespace numeric { +namespace odeint { + + + template< class Iterator , class Stepper , class System , class State , class TimeIterator , + typename Tag , typename StepperTag > + class times_iterator_impl; + + /* + * Specilization for basic steppers + */ + /** + * \brief ODE Iterator with constant step size. + * + * Implements an ODE iterator with observer calls at predefined times. + * Uses controlled steppers. times_iterator is a model of single-pass iterator. + * + * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time. + * + * \tparam Stepper The stepper type which should be used during the iteration. + * \tparam System The type of the system function (ODE) which should be solved. + */ + template< class Iterator , class Stepper , class System , class State , class TimeIterator , typename Tag > + class times_iterator_impl< Iterator , Stepper , System , State , TimeIterator , Tag , stepper_tag > + : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > + { + private: + + + typedef Stepper stepper_type; + typedef System system_type; + typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type; + typedef State state_type; + typedef TimeIterator time_iterator_type; + typedef typename traits::time_type< stepper_type >::type time_type; + typedef typename traits::value_type< stepper_type >::type ode_value_type; + #ifndef DOXYGEN_SKIP + typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type; + #endif + + public: + + /** + * \brief Constructs a times_iterator. This constructor should be used to construct the begin iterator. + * + * \param stepper The stepper to use during the iteration. + * \param sys The system function (ODE) to solve. + * \param s The initial state. adaptive_iterator stores a reference of s and changes its value during the iteration. + * \param t_start Iterator to the begin of a sequence of time values. + * \param t_end Iterator to the begin of a sequence of time values. + * \param dt The (initial) time step. + */ + times_iterator_impl( stepper_type stepper , system_type sys , state_type &s , + time_iterator_type t_start , time_iterator_type t_end , time_type dt ) + : base_type( stepper , sys , *t_start , dt ) , + m_t_start( t_start ) , m_t_end( t_end ) , m_state( &s ) + { + if( t_start == t_end ) + this->m_at_end = true; + } + + /** + * \brief Constructs an adaptive_iterator. This constructor should be used to construct the end iterator. + * + * \param stepper The stepper to use during the iteration. + * \param sys The system function (ODE) to solve. + * \param s The initial state. adaptive_iterator store a reference of s and changes its value during the iteration. + */ + times_iterator_impl( stepper_type stepper , system_type sys , state_type &s ) + : base_type( stepper , sys ) , m_state( &s ) { } + + protected: + + friend class boost::iterator_core_access; + + void increment() + { + unwrapped_stepper_type &stepper = this->m_stepper; + if( ++m_t_start != m_t_end ) + { + while( detail::less_with_sign( this->m_t , static_cast<time_type>(*m_t_start) , this->m_dt ) ) + { + const time_type current_dt = detail::min_abs( this->m_dt , static_cast<time_type>(*m_t_start) - this->m_t ); + stepper.do_step( this->m_system , *( this->m_state ) , this->m_t , current_dt ); + this->m_t += current_dt; + } + + } else { + this->m_at_end = true; + } + } + + public: + const state_type& get_state() const + { + return *m_state; + } + + private: + time_iterator_type m_t_start; + time_iterator_type m_t_end; + state_type* m_state; + }; + + + + /* + * Specilization for controlled steppers + */ + /** + * \brief ODE Iterator with adaptive step size control. The value type of this iterator is the state type of the stepper. + * + * Implements an ODE iterator with observer calls at predefined times. + * Uses controlled steppers. times_iterator is a model of single-pass iterator. + * + * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time. + * + * \tparam Stepper The stepper type which should be used during the iteration. + * \tparam System The type of the system function (ODE) which should be solved. + */ + template< class Iterator , class Stepper , class System , class State , class TimeIterator , typename Tag > + class times_iterator_impl< Iterator , Stepper , System , State , TimeIterator , Tag , controlled_stepper_tag > + : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > + { + private: + + + typedef Stepper stepper_type; + typedef System system_type; + typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type; + typedef State state_type; + typedef TimeIterator time_iterator_type; + typedef typename traits::time_type< stepper_type >::type time_type; + typedef typename traits::value_type< stepper_type >::type ode_value_type; + #ifndef DOXYGEN_SKIP + typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type; + #endif + + public: + + /** + * \brief Constructs a times_iterator. This constructor should be used to construct the begin iterator. + * + * \param stepper The stepper to use during the iteration. + * \param sys The system function (ODE) to solve. + * \param s The initial state. adaptive_iterator stores a reference of s and changes its value during the iteration. + * \param t_start Iterator to the begin of a sequence of time values. + * \param t_end Iterator to the begin of a sequence of time values. + * \param dt The (initial) time step. + */ + times_iterator_impl( stepper_type stepper , system_type sys , state_type &s , + time_iterator_type t_start , time_iterator_type t_end , time_type dt ) + : base_type( stepper , sys , *t_start , dt ) , + m_t_start( t_start ) , m_t_end( t_end ) , m_state( &s ) + { + if( t_start == t_end ) + this->m_at_end = true; + } + + /** + * \brief Constructs an adaptive_iterator. This constructor should be used to construct the end iterator. + * + * \param stepper The stepper to use during the iteration. + * \param sys The system function (ODE) to solve. + * \param s The initial state. adaptive_iterator store a reference of s and changes its value during the iteration. + */ + times_iterator_impl( stepper_type stepper , system_type sys , state_type &s ) + : base_type( stepper , sys ) , m_state( &s ) { } + + protected: + + friend class boost::iterator_core_access; + + void increment() + { + if( ++m_t_start != m_t_end ) + { + while( detail::less_with_sign( this->m_t , static_cast<time_type>(*m_t_start) , this->m_dt ) ) + { + if( detail::less_with_sign( static_cast<time_type>(*m_t_start) - this->m_t , this->m_dt , this->m_dt ) ) + { + // we want to end exactly at the time point + time_type current_dt = static_cast<time_type>(*m_t_start) - this->m_t; + step_loop( current_dt ); + } else { + step_loop( this->m_dt ); + } + } + + } else { + this->m_at_end = true; + } + } + + private: + void step_loop( time_type &dt ) + { + unwrapped_stepper_type &stepper = this->m_stepper; + const size_t max_attempts = 1000; + size_t trials = 0; + controlled_step_result res = success; + do + { + res = stepper.try_step( this->m_system , *( this->m_state ) , this->m_t , dt ); + ++trials; + } + while( ( res == fail ) && ( trials < max_attempts ) ); + if( trials == max_attempts ) + { + BOOST_THROW_EXCEPTION( std::overflow_error( "Adaptive iterator : Maximal number of iterations reached. A step size could not be found." ) ); + } + } + + public: + const state_type& get_state() const + { + return *m_state; + } + + + private: + time_iterator_type m_t_start; + time_iterator_type m_t_end; + state_type* m_state; + }; + + + /* + * Specilization for dense outputer steppers + */ + /** + * \brief ODE Iterator with step size control and dense output. + * Implements an ODE iterator with adaptive step size control. Uses dense-output steppers. + * times_iterator is a model of single-pass iterator. + * + * \tparam Stepper The stepper type which should be used during the iteration. + * \tparam System The type of the system function (ODE) which should be solved. + */ + template< class Iterator , class Stepper , class System , class State , class TimeIterator , typename Tag > + class times_iterator_impl< Iterator , Stepper , System , State , TimeIterator , Tag , dense_output_stepper_tag > + : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > + { + private: + + + typedef Stepper stepper_type; + typedef System system_type; + typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type; + typedef State state_type; + typedef TimeIterator time_iterator_type; + typedef typename traits::time_type< stepper_type >::type time_type; + typedef typename traits::value_type< stepper_type >::type ode_value_type; + #ifndef DOXYGEN_SKIP + typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type; + #endif + + + public: + + + /** + * \brief Constructs a times_iterator. This constructor should be used to construct the begin iterator. + * + * \param stepper The stepper to use during the iteration. + * \param sys The system function (ODE) to solve. + * \param s The initial state. + * \param t_start Iterator to the begin of a sequence of time values. + * \param t_end Iterator to the begin of a sequence of time values. + * \param dt The (initial) time step. + */ + times_iterator_impl( stepper_type stepper , system_type sys , state_type &s , + time_iterator_type t_start , time_iterator_type t_end , time_type dt ) + : base_type( stepper , sys , *t_start , dt ) , + m_t_start( t_start ) , m_t_end( t_end ) , m_final_time( *(t_end-1) ) , + m_state( &s ) + { + if( t_start != t_end ) + { + unwrapped_stepper_type &st = this->m_stepper; + st.initialize( *( this->m_state ) , this->m_t , this->m_dt ); + } else { + this->m_at_end = true; + } + } + + /** + * \brief Constructs a times_iterator. This constructor should be used to construct the end iterator. + * + * \param stepper The stepper to use during the iteration. + * \param sys The system function (ODE) to solve. + * \param s The initial state. + */ + times_iterator_impl( stepper_type stepper , system_type sys , state_type &s ) + : base_type( stepper , sys ) , m_state( &s ) { } + + protected: + + friend class boost::iterator_core_access; + + void increment() + { + unwrapped_stepper_type &st = this->m_stepper; + if( ++m_t_start != m_t_end ) + { + this->m_t = static_cast<time_type>(*m_t_start); + while( detail::less_with_sign( st.current_time() , this->m_t , this->m_dt ) ) + { + // make sure we don't go beyond the last point + if( detail::less_with_sign( m_final_time-st.current_time() , st.current_time_step() , st.current_time_step() ) ) + { + st.initialize( st.current_state() , st.current_time() , m_final_time-st.current_time() ); + } + st.do_step( this->m_system ); + } + st.calc_state( this->m_t , *( this->m_state ) ); + } else { + this->m_at_end = true; + } + } + + public: + const state_type& get_state() const + { + return *m_state; + } + + + private: + time_iterator_type m_t_start; + time_iterator_type m_t_end; + time_type m_final_time; + state_type* m_state; + }; + +} // namespace odeint +} // namespace numeric +} // namespace boost + + +#endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_TIMES_ITERATOR_IMPL_HPP_DEFINED |