boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp

@@ -0,0 +1,239 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/iterator/detail/n_step_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_N_STEP_ITERATOR_IMPL_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_N_STEP_ITERATOR_IMPL_HPP_DEFINED
+
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    template< class Iterator , class Stepper , class System , class State , typename Tag , class StepperTag >
+    class n_step_iterator_impl;
+
+
+    /*
+     * Specilization for steppers and error steppers
+     */
+    /**
+     * \brief ODE Iterator performing exactly n steps with constant step size. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an ODE iterator solving the ODE with constant step size. Uses steppers fulfilling the Stepper concept.
+     * n_step_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 , typename Tag >
+    class n_step_iterator_impl< Iterator , Stepper , System , State , 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 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 n_step_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. const_step_iterator stores a reference of s and changes its value during the iteration.
+         * \param t The initial time.
+         * \param dt The initial time step.
+         * \param num_of_steps the number of steps to be executed.
+         */
+        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s ,
+                              time_type t , time_type dt , size_t num_of_steps )
+            : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_state( &s ) ,
+              m_steps(num_of_steps) , m_step( 0 )
+        { }
+
+        /**
+         * \brief Constructs a const_step_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. const_step_iterator stores a reference of s and changes its value during the iteration.
+         */
+        n_step_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( this->m_step < this->m_steps )
+            {
+                unwrapped_stepper_type &stepper = this->m_stepper;
+                stepper.do_step( this->m_system , *this->m_state , this->m_t , this->m_dt );
+                // use integer to compute current time to reduce roundoff errors
+                this->m_step++;
+                this->m_t = this->m_t_start + static_cast< typename unit_value_type<time_type>::type >(this->m_step)*this->m_dt;
+            } else {
+                this->m_at_end = true;
+
+            }
+        }
+
+    public:
+        const state_type& get_state() const
+        {
+            return *m_state;
+        }
+
+
+    private:
+        time_type m_t_start;
+        time_type m_t_end;
+        state_type* m_state;
+        size_t m_steps;
+        size_t m_step;
+
+    };
+
+
+
+
+    /*
+     * Specilization for dense output stepper
+     */
+    /**
+     * \brief ODE Iterator with step-size control and dense output.
+     *
+     * Implements an ODE iterator solving the ODE with constant steps. Uses dense-output steppers.
+     * n_step_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 , typename Tag >
+    class n_step_iterator_impl< Iterator , Stepper , System , State , 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 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 const_step_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. const_step_iterator stores a reference of s and changes its value during the iteration.
+         * \param t The initial time.
+         * \param dt The initial time step.
+         * \param num_of_steps the number of steps to be executed.
+         */
+        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s ,
+                              time_type t , time_type dt , size_t num_of_steps )
+            : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_state( &s ) ,
+              m_steps( num_of_steps ) , m_step( 0 )
+        {
+            unwrapped_stepper_type &st = this->m_stepper;
+            st.initialize( * ( this->m_state ) , this->m_t , this->m_dt );
+        }
+
+        /**
+         * \brief Constructs a const_step_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. const_step_iterator stores a reference of s and changes its value during the iteration.
+         */
+        n_step_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( void )
+        {
+            if( this->m_step < this->m_steps )
+            {
+                unwrapped_stepper_type &stepper = this->m_stepper;
+                // use integer to compute current time to reduce roundoff errors
+                this->m_step++;
+                this->m_t = this->m_t_start + static_cast< typename unit_value_type<time_type>::type >(this->m_step)*this->m_dt;
+                while( detail::less_with_sign( stepper.current_time() , this->m_t ,
+                       stepper.current_time_step() ) )
+                {
+                    stepper.do_step( this->m_system );
+                }
+                stepper.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_type m_t_start;
+        time_type m_t_end;
+        state_type* m_state;
+        size_t m_steps;
+        size_t m_step;
+    };
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_N_STEP_ITERATOR_IMPL_HPP_DEFINED

package/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp

@@ -0,0 +1,369 @@
+/*
+ [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/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

package/boost/numeric/odeint/iterator/integrate/detail/functors.hpp

@@ -0,0 +1,70 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/functors.hpp
+
+ [begin_description]
+ some functors for the iterator based integrate routines
+ [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_INTEGRATE_DETAIL_FUNCTORS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_FUNCTORS_HPP_INCLUDED
+
+#include <utility>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+
+template< class Observer >
+struct obs_caller {
+
+    size_t &m_n;
+    Observer m_obs;
+
+    obs_caller( size_t &m , Observer &obs ) : m_n(m) , m_obs( obs ) {}
+
+    template< class State , class Time >
+    void operator()( std::pair< const State & , const Time & > x )
+    {
+        typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+        observer_type &obs = m_obs;
+        obs( x.first , x.second );
+        m_n++;
+    }
+};
+
+template< class Observer , class Time >
+struct obs_caller_time {
+
+    Time &m_t;
+    Observer m_obs;
+
+    obs_caller_time( Time &t , Observer &obs ) : m_t(t) , m_obs( obs ) {}
+
+    template< class State >
+    void operator()( std::pair< const State & , const Time & > x )
+    {
+        typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+        observer_type &obs = m_obs;
+        obs( x.first , x.second );
+        m_t = x.second;
+    }
+};
+
+} // namespace detail
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_FUNCTORS_HPP_INCLUDED