?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/odeint.zip
???????
PK 䄟[RV�]� � config.hppnu �[��� /* [auto_generated] boost/numeric/odeint/config.hpp [begin_description] Sets configurations for odeint and used libraries. Should be included before any other odeint library [end_description] Copyright 2011-2012 Mario Mulansky Copyright 2011-2012 Karsten Ahnert 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_CONFIG_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_CONFIG_HPP_INCLUDED //increase macro variable to allow rk78 scheme #ifndef FUSION_MAX_VECTOR_SIZE #define FUSION_MAX_VECTOR_SIZE 15 #endif /* * the following definitions are only required if fusion vectors are used as state types * in the rk78 scheme * they should be defined by the user if required, see e.g. libs/numeric/examples/harmonic_oscillator_units.cpp */ #ifndef BOOST_FUSION_INVOKE_MAX_ARITY #define BOOST_FUSION_INVOKE_MAX_ARITY 15 #endif #ifndef BOOST_RESULT_OF_NUM_ARGS #define BOOST_RESULT_OF_NUM_ARGS 15 #endif #include <boost/config.hpp> #if __cplusplus >= 201103L #define BOOST_NUMERIC_ODEINT_CXX11 1 #endif #endif // BOOST_NUMERIC_ODEINT_CONFIG_HPP_INCLUDED PK 䄟[43 �� � util/split.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/split.hpp [begin_description] Split abstraction for parallel backends. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_UTIL_SPLIT_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_SPLIT_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { /* * No default implementation of the split operation */ template< class Container1, class Container2 , class Enabler = void > struct split_impl { static void split( const Container1 &from , Container2 &to ); }; template< class Container1 , class Container2 > void split( const Container1 &from , Container2 &to ) { split_impl< Container1 , Container2 >::split( from , to ); } /* * No default implementation of the unsplit operation */ template< class Container1, class Container2 , class Enabler = void > struct unsplit_impl { static void unsplit( const Container1 &from , Container2 &to ); }; template< class Container1 , class Container2 > void unsplit( const Container1 &from , Container2 &to ) { unsplit_impl< Container1 , Container2 >::unsplit( from , to ); } } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED PK 䄟[���� util/resize.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/state_wrapper.hpp [begin_description] State wrapper for the state type in all stepper. The state wrappers are responsible for construction, destruction, copying construction, assignment and resizing. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011 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_UTIL_RESIZE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_RESIZE_HPP_INCLUDED #include <boost/range.hpp> #include <boost/utility/enable_if.hpp> #include <boost/fusion/include/is_sequence.hpp> #include <boost/fusion/include/zip_view.hpp> #include <boost/fusion/include/vector.hpp> #include <boost/fusion/include/make_fused.hpp> #include <boost/fusion/include/for_each.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> namespace boost { namespace numeric { namespace odeint { template< class StateOut , class StateIn , class Enabler = void > struct resize_impl_sfinae { static void resize( StateOut &x1 , const StateIn &x2 ) { x1.resize( boost::size( x2 ) ); } }; // resize function // standard implementation relies on boost.range and resize member function template< class StateOut , class StateIn > struct resize_impl { static void resize( StateOut &x1 , const StateIn &x2 ) { resize_impl_sfinae< StateOut , StateIn >::resize( x1 , x2 ); } }; // do not overload or specialize this function, specialize resize_impl<> instead template< class StateOut , class StateIn > void resize( StateOut &x1 , const StateIn &x2 ) { resize_impl< StateOut , StateIn >::resize( x1 , x2 ); } namespace detail { struct resizer { typedef void result_type; template< class StateOut , class StateIn > void operator()( StateOut &x1 , const StateIn &x2 ) const { resize_op( x1 , x2 , typename is_resizeable< StateOut >::type() ); } template< class StateOut , class StateIn > void resize_op( StateOut &x1 , const StateIn &x2 , boost::true_type ) const { resize( x1 , x2 ); } template< class StateOut , class StateIn > void resize_op( StateOut &/*x1*/ , const StateIn &/*x2*/ , boost::false_type ) const { } }; } // namespace detail /* * specialization for fusion sequences */ template< class FusionSeq > struct resize_impl_sfinae< FusionSeq , FusionSeq , typename boost::enable_if< typename boost::fusion::traits::is_sequence< FusionSeq >::type >::type > { static void resize( FusionSeq &x1 , const FusionSeq &x2 ) { typedef boost::fusion::vector< FusionSeq& , const FusionSeq& > Sequences; Sequences sequences( x1 , x2 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( detail::resizer() ) ); } }; } } } #endif // BOOST_NUMERIC_ODEINT_UTIL_RESIZE_HPP_INCLUDED PK 䄟[��B# util/split_adaptor.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/split_adaptor.hpp [begin_description] A range adaptor which returns even-sized slices. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_UTIL_SPLIT_ADAPTOR_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_SPLIT_ADAPTOR_INCLUDED #include <boost/range/adaptor/argument_fwd.hpp> #include <boost/range/size_type.hpp> #include <boost/range/iterator_range.hpp> #include <algorithm> namespace boost { namespace numeric { namespace odeint { namespace detail { /** \brief Returns the begin and end offset for a sub-range */ inline std::pair<std::size_t, std::size_t> split_offsets( std::size_t total_length, std::size_t index, std::size_t parts ) { BOOST_ASSERT( parts > 0 ); BOOST_ASSERT( index < parts ); const std::size_t slice = total_length / parts, partial = total_length % parts, lo = (std::min)(index, partial), hi = (std::max<std::ptrdiff_t>)(0, index - partial), begin_offset = lo * (slice + 1) + hi * slice, length = slice + (index < partial ? 1 : 0), end_offset = begin_offset + length; return std::make_pair( begin_offset, end_offset ); } /** \brief Return the sub-range `index` from a range which is split into `parts`. * * For example, splitting a range into three about equal-sized sub-ranges: * \code * sub0 = make_split_range(rng, 0, 3); * sub1 = rng | split(1, 3); * sub2 = rng | split(2, 3); * \endcode */ template< class RandomAccessRange > inline iterator_range< typename range_iterator<RandomAccessRange>::type > make_split_range( RandomAccessRange& rng, std::size_t index, std::size_t parts ) { const std::pair<std::size_t, std::size_t> off = split_offsets(boost::size(rng), index, parts); return make_iterator_range( boost::begin(rng) + off.first, boost::begin(rng) + off.second ); } template< class RandomAccessRange > inline iterator_range< typename range_iterator<const RandomAccessRange>::type > make_split_range( const RandomAccessRange& rng, std::size_t index, std::size_t parts ) { const std::pair<std::size_t, std::size_t> off = split_offsets(boost::size(rng), index, parts); return make_iterator_range( boost::begin(rng) + off.first, boost::begin(rng) + off.second ); } struct split { split(std::size_t index, std::size_t parts) : index(index), parts(parts) {} std::size_t index, parts; }; template< class RandomAccessRange > inline iterator_range< typename range_iterator<RandomAccessRange>::type > operator|( RandomAccessRange& rng, const split& f ) { return make_split_range( rng, f.index, f.parts ); } template< class RandomAccessRange > inline iterator_range< typename range_iterator<const RandomAccessRange>::type > operator|( const RandomAccessRange& rng, const split& f ) { return make_split_range( rng, f.index, f.parts ); } } } } } #endif PK 䄟[�١� util/is_pair.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/is_pair.hpp [begin_description] Metafunction to determine if a type is a std::pair<>. [end_description] Copyright 2011 Karsten Ahnert Copyright 2011 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_UTIL_IS_PAIR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_IS_PAIR_HPP_INCLUDED #include <boost/mpl/bool.hpp> #include <utility> namespace boost { namespace numeric { namespace odeint { template< class T > struct is_pair : public boost::mpl::false_ { }; template< class T1 , class T2 > struct is_pair< std::pair< T1 , T2 > > : public boost::mpl::true_ { }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_UTIL_IS_PAIR_HPP_INCLUDED PK 䄟[=+[n n util/copy.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/copy.hpp [begin_description] Copy abstraction for the usage in the steppers. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_UTIL_COPY_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED #include <boost/range/algorithm/copy.hpp> #include <boost/utility/enable_if.hpp> #include <boost/numeric/odeint/util/detail/is_range.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { template< class Container1 , class Container2 > void do_copying( const Container1 &from , Container2 &to , boost::mpl::true_ ) { boost::range::copy( from , boost::begin( to ) ); } template< class Container1 , class Container2 > void do_copying( const Container1 &from , Container2 &to , boost::mpl::false_ ) { to = from; } } // namespace detail /* * Default implementation of the copy operation used the assign operator * gsl_vector must copied differently */ template< class Container1 , class Container2 , class Enabler = void > struct copy_impl_sfinae { static void copy( const Container1 &from , Container2 &to ) { typedef typename boost::numeric::odeint::detail::is_range< Container1 >::type is_range_type; detail::do_copying( from , to , is_range_type() ); } }; template< class Container1, class Container2 > struct copy_impl { static void copy( const Container1 &from , Container2 &to ) { copy_impl_sfinae< Container1 , Container2 >::copy( from , to ); } }; // ToDo: allow also to copy INTO a range, not only from a range! Needs "const Container2 &to" template< class Container1 , class Container2 > void copy( const Container1 &from , Container2 &to ) { copy_impl< Container1 , Container2 >::copy( from , to ); } } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED PK 䄟[4E_$ util/stepper_traits.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/stepper_traits.hpp [begin_description] tba. [end_description] Copyright 2013 Karsten Ahnert Copyright 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_UTIL_STEPPER_TRAITS_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_UTIL_STEPPER_TRAITS_HPP_DEFINED #include <boost/numeric/odeint/util/unwrap_reference.hpp> namespace boost { namespace numeric { namespace odeint { namespace traits { template< class Stepper > struct state_type { typedef typename boost::numeric::odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename stepper_type::state_type type; }; template< class Stepper > struct time_type { typedef typename boost::numeric::odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename stepper_type::time_type type; }; template< class Stepper > struct stepper_category { typedef typename boost::numeric::odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename stepper_type::stepper_category type; }; template< class Stepper > struct value_type { typedef typename boost::numeric::odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename stepper_type::value_type type; }; } // namespace traits } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_UTIL_STEPPER_TRAITS_HPP_DEFINED PK 䄟[p�ط� � util/resizer.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/resizer.hpp [begin_description] Implementation of the resizers. [end_description] Copyright 2011-2012 Mario Mulansky Copyright 2011 Karsten Ahnert 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_UTIL_RESIZER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_RESIZER_HPP_INCLUDED #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/same_size.hpp> #include <boost/numeric/odeint/util/resize.hpp> namespace boost { namespace numeric { namespace odeint { template< class ResizeWrappedState , class State > bool adjust_size_by_resizeability( ResizeWrappedState &x , const State &y , boost::true_type ) { if ( !same_size( x.m_v , y ) ) { resize( x.m_v , y ); return true; } else return false; } template< class ResizeWrappedState , class State > bool adjust_size_by_resizeability( ResizeWrappedState & /* x */ , const State & /* y */ , boost::false_type ) { return false; } struct always_resizer { template< class State , class ResizeFunction > bool adjust_size( const State &x , ResizeFunction f ) { return f( x ); } }; struct initially_resizer { bool m_initialized; initially_resizer() : m_initialized( false ) { } template< class State , class ResizeFunction > bool adjust_size( const State &x , ResizeFunction f ) { if( !m_initialized ) { m_initialized = true; return f( x ); } else return false; } }; struct never_resizer { template< class State , class ResizeFunction > bool adjust_size( const State &/*x*/ , ResizeFunction /*f*/ ) { return false; } }; } } } #endif // BOOST_NUMERIC_ODEINT_UTIL_RESIZER_HPP_INCLUDED PK 䄟[��Z?� � util/bind.hppnu �[��� /* * [begin_description] * Boost bind pull the placeholders, _1, _2, ... into global * namespace. This can conflict with the C++03 TR1 and C++11 * std::placeholders. This header provides a workaround for * this problem. * [end_description] * * Copyright 2012 Christoph Koke * Copyright 2012 Karsten Ahnert * * 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_UTIL_BIND_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_BIND_HPP_INCLUDED #include <boost/numeric/odeint/config.hpp> #if BOOST_NUMERIC_ODEINT_CXX11 #include <functional> #else #define BOOST_BIND_NO_PLACEHOLDERS #include <boost/bind.hpp> #endif namespace boost { namespace numeric { namespace odeint { namespace detail { #if BOOST_NUMERIC_ODEINT_CXX11 using ::std::bind; using namespace ::std::placeholders; #else // unnamed namespace to avoid multiple declarations (#138) namespace { using ::boost::bind; boost::arg<1> _1; boost::arg<2> _2; } // using ::boost::bind; // using ::_1; // using ::_2; #endif } } } } /* // the following is the suggested way. Unfortunately it does not work with all compilers. #ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL #include <boost/bind.hpp> #else #include <functional> #endif namespace boost { namespace numeric { namespace odeint { namespace detail { #ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL using ::boost::bind; using ::_1; using ::_2; #else using ::std::bind; using namespace ::std::placeholders; #endif } } } }*/ #endif // BOOST_NUMERIC_ODEINT_UTIL_BIND_HPP_INCLUDED PK 䄟[�oť � util/multi_array_adaption.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/multi_array_adaption.hpp [begin_description] tba. [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/util/same_size.hpp> #include <boost/mpl/and.hpp> #include <boost/mpl/bool.hpp> #include <boost/multi_array.hpp> namespace boost { namespace numeric { namespace odeint { template< typename T > struct is_multi_array { typedef boost::false_type type; const static bool value = type::value; }; template< typename T > struct is_resizeable_multi_array { typedef boost::false_type type; const static bool value = type::value; }; template< typename V , size_t Dim , typename A > struct is_multi_array< boost::multi_array< V , Dim , A > > { typedef boost::true_type type; const static bool value = type::value; }; template< typename V , size_t Dim , typename A > struct is_resizeable_multi_array< boost::multi_array< V , Dim , A > > { typedef boost::true_type type; const static bool value = type::value; }; template< typename T > struct is_resizeable_sfinae< T , typename boost::enable_if< typename is_resizeable_multi_array< T >::type >::type > { typedef boost::true_type type; const static bool value = type::value; }; template< typename T1 , typename T2 > struct same_size_impl_sfinae< T1 , T2 , typename boost::enable_if< typename boost::mpl::and_< is_multi_array< T1 > , is_multi_array< T2 > , boost::mpl::bool_< T1::dimensionality == T2::dimensionality > >::type >::type > { static bool same_size( T1 const &x1 , T2 const &x2 ) { for( size_t i=0 ; i<T1::dimensionality ; ++i ) { if( x1.shape()[i] != x2.shape()[i] ) return false; if( x1.index_bases()[i] != x2.index_bases()[i] ) return false; } return true; } }; template< typename T1 , typename T2 > struct resize_impl_sfinae< T1 , T2 , typename boost::enable_if< typename boost::mpl::and_< is_resizeable_multi_array< T1 > , is_multi_array< T2 > , boost::mpl::bool_< T1::dimensionality == T2::dimensionality > >::type >::type > { static void resize( T1 &x1 , const T2 &x2 ) { boost::array< int , T1::dimensionality > extents; for( size_t i=0 ; i<T1::dimensionality ; ++i ) extents[i] = x2.shape()[i]; x1.resize( extents ); boost::array< int , T1::dimensionality > origins; for( size_t i=0 ; i<T1::dimensionality ; ++i ) origins[i] = x2.index_bases()[i]; x1.reindex( origins ); } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED PK 䄟[b�q util/odeint_error.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/odeint_error.hpp [begin_description] Runtime Exceptions thrown by odeint [end_description] Copyright 2015 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_UTIL_ODEINT_ERROR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_ODEINT_ERROR_HPP_INCLUDED #include <stdexcept> #include <string> namespace boost { namespace numeric { namespace odeint { /** * \brief Runtime error thrown by odeint */ class odeint_error : public std::runtime_error { public: odeint_error(const std::string &s) : std::runtime_error(s) { } }; /** * \brief Runtime error thrown from integrate routines * * This Error occures when too many iterations are performed in between two * observer calls in the integrate routines. */ class no_progress_error : public odeint_error { public: no_progress_error(const std::string &s) : odeint_error(s) { } }; /** * \brief Runtime error thrown during stepsize adjustment * * This Error occures when too many iterations are performed without finding * an appropriate new step size. This usually indicates non-continuous points * in the ODE. */ class step_adjustment_error : public odeint_error { public: step_adjustment_error(const std::string &s) : odeint_error(s) { } }; } } } #endif // BOOST_NUMERIC_ODEINT_UTIL_ODEINT_ERROR_HPP_INCLUDED PK 䄟[x�C�� � util/unit_helper.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/unit_helper.hpp [begin_description] Get and set the value of a unit. [end_description] Copyright 2012-2013 Karsten Ahnert Copyright 2012-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_UTIL_UNIT_HELPER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_UNIT_HELPER_HPP_INCLUDED #ifndef __CUDACC__ #include <boost/units/quantity.hpp> #include <boost/units/get_dimension.hpp> #include <boost/units/get_system.hpp> #endif namespace boost { namespace numeric { namespace odeint { namespace detail { template<class T , class Enabler = void > struct get_unit_value_impl { static T value(const T &t) { return t; } typedef T result_type; }; #ifndef __CUDACC__ template<class Unit , class T> struct get_unit_value_impl< boost::units::quantity< Unit , T> > { static T value( const boost::units::quantity< Unit , T> &t ) { return t.value(); } typedef T result_type; }; #endif template<class T , class V , class Enabler = void > struct set_unit_value_impl { static void set_value(T &t , const V &v) { t = v; } }; #ifndef __CUDACC__ template<class Unit , class T , class V> struct set_unit_value_impl<boost::units::quantity<Unit , T> , V> { static void set_value(boost::units::quantity<Unit , T> &t , const V &v) { t = boost::units::quantity<Unit , T>::from_value(v); } }; #endif } // namespace detail template<class T> typename detail::get_unit_value_impl<T>::result_type get_unit_value(const T &t) { return detail::get_unit_value_impl<T>::value(t); } template<class T , class V> void set_unit_value(T &t , const V &v) { return detail::set_unit_value_impl<T , V>::set_value(t , v); } template< class T > struct unit_value_type { typedef T type; }; #ifndef __CUDACC__ template< class Unit , class Y > struct unit_value_type< boost::units::quantity< Unit , Y > > { typedef Y type; }; #endif template< typename Time > struct inverse_time { typedef Time type; }; #ifndef __CUDACC__ template< typename Unit , typename Value > struct inverse_time< boost::units::quantity< Unit , Value > > { typedef boost::units::quantity< Unit , Value > time_type; typedef typename boost::units::get_dimension< time_type >::type dimension; typedef typename boost::units::get_system< time_type >::type system; typedef typename boost::mpl::divides< boost::units::dimensionless_type , dimension >::type inv_dimension; typedef boost::units::unit< inv_dimension , system > inv_unit; typedef boost::units::quantity< inv_unit , Value > type; }; #endif } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_UTIL_UNIT_HELPER_HPP_INCLUDED PK 䄟[h� � � util/same_instance.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/same_instance.hpp [begin_description] Basic check if two variables are the same instance [end_description] Copyright 2012 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_UTIL_SAME_INSTANCE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_SAME_INSTANCE_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { template< class T1 , class T2 , class Enabler=void > struct same_instance_impl { static bool same_instance( const T1& /* x1 */ , const T2& /* x2 */ ) { return false; } }; template< class T > struct same_instance_impl< T , T > { static bool same_instance( const T &x1 , const T &x2 ) { // check pointers return (&x1 == &x2); } }; template< class T1 , class T2 > bool same_instance( const T1 &x1 , const T2 &x2 ) { return same_instance_impl< T1 , T2 >::same_instance( x1 , x2 ); } } // namespace odeint } // namespace numeric } // namespace boost #endif PK 䄟[@ɽ�� � util/detail/less_with_sign.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/detail/less_with_sign.hpp [begin_description] Helper function to compare times taking into account the sign of dt [end_description] Copyright 2012-2015 Mario Mulansky Copyright 2012 Karsten Ahnert 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_LESS_WITH_SIGN_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_LESS_WITH_SIGN_HPP_INCLUDED #include <limits> #include <boost/numeric/odeint/util/unit_helper.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { /** * return t1 < t2 if dt > 0 and t1 > t2 if dt < 0 with epsilon accuracy */ template< typename T > bool less_with_sign( T t1 , T t2 , T dt ) { if( get_unit_value(dt) > 0 ) //return t1 < t2; return t2-t1 > std::numeric_limits<T>::epsilon(); else //return t1 > t2; return t1-t2 > std::numeric_limits<T>::epsilon(); } /** * return t1 <= t2 if dt > 0 and t1 => t2 if dt < 0 with epsilon accuracy */ template< typename T > bool less_eq_with_sign( T t1 , T t2 , T dt ) { if( get_unit_value(dt) > 0 ) return t1-t2 <= std::numeric_limits<T>::epsilon(); else return t2-t1 <= std::numeric_limits<T>::epsilon(); } template< typename T > T min_abs( T t1 , T t2 ) { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); if( get_unit_value(t1)>0 ) return min BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 ); else return max BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 ); } template< typename T > T max_abs( T t1 , T t2 ) { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); if( get_unit_value(t1)>0 ) return max BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 ); else return min BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 ); } } } } } #endif PK 䄟[ �O�� � util/detail/is_range.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/detail/is_range.hpp [begin_description] is_range implementation. Taken from the boost::range library. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-2013 Thorsten Ottosen 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_UTIL_DETAIL_IS_RANGE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_DETAIL_IS_RANGE_HPP_INCLUDED #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif #include <cstddef> #include <boost/range/config.hpp> #include <boost/mpl/has_xxx.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/and.hpp> namespace boost { namespace numeric { namespace odeint { namespace range_detail { BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator) BOOST_MPL_HAS_XXX_TRAIT_DEF(const_iterator) } namespace detail { template< typename Range > struct is_range : boost::mpl::and_<range_detail::has_iterator<Range>, range_detail::has_const_iterator<Range> > { }; ////////////////////////////////////////////////////////////////////////// // pair ////////////////////////////////////////////////////////////////////////// template< typename iteratorT > struct is_range< std::pair<iteratorT,iteratorT> > : boost::mpl::true_ { }; template< typename iteratorT > struct is_range< const std::pair<iteratorT,iteratorT> > : boost::mpl::true_ { }; ////////////////////////////////////////////////////////////////////////// // array ////////////////////////////////////////////////////////////////////////// template< typename elementT, std::size_t sz > struct is_range< elementT[sz] > : boost::mpl::true_ { }; template< typename elementT, std::size_t sz > struct is_range< const elementT[sz] > : boost::mpl::true_ { }; ////////////////////////////////////////////////////////////////////////// // string ////////////////////////////////////////////////////////////////////////// template<> struct is_range< char* > : boost::mpl::true_ { }; template<> struct is_range< wchar_t* > : boost::mpl::true_ { }; template<> struct is_range< const char* > : boost::mpl::true_ { }; template<> struct is_range< const wchar_t* > : boost::mpl::true_ { }; template<> struct is_range< char* const > : boost::mpl::true_ { }; template<> struct is_range< wchar_t* const > : boost::mpl::true_ { }; template<> struct is_range< const char* const > : boost::mpl::true_ { }; template<> struct is_range< const wchar_t* const > : boost::mpl::true_ { }; } // namespace detail } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_UTIL_DETAIL_IS_RANGE_HPP_INCLUDED PK 䄟[��I!� � util/n_ary_helper.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/n_ary_helper.hpp Macros to generate scale_sumN and for_eachN functors. Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_UTIL_N_ARY_HELPER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_N_ARY_HELPER_HPP_INCLUDED #include <boost/preprocessor/repetition.hpp> // like BOOST_PP_ENUM_SHIFTED but with a comma in front like _TRAILING #define BOOST_ODEINT_ENUM_TRAILING_SHIFTED_PARAMS(count, param) \ BOOST_PP_COMMA_IF(BOOST_PP_DEC(count)) \ BOOST_PP_ENUM_SHIFTED_PARAMS(count, param) #define BOOST_ODEINT_ENUM_TRAILING_SHIFTED_BINARY_PARAMS(count, p1, p2) \ BOOST_PP_COMMA_IF(BOOST_PP_DEC(count)) \ BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(count, p1, p2) // like BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(n, p1, p2) but p2 is shifted left. // generate "p1 ## 0 = p2, p1 ## 1 = p3 ## 0, p1 ## 2 = p3 ## 1" #define BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS(count, p1, p2, p3) \ BOOST_PP_ENUM(count, BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS_, (p1, p2, p3)) #define BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS_(z, n, data) \ BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, data), n) \ BOOST_PP_IF(n, \ BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 2, data), BOOST_PP_DEC(n)), \ BOOST_PP_TUPLE_ELEM(3, 1, data)) // like BOOST_PP_ENUM_BINARY_PARAMS(n, p1, p2) but with statements. // "p1 ## 0 p2 ## 0 ; p1 ## 1 p2 ## 1 ; ..." #define BOOST_ODEINT_ENUM_BINARY_STATEMENTS(count, p1, p2) \ BOOST_PP_REPEAT(count, BOOST_ODEINT_ENUM_BINARY_STATEMENTS_, (p1, p2)) #define BOOST_ODEINT_ENUM_BINARY_STATEMENTS_(z, n, data) \ BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n) \ BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n) ; // like BOOST_PP_ENUM_BINARY_PARAMS(n, p1, p2) but p2 is in parens. // "p1 ## 0 (p2 ## 0) , p1 ## 1 (p2 ## 1) , ..." #define BOOST_ODEINT_ENUM_UNARY_CALLS(count, p1, p2) \ BOOST_PP_ENUM(count, BOOST_ODEINT_ENUM_UNARY_CALLS_, (p1, p2)) #define BOOST_ODEINT_ENUM_SHIFTED_UNARY_CALLS(count, p1, p2) \ BOOST_PP_ENUM_SHIFTED(count, BOOST_ODEINT_ENUM_UNARY_CALLS_, (p1, p2)) #define BOOST_ODEINT_ENUM_TRAILING_SHIFTED_UNARY_CALLS(count, p1, p2) \ BOOST_PP_COMMA_IF(BOOST_PP_DEC(count)) \ BOOST_PP_ENUM_SHIFTED(count, BOOST_ODEINT_ENUM_UNARY_CALLS_, (p1, p2)) #define BOOST_ODEINT_ENUM_UNARY_CALLS_(z, n, data) \ BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n) \ ( BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n) ) // maximum arity + 1 for scale_sum and for_each #define BOOST_ODEINT_N_ARY_MAX 16 // generate scale_sum1 to scale_sumN, operator body generated by macro(N) #define BOOST_ODEINT_GEN_SCALE_SUM(macro) \ BOOST_PP_REPEAT_FROM_TO(1, BOOST_ODEINT_N_ARY_MAX, BOOST_ODEINT_GEN_SCALE_SUM_, macro) #define BOOST_ODEINT_GEN_SCALE_SUM_(z, n, macro) \ template< BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS(n, class Fac, = double, = Fac) > \ struct BOOST_PP_CAT(scale_sum, n) \ { \ BOOST_ODEINT_ENUM_BINARY_STATEMENTS(n, const Fac, m_alpha) \ \ BOOST_PP_CAT(scale_sum, n) \ ( BOOST_PP_ENUM_BINARY_PARAMS(n, Fac, alpha) ) \ : BOOST_ODEINT_ENUM_UNARY_CALLS(n, m_alpha, alpha) {} \ \ template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), class T) > \ void operator()( T0 &t0 \ BOOST_ODEINT_ENUM_TRAILING_SHIFTED_BINARY_PARAMS(BOOST_PP_INC(n), const T, &t) \ ) const \ { macro(n) } \ typedef void result_type; \ }; // generate for_each1 to for_eachN, body generated by macro(N) #define BOOST_ODEINT_GEN_FOR_EACH(macro) \ BOOST_PP_REPEAT_FROM_TO(1, BOOST_ODEINT_N_ARY_MAX, BOOST_ODEINT_GEN_FOR_EACH_, macro) #define BOOST_ODEINT_GEN_FOR_EACH_(z, n, macro) \ template< BOOST_PP_ENUM_PARAMS(n, class S) , class Op > \ static void for_each##n ( BOOST_PP_ENUM_BINARY_PARAMS(n, S, &s) , Op op ) \ { macro(n) } #endif PK 䄟[� R�& �& util/ublas_wrapper.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/ublas_wrapper.hpp [begin_description] Resizing for ublas::vector and ublas::matrix [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_UTIL_UBLAS_WRAPPER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED #include <boost/type_traits/integral_constant.hpp> #include <boost/numeric/ublas/vector.hpp> #include <boost/numeric/ublas/matrix.hpp> #include <boost/numeric/ublas/lu.hpp> #include <boost/numeric/ublas/vector_expression.hpp> #include <boost/numeric/ublas/matrix_expression.hpp> #include <boost/numeric/odeint/algebra/vector_space_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/state_wrapper.hpp> /* extend ublas by a few operations */ /* map norm_inf onto reduce( v , default_operations::maximum ) */ namespace boost { namespace numeric { namespace odeint { template< typename T , typename A > struct vector_space_norm_inf< boost::numeric::ublas::vector<T,A> > { typedef T result_type; result_type operator()( const boost::numeric::ublas::vector<T,A> &x ) const { return boost::numeric::ublas::norm_inf( x ); } }; template< class T , class L , class A > struct vector_space_norm_inf< boost::numeric::ublas::matrix<T,L,A> > { typedef T result_type; result_type operator()( const boost::numeric::ublas::matrix<T,L,A> &x ) const { return boost::numeric::ublas::norm_inf( x ); } }; } } } /* additional operations: * abs( v ) * v / w * a + v */ namespace boost { namespace numeric { namespace ublas { // elementwise abs - calculates absolute values of the elements template<class T> struct scalar_abs: public scalar_unary_functor<T> { typedef typename scalar_unary_functor<T>::value_type value_type; typedef typename scalar_unary_functor<T>::argument_type argument_type; typedef typename scalar_unary_functor<T>::result_type result_type; static BOOST_UBLAS_INLINE result_type apply (argument_type t) { using std::abs; return abs (t); } }; // (abs v) [i] = abs (v [i]) template<class E> BOOST_UBLAS_INLINE typename vector_unary_traits<E, scalar_abs<typename E::value_type> >::result_type abs (const vector_expression<E> &e) { typedef typename vector_unary_traits<E, scalar_abs<typename E::value_type> >::expression_type expression_type; return expression_type (e ()); } // (abs m) [i] = abs (m [i]) template<class E> BOOST_UBLAS_INLINE typename matrix_unary1_traits<E, scalar_abs<typename E::value_type> >::result_type abs (const matrix_expression<E> &e) { typedef typename matrix_unary1_traits<E, scalar_abs<typename E::value_type> >::expression_type expression_type; return expression_type (e ()); } // elementwise division (v1 / v2) [i] = v1 [i] / v2 [i] template<class E1, class E2> BOOST_UBLAS_INLINE typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type, typename E2::value_type> >::result_type operator / (const vector_expression<E1> &e1, const vector_expression<E2> &e2) { typedef typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type, typename E2::value_type> >::expression_type expression_type; return expression_type (e1 (), e2 ()); } // elementwise division (m1 / m2) [i] = m1 [i] / m2 [i] template<class E1, class E2> BOOST_UBLAS_INLINE typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type, typename E2::value_type> >::result_type operator / (const matrix_expression<E1> &e1, const matrix_expression<E2> &e2) { typedef typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type, typename E2::value_type> >::expression_type expression_type; return expression_type (e1 (), e2 ()); } // addition with scalar // (t + v) [i] = t + v [i] template<class T1, class E2> BOOST_UBLAS_INLINE typename enable_if< is_convertible<T1, typename E2::value_type >, typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::result_type >::type operator + (const T1 &e1, const vector_expression<E2> &e2) { typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::expression_type expression_type; return expression_type (e1, e2 ()); } // addition with scalar // (t + m) [i] = t + m [i] template<class T1, class E2> BOOST_UBLAS_INLINE typename enable_if< is_convertible<T1, typename E2::value_type >, typename matrix_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::result_type >::type operator + (const T1 &e1, const matrix_expression<E2> &e2) { typedef typename matrix_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::expression_type expression_type; return expression_type (e1, e2 ()); } } } } /* add resize functionality */ namespace boost { namespace numeric { namespace odeint { /* * resizeable specialization for boost::numeric::ublas::vector */ template< class T , class A > struct is_resizeable< boost::numeric::ublas::vector< T , A > > { typedef boost::true_type type; const static bool value = type::value; }; /* * resizeable specialization for boost::numeric::ublas::matrix */ template< class T , class L , class A > struct is_resizeable< boost::numeric::ublas::matrix< T , L , A > > { typedef boost::true_type type; const static bool value = type::value; }; /* * resizeable specialization for boost::numeric::ublas::permutation_matrix */ template< class T , class A > struct is_resizeable< boost::numeric::ublas::permutation_matrix< T , A > > { typedef boost::true_type type; const static bool value = type::value; }; // specialization for ublas::matrix // same size and resize specialization for matrix-matrix resizing template< class T , class L , class A , class T2 , class L2 , class A2 > struct same_size_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::matrix< T2 , L2 , A2 > > { static bool same_size( const boost::numeric::ublas::matrix< T , L , A > &m1 , const boost::numeric::ublas::matrix< T2 , L2 , A2 > &m2 ) { return ( ( m1.size1() == m2.size1() ) && ( m1.size2() == m2.size2() ) ); } }; template< class T , class L , class A , class T2 , class L2 , class A2 > struct resize_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::matrix< T2 , L2 , A2 > > { static void resize( boost::numeric::ublas::matrix< T , L , A > &m1 , const boost::numeric::ublas::matrix< T2 , L2 , A2 > &m2 ) { m1.resize( m2.size1() , m2.size2() ); } }; // same size and resize specialization for matrix-vector resizing template< class T , class L , class A , class T_V , class A_V > struct same_size_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::vector< T_V , A_V > > { static bool same_size( const boost::numeric::ublas::matrix< T , L , A > &m , const boost::numeric::ublas::vector< T_V , A_V > &v ) { return ( ( m.size1() == v.size() ) && ( m.size2() == v.size() ) ); } }; template< class T , class L , class A , class T_V , class A_V > struct resize_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::vector< T_V , A_V > > { static void resize( boost::numeric::ublas::matrix< T , L , A > &m , const boost::numeric::ublas::vector< T_V , A_V > &v ) { m.resize( v.size() , v.size() ); } }; // specialization for ublas::permutation_matrix // same size and resize specialization for matrix-vector resizing template< class T , class A , class T_V , class A_V > struct same_size_impl< boost::numeric::ublas::permutation_matrix< T , A > , boost::numeric::ublas::vector< T_V , A_V > > { static bool same_size( const boost::numeric::ublas::permutation_matrix< T , A > &m , const boost::numeric::ublas::vector< T_V , A_V > &v ) { return ( m.size() == v.size() ); // && ( m.size2() == v.size() ) ); } }; template< class T , class A , class T_V , class A_V > struct resize_impl< boost::numeric::ublas::vector< T_V , A_V > , boost::numeric::ublas::permutation_matrix< T , A > > { static void resize( const boost::numeric::ublas::vector< T_V , A_V > &v, boost::numeric::ublas::permutation_matrix< T , A > &m ) { m.resize( v.size() , v.size() ); } }; template< class T , class A > struct state_wrapper< boost::numeric::ublas::permutation_matrix< T , A > > // with resizing { typedef boost::numeric::ublas::permutation_matrix< T , A > state_type; typedef state_wrapper< state_type > state_wrapper_type; state_type m_v; state_wrapper() : m_v( 1 ) // permutation matrix constructor requires a size, choose 1 as default { } }; } } } #endif // BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED PK 䄟[Ѓ� � util/same_size.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/state_wrapper.hpp [begin_description] State wrapper for the state type in all stepper. The state wrappers are responsible for construction, destruction, copying construction, assignment and resizing. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011 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_UTIL_SAME_SIZE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_SAME_SIZE_HPP_INCLUDED #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/utility/enable_if.hpp> #include <boost/fusion/include/is_sequence.hpp> #include <boost/fusion/include/zip_view.hpp> #include <boost/fusion/include/vector.hpp> #include <boost/fusion/include/make_fused.hpp> #include <boost/fusion/include/all.hpp> #include <boost/range.hpp> namespace boost { namespace numeric { namespace odeint { template< typename State1 , typename State2 , class Enabler = void > struct same_size_impl_sfinae { static bool same_size( const State1 &x1 , const State2 &x2 ) { return ( boost::size( x1 ) == boost::size( x2 ) ); } }; // same_size function // standard implementation relies on boost.range template< class State1 , class State2 > struct same_size_impl { static bool same_size( const State1 &x1 , const State2 &x2 ) { return same_size_impl_sfinae< State1 , State2 >::same_size( x1 , x2 ); } }; // do not overload or specialize this function, specialize resize_impl<> instead template< class State1 , class State2 > bool same_size( const State1 &x1 , const State2 &x2 ) { return same_size_impl< State1 , State2 >::same_size( x1 , x2 ); } namespace detail { struct same_size_fusion { typedef bool result_type; template< class S1 , class S2 > bool operator()( const S1 &x1 , const S2 &x2 ) const { return same_size_op( x1 , x2 , typename is_resizeable< S1 >::type() ); } template< class S1 , class S2 > bool same_size_op( const S1 &x1 , const S2 &x2 , boost::true_type ) const { return same_size( x1 , x2 ); } template< class S1 , class S2 > bool same_size_op( const S1 &/*x1*/ , const S2 &/*x2*/ , boost::false_type ) const { return true; } }; } // namespace detail template< class FusionSeq > struct same_size_impl_sfinae< FusionSeq , FusionSeq , typename boost::enable_if< typename boost::fusion::traits::is_sequence< FusionSeq >::type >::type > { static bool same_size( const FusionSeq &x1 , const FusionSeq &x2 ) { typedef boost::fusion::vector< const FusionSeq& , const FusionSeq& > Sequences; Sequences sequences( x1 , x2 ); return boost::fusion::all( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( detail::same_size_fusion() ) ); } }; } } } #endif // BOOST_NUMERIC_ODEINT_UTIL_SAME_SIZE_HPP_INCLUDED PK 䄟[w�~ 6 6 util/is_resizeable.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/is_resizeable.hpp [begin_description] Metafunction to determine if a state type can resized. For usage in the steppers. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011 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_UTIL_IS_RESIZEABLE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_IS_RESIZEABLE_HPP_INCLUDED #include <vector> #include <boost/type_traits/integral_constant.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/fusion/include/front.hpp> #include <boost/fusion/include/is_sequence.hpp> #include <boost/mpl/find_if.hpp> #include <boost/mpl/end.hpp> #include <boost/mpl/placeholders.hpp> #include <boost/mpl/if.hpp> #include <boost/type_traits/is_same.hpp> namespace boost { namespace numeric { namespace odeint { /* * by default any type is not resizable */ template< typename Container , typename Enabler = void > struct is_resizeable_sfinae : boost::false_type {}; template< typename Container > struct is_resizeable : is_resizeable_sfinae< Container > {}; /* * specialization for std::vector */ template< class V, class A > struct is_resizeable< std::vector< V , A > > : boost::true_type {}; /* * sfinae specialization for fusion sequences */ template< typename FusionSequence > struct is_resizeable_sfinae< FusionSequence , typename boost::enable_if< typename boost::fusion::traits::is_sequence< FusionSequence >::type >::type > { typedef typename boost::mpl::find_if< FusionSequence , is_resizeable< boost::mpl::_1 > >::type iter; typedef typename boost::mpl::end< FusionSequence >::type last; typedef typename boost::mpl::if_< boost::is_same< iter , last > , boost::false_type , boost::true_type >::type type; const static bool value = type::value; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_UTIL_IS_RESIZEABLE_HPP_INCLUDED PK 䄟[q�ly� � util/unwrap_reference.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/unwrap_reference.hpp [begin_description] unwrap_reference [end_description] Copyright 2012-2013 Karsten Ahnert Copyright 2012-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_UTIL_UNWRAP_REFERENCE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_UNWRAP_REFERENCE_HPP_INCLUDED #include <boost/numeric/odeint/config.hpp> #if BOOST_NUMERIC_ODEINT_CXX11 #include <functional> #else #include <boost/ref.hpp> #endif namespace boost { #if BOOST_NUMERIC_ODEINT_CXX11 template<typename T> class reference_wrapper; template<typename T> struct unwrap_reference; #endif namespace numeric { namespace odeint { #if BOOST_NUMERIC_ODEINT_CXX11 template<typename T> struct unwrap_reference { typedef typename std::remove_reference<T>::type type; }; template<typename T> struct unwrap_reference< std::reference_wrapper<T> > { typedef typename std::remove_reference<T>::type type; }; template<typename T> struct unwrap_reference< boost::reference_wrapper<T> > { typedef typename boost::unwrap_reference<T>::type type; }; #else using ::boost::unwrap_reference; #endif namespace detail { #if BOOST_NUMERIC_ODEINT_CXX11 using ::std::ref; #else using ::boost::ref; #endif } } } } /* * * the following is the suggested way, but unfortunately it does not work with all compilers. */ /* #include <boost/config.hpp> #ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL #include <boost/ref.hpp> #else #include <functional> #endif namespace boost { namespace numeric { namespace odeint { #ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL template<typename T> struct unwrap_reference { typedef typename std::remove_reference<T>::type type; }; template<typename T> struct unwrap_reference< std::reference_wrapper<T> > { typedef typename std::remove_reference<T>::type type; }; template<typename T> struct unwrap_reference< boost::reference_wrapper<T> > { typedef typename boost::unwrap_reference<T>::type type; }; #else using ::boost::unwrap_reference; #endif } } } namespace boost { namespace numeric { namespace odeint { namespace detail { #ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL using ::std::ref; #else using ::boost::ref; #endif } } } } */ #endif // BOOST_NUMERIC_ODEINT_UTIL_UNWRAP_REFERENCE_HPP_INCLUDED PK 䄟[Q��_J J util/state_wrapper.hppnu �[��� /* [auto_generated] boost/numeric/odeint/util/state_wrapper.hpp [begin_description] State wrapper for the state type in all stepper. The state wrappers are responsible for construction, destruction, copying construction, assignment and resizing. [end_description] Copyright 2011-2012 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_UTIL_STATE_WRAPPER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_UTIL_STATE_WRAPPER_HPP_INCLUDED #include <boost/type_traits/integral_constant.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/util/same_size.hpp> namespace boost { namespace numeric { namespace odeint { template< class V , class Enabler = void > struct state_wrapper { typedef state_wrapper< V > state_wrapper_type; V m_v; }; } } } #endif // BOOST_NUMERIC_ODEINT_UTIL_STATE_WRAPPER_HPP_INCLUDED PK 䄟[�I� � stepper/euler.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/euler.hpp [begin_description] Implementation of the classical explicit Euler stepper. This method is really simple and should only be used for demonstration purposes. [end_description] Copyright 2010-2013 Karsten Ahnert Copyright 2010-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_STEPPER_EULER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_EULER_HPP_INCLUDED #include <boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp> #include <boost/numeric/odeint/util/resizer.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class euler : public explicit_stepper_base< euler< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else class euler : public explicit_stepper_base #endif { public : #ifndef DOXYGEN_SKIP typedef explicit_stepper_base< euler< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; #else typedef explicit_stepper_base< euler< ... > , ... > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; #ifndef DOXYGEN_SKIP typedef typename stepper_base_type::stepper_type stepper_type; typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; #endif euler( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra ) { } template< class System , class StateIn , class DerivIn , class StateOut > void do_step_impl( System /* system */ , const StateIn &in , const DerivIn &dxdt , time_type /* t */ , StateOut &out , time_type dt ) { stepper_base_type::m_algebra.for_each3( out , in , dxdt , typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , dt ) ); } template< class StateOut , class StateIn1 , class StateIn2 > void calc_state( StateOut &x , time_type t , const StateIn1 &old_state , time_type t_old , const StateIn2 & /*current_state*/ , time_type /* t_new */ ) const { const time_type delta = t - t_old; stepper_base_type::m_algebra.for_each3( x , old_state , stepper_base_type::m_dxdt.m_v , typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , delta ) ); } template< class StateType > void adjust_size( const StateType &x ) { stepper_base_type::adjust_size( x ); } }; /********** DOXYGEN ***********/ /** * \class euler * \brief An implementation of the Euler method. * * The Euler method is a very simply solver for ordinary differential equations. This method should not be used * for real applications. It is only useful for demonstration purposes. Step size control is not provided but * trivial continuous output is available. * * This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern), * see explicit_stepper_base * * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn euler::euler( const algebra_type &algebra ) * \brief Constructs the euler class. This constructor can be used as a default * constructor of the algebra has a default constructor. * \param algebra A copy of algebra is made and stored inside explicit_stepper_base. */ /** * \fn euler::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. * The result is updated out of place, hence the input is in `in` and the output in `out`. * Access to this step functionality is provided by explicit_stepper_base and * `do_step_impl` should not be called directly. * * \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 euler::calc_state( StateOut &x , time_type t , const StateIn1 &old_state , time_type t_old , const StateIn2 ¤t_state , time_type t_new ) const * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the * knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`. */ /** * \fn euler::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. */ } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_EULER_HPP_INCLUDED PK 䄟[r���7 �7 + stepper/runge_kutta_cash_karp54_classic.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp [begin_description] Classical implementation of the Runge-Kutta Cash-Karp 5(4) method. [end_description] Copyright 2010-2013 Mario Mulansky Copyright 2010-2013 Karsten Ahnert 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_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/util/state_wrapper.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resizer.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class runge_kutta_cash_karp54_classic : public explicit_error_stepper_base< runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else class runge_kutta_cash_karp54_classic : public explicit_error_stepper_base #endif { public : #ifndef DOXYGEN_SKIP typedef explicit_error_stepper_base< runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; #else typedef explicit_error_stepper_base< runge_kutta_cash_karp54_classic< ... > , ... > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; #ifndef DOXYGEN_SKIP typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; typedef typename stepper_base_type::stepper_type stepper_type; #endif runge_kutta_cash_karp54_classic( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra ) { } template< class System , class StateIn , class DerivIn , class StateOut , class Err > void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr ) { const value_type c1 = static_cast<value_type> ( 37 ) / static_cast<value_type>( 378 ); const value_type c3 = static_cast<value_type> ( 250 ) / static_cast<value_type>( 621 ); const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 594 ); const value_type c6 = static_cast<value_type> ( 512 ) / static_cast<value_type>( 1771 ); const value_type dc1 = c1 - static_cast<value_type> ( 2825 ) / static_cast<value_type>( 27648 ); const value_type dc3 = c3 - static_cast<value_type> ( 18575 ) / static_cast<value_type>( 48384 ); const value_type dc4 = c4 - static_cast<value_type> ( 13525 ) / static_cast<value_type>( 55296 ); const value_type dc5 = static_cast<value_type> ( -277 ) / static_cast<value_type>( 14336 ); const value_type dc6 = c6 - static_cast<value_type> ( 1 ) / static_cast<value_type> ( 4 ); do_step_impl( system , in , dxdt , t , out , dt ); //error estimate stepper_base_type::m_algebra.for_each6( xerr , dxdt , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , typename operations_type::template scale_sum5< time_type , time_type , time_type , time_type , time_type >( dt*dc1 , dt*dc3 , dt*dc4 , dt*dc5 , dt*dc6 )); } template< class System , class StateIn , class DerivIn , class StateOut > void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) { const value_type a2 = static_cast<value_type> ( 1 ) / static_cast<value_type> ( 5 ); const value_type a3 = static_cast<value_type> ( 3 ) / static_cast<value_type> ( 10 ); const value_type a4 = static_cast<value_type> ( 3 ) / static_cast<value_type> ( 5 ); const value_type a5 = static_cast<value_type> ( 1 ); const value_type a6 = static_cast<value_type> ( 7 ) / static_cast<value_type> ( 8 ); const value_type b21 = static_cast<value_type> ( 1 ) / static_cast<value_type> ( 5 ); const value_type b31 = static_cast<value_type> ( 3 ) / static_cast<value_type>( 40 ); const value_type b32 = static_cast<value_type> ( 9 ) / static_cast<value_type>( 40 ); const value_type b41 = static_cast<value_type> ( 3 ) / static_cast<value_type> ( 10 ); const value_type b42 = static_cast<value_type> ( -9 ) / static_cast<value_type> ( 10 ); const value_type b43 = static_cast<value_type> ( 6 ) / static_cast<value_type> ( 5 ); const value_type b51 = static_cast<value_type> ( -11 ) / static_cast<value_type>( 54 ); const value_type b52 = static_cast<value_type> ( 5 ) / static_cast<value_type> ( 2 ); const value_type b53 = static_cast<value_type> ( -70 ) / static_cast<value_type>( 27 ); const value_type b54 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 27 ); const value_type b61 = static_cast<value_type> ( 1631 ) / static_cast<value_type>( 55296 ); const value_type b62 = static_cast<value_type> ( 175 ) / static_cast<value_type>( 512 ); const value_type b63 = static_cast<value_type> ( 575 ) / static_cast<value_type>( 13824 ); const value_type b64 = static_cast<value_type> ( 44275 ) / static_cast<value_type>( 110592 ); const value_type b65 = static_cast<value_type> ( 253 ) / static_cast<value_type>( 4096 ); const value_type c1 = static_cast<value_type> ( 37 ) / static_cast<value_type>( 378 ); const value_type c3 = static_cast<value_type> ( 250 ) / static_cast<value_type>( 621 ); const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 594 ); const value_type c6 = static_cast<value_type> ( 512 ) / static_cast<value_type>( 1771 ); typename odeint::unwrap_reference< System >::type &sys = system; m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ); //m_x1 = x + dt*b21*dxdt stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , dxdt , typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , dt*b21 ) ); sys( m_x_tmp.m_v , m_k2.m_v , t + dt*a2 ); // m_x_tmp = x + dt*b31*dxdt + dt*b32*m_x2 stepper_base_type::m_algebra.for_each4( m_x_tmp.m_v , in , dxdt , m_k2.m_v , typename operations_type::template scale_sum3< value_type , time_type , time_type >( 1.0 , dt*b31 , dt*b32 )); sys( m_x_tmp.m_v , m_k3.m_v , t + dt*a3 ); // m_x_tmp = x + dt * (b41*dxdt + b42*m_x2 + b43*m_x3) stepper_base_type::m_algebra.for_each5( m_x_tmp.m_v , in , dxdt , m_k2.m_v , m_k3.m_v , typename operations_type::template scale_sum4< value_type , time_type , time_type , time_type >( 1.0 , dt*b41 , dt*b42 , dt*b43 )); sys( m_x_tmp.m_v, m_k4.m_v , t + dt*a4 ); stepper_base_type::m_algebra.for_each6( m_x_tmp.m_v , in , dxdt , m_k2.m_v , m_k3.m_v , m_k4.m_v , typename operations_type::template scale_sum5< value_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b51 , dt*b52 , dt*b53 , dt*b54 )); sys( m_x_tmp.m_v , m_k5.m_v , t + dt*a5 ); stepper_base_type::m_algebra.for_each7( m_x_tmp.m_v , in , dxdt , m_k2.m_v , m_k3.m_v , m_k4.m_v , m_k5.m_v , typename operations_type::template scale_sum6< value_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b61 , dt*b62 , dt*b63 , dt*b64 , dt*b65 )); sys( m_x_tmp.m_v , m_k6.m_v , t + dt*a6 ); stepper_base_type::m_algebra.for_each6( out , in , dxdt , m_k3.m_v , m_k4.m_v , m_k6.m_v , typename operations_type::template scale_sum5< value_type , time_type , time_type , time_type , time_type >( 1.0 , dt*c1 , dt*c3 , dt*c4 , dt*c6 )); } /** * \brief Adjust the size of all temporaries in the stepper manually. * \param x A state from which the size of the temporaries to be resized is deduced. */ template< class StateIn > void adjust_size( const StateIn &x ) { resize_impl( x ); stepper_base_type::adjust_size( x ); } private: template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_k2 , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_k3 , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_k4 , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_k5 , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_k6 , x , typename is_resizeable<deriv_type>::type() ); return resized; } wrapped_state_type m_x_tmp; wrapped_deriv_type m_k2, m_k3, m_k4, m_k5, m_k6; resizer_type m_resizer; }; /************ DOXYGEN *************/ /** * \class runge_kutta_cash_karp54_classic * \brief The Runge-Kutta Cash-Karp method implemented without the generic Runge-Kutta algorithm. * * The Runge-Kutta Cash-Karp method is one of the standard methods for * solving ordinary differential equations, see * <a href="http://en.wikipedia.org/wiki/Cash%E2%80%93Karp_method">en.wikipedia.org/wiki/Cash-Karp_method</a>. * The method is explicit and fulfills the Error Stepper concept. Step size control * is provided but continuous output is not available for this method. * * This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring * template pattern). This class implements the method directly, hence the generic Runge-Kutta algorithm is not used. * * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn runge_kutta_cash_karp54_classic::runge_kutta_cash_karp54_classic( const algebra_type &algebra ) * \brief Constructs the runge_kutta_cash_karp54_classic class. This constructor can be used as a default * constructor if the algebra has a default constructor. * \param algebra A copy of algebra is made and stored inside explicit_stepper_base. */ /** * \fn runge_kutta_cash_karp54_classic::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr ) * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. * * The result is updated out-of-place, hence the input is in `in` and the output in `out`. Futhermore, an * estimation of the error is stored in `xerr`. * Access to this step functionality is provided by explicit_error_stepper_base and * `do_step_impl` should not be called directly. * * \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 result of the error estimation is written in xerr. */ /** * \fn runge_kutta_cash_karp54_classic::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. * The result is updated out-of-place, hence the input is in `in` and the output in `out`. * Access to this step functionality is provided by explicit_error_stepper_base and * `do_step_impl` should not be called directly. * * \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. */ } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED PK 䄟[��o�! �! # stepper/runge_kutta_cash_karp54.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp [begin_description] Implementation of the Runge Kutta Cash Karp 5(4) method. It uses the generic error stepper. [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED #include <boost/fusion/container/vector.hpp> #include <boost/fusion/container/generation/make_vector.hpp> #include <boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.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/array.hpp> namespace boost { namespace numeric { namespace odeint { #ifndef DOXYGEN_SKIP template< class Value = double > struct rk54_ck_coefficients_a1 : boost::array< Value , 1 > { rk54_ck_coefficients_a1( void ) { (*this)[0] = static_cast< Value >( 1 )/static_cast< Value >( 5 ); } }; template< class Value = double > struct rk54_ck_coefficients_a2 : boost::array< Value , 2 > { rk54_ck_coefficients_a2( void ) { (*this)[0] = static_cast<Value>( 3 )/static_cast<Value>( 40 ); (*this)[1] = static_cast<Value>( 9 )/static_cast<Value>( 40 ); } }; template< class Value = double > struct rk54_ck_coefficients_a3 : boost::array< Value , 3 > { rk54_ck_coefficients_a3( void ) { (*this)[0] = static_cast<Value>( 3 )/static_cast<Value>( 10 ); (*this)[1] = static_cast<Value>( -9 )/static_cast<Value>( 10 ); (*this)[2] = static_cast<Value>( 6 )/static_cast<Value>( 5 ); } }; template< class Value = double > struct rk54_ck_coefficients_a4 : boost::array< Value , 4 > { rk54_ck_coefficients_a4( void ) { (*this)[0] = static_cast<Value>( -11 )/static_cast<Value>( 54 ); (*this)[1] = static_cast<Value>( 5 )/static_cast<Value>( 2 ); (*this)[2] = static_cast<Value>( -70 )/static_cast<Value>( 27 ); (*this)[3] = static_cast<Value>( 35 )/static_cast<Value>( 27 ); } }; template< class Value = double > struct rk54_ck_coefficients_a5 : boost::array< Value , 5 > { rk54_ck_coefficients_a5( void ) { (*this)[0] = static_cast<Value>( 1631 )/static_cast<Value>( 55296 ); (*this)[1] = static_cast<Value>( 175 )/static_cast<Value>( 512 ); (*this)[2] = static_cast<Value>( 575 )/static_cast<Value>( 13824 ); (*this)[3] = static_cast<Value>( 44275 )/static_cast<Value>( 110592 ); (*this)[4] = static_cast<Value>( 253 )/static_cast<Value>( 4096 ); } }; template< class Value = double > struct rk54_ck_coefficients_b : boost::array< Value , 6 > { rk54_ck_coefficients_b( void ) { (*this)[0] = static_cast<Value>( 37 )/static_cast<Value>( 378 ); (*this)[1] = static_cast<Value>( 0 ); (*this)[2] = static_cast<Value>( 250 )/static_cast<Value>( 621 ); (*this)[3] = static_cast<Value>( 125 )/static_cast<Value>( 594 ); (*this)[4] = static_cast<Value>( 0 ); (*this)[5] = static_cast<Value>( 512 )/static_cast<Value>( 1771 ); } }; template< class Value = double > struct rk54_ck_coefficients_db : boost::array< Value , 6 > { rk54_ck_coefficients_db( void ) { (*this)[0] = static_cast<Value>( 37 )/static_cast<Value>( 378 ) - static_cast<Value>( 2825 )/static_cast<Value>( 27648 ); (*this)[1] = static_cast<Value>( 0 ); (*this)[2] = static_cast<Value>( 250 )/static_cast<Value>( 621 ) - static_cast<Value>( 18575 )/static_cast<Value>( 48384 ); (*this)[3] = static_cast<Value>( 125 )/static_cast<Value>( 594 ) - static_cast<Value>( 13525 )/static_cast<Value>( 55296 ); (*this)[4] = static_cast<Value>( -277 )/static_cast<Value>( 14336 ); (*this)[5] = static_cast<Value>( 512 )/static_cast<Value>( 1771 ) - static_cast<Value>( 1 )/static_cast<Value>( 4 ); } }; template< class Value = double > struct rk54_ck_coefficients_c : boost::array< Value , 6 > { rk54_ck_coefficients_c( void ) { (*this)[0] = static_cast<Value>(0); (*this)[1] = static_cast<Value>( 1 )/static_cast<Value>( 5 ); (*this)[2] = static_cast<Value>( 3 )/static_cast<Value>( 10 ); (*this)[3] = static_cast<Value>( 3 )/static_cast<Value>( 5 ); (*this)[4] = static_cast<Value>( 1 ); (*this)[5] = static_cast<Value>( 7 )/static_cast<Value>( 8 ); } }; #endif template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class runge_kutta_cash_karp54 : public explicit_error_generic_rk< 6 , 5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else class runge_kutta_cash_karp54 : public explicit_error_generic_rk #endif { public: #ifndef DOXYGEN_SKIP typedef explicit_error_generic_rk< 6 , 5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_typ; #ifndef DOXYGEN_SKIP typedef typename stepper_base_type::stepper_type stepper_type; typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; #endif runge_kutta_cash_karp54( const algebra_type &algebra = algebra_type() ) : stepper_base_type( boost::fusion::make_vector( rk54_ck_coefficients_a1<Value>() , rk54_ck_coefficients_a2<Value>() , rk54_ck_coefficients_a3<Value>() , rk54_ck_coefficients_a4<Value>() , rk54_ck_coefficients_a5<Value>() ) , rk54_ck_coefficients_b<Value>() , rk54_ck_coefficients_db<Value>() , rk54_ck_coefficients_c<Value>() , algebra ) { } }; /********** DOXYGEN **********/ /** * \class runge_kutta_cash_karp54 * \brief The Runge-Kutta Cash-Karp method. * * The Runge-Kutta Cash-Karp method is one of the standard methods for * solving ordinary differential equations, see * <a href="http://en.wikipedia.org/wiki/Cash%E2%80%93Karp_methods">en.wikipedia.org/wiki/Cash-Karp_methods</a>. * The method is explicit and fulfills the Error Stepper concept. Step size control * is provided but continuous output is not available for this method. * * This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern). * Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation. * For more details see explicit_error_stepper_base and explicit_error_generic_rk. * * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn runge_kutta_cash_karp54::runge_kutta_cash_karp54( const algebra_type &algebra ) * \brief Constructs the runge_kutta_cash_karp54 class. This constructor can be used as a default * constructor if the algebra has a default constructor. * \param algebra A copy of algebra is made and stored inside explicit_stepper_base. */ } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED PK 䄟[�c���. �. # stepper/adams_bashforth_moulton.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp [begin_description] Implementation of the Adams-Bashforth-Moulton method, a predictor-corrector multistep method. [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_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/util/state_wrapper.hpp> #include <boost/numeric/odeint/util/resizer.hpp> #include <boost/numeric/odeint/stepper/adams_bashforth.hpp> #include <boost/numeric/odeint/stepper/adams_moulton.hpp> namespace boost { namespace numeric { namespace odeint { template< size_t Steps , class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer, class InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer > > class adams_bashforth_moulton { #ifndef DOXYGEN_SKIP BOOST_STATIC_ASSERT(( Steps > 0 )); BOOST_STATIC_ASSERT(( Steps < 9 )); #endif public : typedef State state_type; typedef state_wrapper< state_type > wrapped_state_type; typedef Value value_type; typedef Deriv deriv_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef Time time_type; typedef Algebra algebra_type; typedef Operations operations_type; typedef Resizer resizer_type; typedef stepper_tag stepper_category; typedef InitializingStepper initializing_stepper_type; static const size_t steps = Steps; #ifndef DOXYGEN_SKIP typedef adams_bashforth< steps , state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type, initializing_stepper_type > adams_bashforth_type; typedef adams_moulton< steps , state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type > adams_moulton_type; typedef adams_bashforth_moulton< steps , state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type , initializing_stepper_type> stepper_type; #endif //DOXYGEN_SKIP typedef unsigned short order_type; static const order_type order_value = steps; /** \brief Constructs the adams_bashforth class. */ adams_bashforth_moulton( void ) : m_adams_bashforth() , m_adams_moulton( m_adams_bashforth.algebra() ) , m_x() , m_resizer() { } adams_bashforth_moulton( const algebra_type &algebra ) : m_adams_bashforth( algebra ) , m_adams_moulton( m_adams_bashforth.algebra() ) , m_x() , m_resizer() { } order_type order( void ) const { return order_value; } template< class System , class StateInOut > void do_step( System system , StateInOut &x , time_type t , time_type dt ) { do_step_impl1( 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_impl1( system , x , t , dt ); } template< class System , class StateIn , class StateOut > void do_step( System system , const StateIn &in , time_type t , const StateOut &out , time_type dt ) { do_step_impl2( system , in , t , out , dt ); } /** * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateOut. */ template< class System , class StateIn , class StateOut > void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt ) { do_step_impl2( system , in ,t , out , dt ); } template< class StateType > void adjust_size( const StateType &x ) { m_adams_bashforth.adjust_size( x ); m_adams_moulton.adjust_size( x ); resize_impl( x ); } template< class ExplicitStepper , class System , class StateIn > void initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt ) { m_adams_bashforth.initialize( explicit_stepper , system , x , t , dt ); } template< class System , class StateIn > void initialize( System system , StateIn &x , time_type &t , time_type dt ) { m_adams_bashforth.initialize( system , x , t , dt ); } void reset(void) { m_adams_bashforth.reset(); } private: template< typename System , typename StateInOut > void do_step_impl1( System system , StateInOut &x , time_type t , time_type dt ) { if( m_adams_bashforth.is_initialized() ) { m_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ); m_adams_bashforth.do_step( system , x , t , m_x.m_v , dt ); m_adams_moulton.do_step( system , x , m_x.m_v , t+dt , x , dt , m_adams_bashforth.step_storage() ); } else { m_adams_bashforth.do_step( system , x , t , dt ); } } template< typename System , typename StateIn , typename StateInOut > void do_step_impl2( System system , StateIn const &in , time_type t , StateInOut & out , time_type dt ) { if( m_adams_bashforth.is_initialized() ) { m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ); m_adams_bashforth.do_step( system , in , t , m_x.m_v , dt ); m_adams_moulton.do_step( system , in , m_x.m_v , t+dt , out , dt , m_adams_bashforth.step_storage() ); } else { m_adams_bashforth.do_step( system , in , t , out , dt ); } } template< class StateIn > bool resize_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_x , x , typename is_resizeable< state_type >::type() ); } adams_bashforth_type m_adams_bashforth; adams_moulton_type m_adams_moulton; wrapped_state_type m_x; resizer_type m_resizer; }; /********* DOXYGEN ********/ /** * \class adams_bashforth_moulton * \brief The Adams-Bashforth-Moulton multistep algorithm. * * The Adams-Bashforth method is a multi-step predictor-corrector algorithm * with configurable step number. The step number is specified as template * parameter Steps and it then uses the result from the previous Steps steps. * See also * <a href="http://en.wikipedia.org/wiki/Linear_multistep_method">en.wikipedia.org/wiki/Linear_multistep_method</a>. * Currently, a maximum of Steps=8 is supported. * The method is explicit and fulfills the Stepper concept. Step size control * or continuous output are not provided. * * This class derives from algebra_base and inherits its interface via * CRTP (current recurring template pattern). For more details see * algebra_stepper_base. * * \tparam Steps The number of steps (maximal 8). * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. * \tparam InitializingStepper The stepper for the first two steps. */ /** * \fn adams_bashforth_moulton::adams_bashforth_moulton( const algebra_type &algebra ) * \brief Constructs the adams_bashforth 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. */ /** * \fn adams_bashforth_moulton::order( void ) const * \brief Returns the order of the algorithm, which is equal to the number of steps+1. * \return order of the method. */ /** * \fn adams_bashforth_moulton::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 adams_bashforth_moulton::do_step( System system , const StateIn &in , time_type t , const 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. * * \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 adams_bashforth_moulton::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. */ /** * \fn adams_bashforth_moulton::initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt ) * \brief Initialized the stepper. Does Steps-1 steps with the explicit_stepper to fill the buffer. * \note The state x and time t are updated to the values after Steps-1 initial steps. * \param explicit_stepper the stepper used to fill the buffer of previous step results * \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 initial state of the ODE which should be solved, updated after in this method. * \param t The initial time, updated in this method. * \param dt The step size. */ /** * \fn adams_bashforth_moulton::initialize( System system , StateIn &x , time_type &t , time_type dt ) * \brief Initialized the stepper. Does Steps-1 steps using the standard initializing stepper * of the underlying adams_bashforth 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 adams_bashforth_moulton::reset( void ) * \brief Resets the internal buffers of the stepper. */ } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED PK 䄟[��1�r r stepper/stepper_categories.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/stepper_categories.hpp [begin_description] Definition of all stepper categories. [end_description] Copyright 2010-2011 Mario Mulansky Copyright 2010-2012 Karsten Ahnert 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_STEPPER_CATEGORIES_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_STEPPER_CATEGORIES_HPP_INCLUDED #include <boost/type_traits/integral_constant.hpp> namespace boost { namespace numeric { namespace odeint { /* * Tags to specify stepper types * * These tags are used by integrate() to choose which integration method is used */ struct stepper_tag {}; // struct explicit_stepper_tag : stepper_tag {}; // struct implicit_stepper_tag : stepper_tag {}; struct error_stepper_tag : stepper_tag {}; struct explicit_error_stepper_tag : error_stepper_tag {}; struct explicit_error_stepper_fsal_tag : error_stepper_tag {}; struct controlled_stepper_tag {}; struct explicit_controlled_stepper_tag : controlled_stepper_tag {}; struct explicit_controlled_stepper_fsal_tag : controlled_stepper_tag {}; struct dense_output_stepper_tag {}; template< class tag > struct base_tag ; template< > struct base_tag< stepper_tag > { typedef stepper_tag type; }; template< > struct base_tag< error_stepper_tag > { typedef stepper_tag type; }; template< > struct base_tag< explicit_error_stepper_tag > { typedef stepper_tag type; }; template< > struct base_tag< explicit_error_stepper_fsal_tag > { typedef stepper_tag type; }; template< > struct base_tag< controlled_stepper_tag > { typedef controlled_stepper_tag type; }; template< > struct base_tag< explicit_controlled_stepper_tag > { typedef controlled_stepper_tag type; }; template< > struct base_tag< explicit_controlled_stepper_fsal_tag > { typedef controlled_stepper_tag type; }; template< > struct base_tag< dense_output_stepper_tag > { typedef dense_output_stepper_tag type; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_STEPPER_CATEGORIES_HPP_INCLUDED PK 䄟[6�g# 9 9 stepper/rosenbrock4.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/rosenbrock4.hpp [begin_description] Implementation of the Rosenbrock 4 method for solving stiff ODEs. Note, that a controller and a dense-output stepper exist for this method, [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-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_ROSENBROCK4_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_HPP_INCLUDED #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/ublas/vector.hpp> #include <boost/numeric/ublas/matrix.hpp> #include <boost/numeric/ublas/lu.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/util/ublas_wrapper.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resizer.hpp> #include <boost/numeric/ublas/vector.hpp> #include <boost/numeric/ublas/matrix.hpp> #include <boost/numeric/ublas/lu.hpp> namespace boost { namespace numeric { namespace odeint { /* * ToDo: * * 2. Interfacing for odeint, check if controlled_error_stepper can be used * 3. dense output */ template< class Value > struct default_rosenbrock_coefficients { typedef Value value_type; typedef unsigned short order_type; default_rosenbrock_coefficients( void ) : gamma ( static_cast< value_type >( 0.25 ) ) , d1 ( static_cast< value_type >( 0.25 ) ) , d2 ( static_cast< value_type >( -0.1043 ) ) , d3 ( static_cast< value_type >( 0.1035 ) ) , d4 ( static_cast< value_type >( 0.3620000000000023e-01 ) ) , c2 ( static_cast< value_type >( 0.386 ) ) , c3 ( static_cast< value_type >( 0.21 ) ) , c4 ( static_cast< value_type >( 0.63 ) ) , c21 ( static_cast< value_type >( -0.5668800000000000e+01 ) ) , a21 ( static_cast< value_type >( 0.1544000000000000e+01 ) ) , c31 ( static_cast< value_type >( -0.2430093356833875e+01 ) ) , c32 ( static_cast< value_type >( -0.2063599157091915e+00 ) ) , a31 ( static_cast< value_type >( 0.9466785280815826e+00 ) ) , a32 ( static_cast< value_type >( 0.2557011698983284e+00 ) ) , c41 ( static_cast< value_type >( -0.1073529058151375e+00 ) ) , c42 ( static_cast< value_type >( -0.9594562251023355e+01 ) ) , c43 ( static_cast< value_type >( -0.2047028614809616e+02 ) ) , a41 ( static_cast< value_type >( 0.3314825187068521e+01 ) ) , a42 ( static_cast< value_type >( 0.2896124015972201e+01 ) ) , a43 ( static_cast< value_type >( 0.9986419139977817e+00 ) ) , c51 ( static_cast< value_type >( 0.7496443313967647e+01 ) ) , c52 ( static_cast< value_type >( -0.1024680431464352e+02 ) ) , c53 ( static_cast< value_type >( -0.3399990352819905e+02 ) ) , c54 ( static_cast< value_type >( 0.1170890893206160e+02 ) ) , a51 ( static_cast< value_type >( 0.1221224509226641e+01 ) ) , a52 ( static_cast< value_type >( 0.6019134481288629e+01 ) ) , a53 ( static_cast< value_type >( 0.1253708332932087e+02 ) ) , a54 ( static_cast< value_type >( -0.6878860361058950e+00 ) ) , c61 ( static_cast< value_type >( 0.8083246795921522e+01 ) ) , c62 ( static_cast< value_type >( -0.7981132988064893e+01 ) ) , c63 ( static_cast< value_type >( -0.3152159432874371e+02 ) ) , c64 ( static_cast< value_type >( 0.1631930543123136e+02 ) ) , c65 ( static_cast< value_type >( -0.6058818238834054e+01 ) ) , d21 ( static_cast< value_type >( 0.1012623508344586e+02 ) ) , d22 ( static_cast< value_type >( -0.7487995877610167e+01 ) ) , d23 ( static_cast< value_type >( -0.3480091861555747e+02 ) ) , d24 ( static_cast< value_type >( -0.7992771707568823e+01 ) ) , d25 ( static_cast< value_type >( 0.1025137723295662e+01 ) ) , d31 ( static_cast< value_type >( -0.6762803392801253e+00 ) ) , d32 ( static_cast< value_type >( 0.6087714651680015e+01 ) ) , d33 ( static_cast< value_type >( 0.1643084320892478e+02 ) ) , d34 ( static_cast< value_type >( 0.2476722511418386e+02 ) ) , d35 ( static_cast< value_type >( -0.6594389125716872e+01 ) ) {} const value_type gamma; const value_type d1 , d2 , d3 , d4; const value_type c2 , c3 , c4; const value_type c21 ; const value_type a21; const value_type c31 , c32; const value_type a31 , a32; const value_type c41 , c42 , c43; const value_type a41 , a42 , a43; const value_type c51 , c52 , c53 , c54; const value_type a51 , a52 , a53 , a54; const value_type c61 , c62 , c63 , c64 , c65; const value_type d21 , d22 , d23 , d24 , d25; const value_type d31 , d32 , d33 , d34 , d35; static const order_type stepper_order = 4; static const order_type error_order = 3; }; template< class Value , class Coefficients = default_rosenbrock_coefficients< Value > , class Resizer = initially_resizer > class rosenbrock4 { private: public: typedef Value value_type; typedef boost::numeric::ublas::vector< value_type > state_type; typedef state_type deriv_type; typedef value_type time_type; typedef boost::numeric::ublas::matrix< value_type > matrix_type; typedef boost::numeric::ublas::permutation_matrix< size_t > pmatrix_type; typedef Resizer resizer_type; typedef Coefficients rosenbrock_coefficients; typedef stepper_tag stepper_category; typedef unsigned short order_type; typedef state_wrapper< state_type > wrapped_state_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef state_wrapper< matrix_type > wrapped_matrix_type; typedef state_wrapper< pmatrix_type > wrapped_pmatrix_type; typedef rosenbrock4< Value , Coefficients , Resizer > stepper_type; const static order_type stepper_order = rosenbrock_coefficients::stepper_order; const static order_type error_order = rosenbrock_coefficients::error_order; rosenbrock4( void ) : m_resizer() , m_x_err_resizer() , m_jac() , m_pm() , m_dfdt() , m_dxdt() , m_dxdtnew() , m_g1() , m_g2() , m_g3() , m_g4() , m_g5() , m_cont3() , m_cont4() , m_xtmp() , m_x_err() , m_coef() { } order_type order() const { return stepper_order; } template< class System > void do_step( System system , const state_type &x , time_type t , state_type &xout , time_type dt , state_type &xerr ) { // get the system and jacobi function typedef typename odeint::unwrap_reference< System >::type system_type; typedef typename odeint::unwrap_reference< typename system_type::first_type >::type deriv_func_type; typedef typename odeint::unwrap_reference< typename system_type::second_type >::type jacobi_func_type; system_type &sys = system; deriv_func_type &deriv_func = sys.first; jacobi_func_type &jacobi_func = sys.second; const size_t n = x.size(); m_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_impl<state_type> , detail::ref( *this ) , detail::_1 ) ); for( size_t i=0 ; i<n ; ++i ) m_pm.m_v( i ) = i; deriv_func( x , m_dxdt.m_v , t ); jacobi_func( x , m_jac.m_v , t , m_dfdt.m_v ); m_jac.m_v *= -1.0; m_jac.m_v += 1.0 / m_coef.gamma / dt * boost::numeric::ublas::identity_matrix< value_type >( n ); boost::numeric::ublas::lu_factorize( m_jac.m_v , m_pm.m_v ); for( size_t i=0 ; i<n ; ++i ) m_g1.m_v[i] = m_dxdt.m_v[i] + dt * m_coef.d1 * m_dfdt.m_v[i]; boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g1.m_v ); for( size_t i=0 ; i<n ; ++i ) m_xtmp.m_v[i] = x[i] + m_coef.a21 * m_g1.m_v[i]; deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + m_coef.c2 * dt ); for( size_t i=0 ; i<n ; ++i ) m_g2.m_v[i] = m_dxdtnew.m_v[i] + dt * m_coef.d2 * m_dfdt.m_v[i] + m_coef.c21 * m_g1.m_v[i] / dt; boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g2.m_v ); for( size_t i=0 ; i<n ; ++i ) m_xtmp.m_v[i] = x[i] + m_coef.a31 * m_g1.m_v[i] + m_coef.a32 * m_g2.m_v[i]; deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + m_coef.c3 * dt ); for( size_t i=0 ; i<n ; ++i ) m_g3.m_v[i] = m_dxdtnew.m_v[i] + dt * m_coef.d3 * m_dfdt.m_v[i] + ( m_coef.c31 * m_g1.m_v[i] + m_coef.c32 * m_g2.m_v[i] ) / dt; boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g3.m_v ); for( size_t i=0 ; i<n ; ++i ) m_xtmp.m_v[i] = x[i] + m_coef.a41 * m_g1.m_v[i] + m_coef.a42 * m_g2.m_v[i] + m_coef.a43 * m_g3.m_v[i]; deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + m_coef.c4 * dt ); for( size_t i=0 ; i<n ; ++i ) m_g4.m_v[i] = m_dxdtnew.m_v[i] + dt * m_coef.d4 * m_dfdt.m_v[i] + ( m_coef.c41 * m_g1.m_v[i] + m_coef.c42 * m_g2.m_v[i] + m_coef.c43 * m_g3.m_v[i] ) / dt; boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g4.m_v ); for( size_t i=0 ; i<n ; ++i ) m_xtmp.m_v[i] = x[i] + m_coef.a51 * m_g1.m_v[i] + m_coef.a52 * m_g2.m_v[i] + m_coef.a53 * m_g3.m_v[i] + m_coef.a54 * m_g4.m_v[i]; deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + dt ); for( size_t i=0 ; i<n ; ++i ) m_g5.m_v[i] = m_dxdtnew.m_v[i] + ( m_coef.c51 * m_g1.m_v[i] + m_coef.c52 * m_g2.m_v[i] + m_coef.c53 * m_g3.m_v[i] + m_coef.c54 * m_g4.m_v[i] ) / dt; boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g5.m_v ); for( size_t i=0 ; i<n ; ++i ) m_xtmp.m_v[i] += m_g5.m_v[i]; deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + dt ); for( size_t i=0 ; i<n ; ++i ) xerr[i] = m_dxdtnew.m_v[i] + ( m_coef.c61 * m_g1.m_v[i] + m_coef.c62 * m_g2.m_v[i] + m_coef.c63 * m_g3.m_v[i] + m_coef.c64 * m_g4.m_v[i] + m_coef.c65 * m_g5.m_v[i] ) / dt; boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , xerr ); for( size_t i=0 ; i<n ; ++i ) xout[i] = m_xtmp.m_v[i] + xerr[i]; } template< class System > void do_step( System system , state_type &x , time_type t , time_type dt , state_type &xerr ) { do_step( system , x , t , x , dt , xerr ); } /* * do_step without error output - just calls above functions with and neglects the error estimate */ template< class System > void do_step( System system , const state_type &x , time_type t , state_type &xout , time_type dt ) { m_x_err_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_x_err<state_type> , detail::ref( *this ) , detail::_1 ) ); do_step( system , x , t , xout , dt , m_x_err.m_v ); } template< class System > void do_step( System system , state_type &x , time_type t , time_type dt ) { m_x_err_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_x_err<state_type> , detail::ref( *this ) , detail::_1 ) ); do_step( system , x , t , dt , m_x_err.m_v ); } void prepare_dense_output() { const size_t n = m_g1.m_v.size(); for( size_t i=0 ; i<n ; ++i ) { m_cont3.m_v[i] = m_coef.d21 * m_g1.m_v[i] + m_coef.d22 * m_g2.m_v[i] + m_coef.d23 * m_g3.m_v[i] + m_coef.d24 * m_g4.m_v[i] + m_coef.d25 * m_g5.m_v[i]; m_cont4.m_v[i] = m_coef.d31 * m_g1.m_v[i] + m_coef.d32 * m_g2.m_v[i] + m_coef.d33 * m_g3.m_v[i] + m_coef.d34 * m_g4.m_v[i] + m_coef.d35 * m_g5.m_v[i]; } } void calc_state( time_type t , state_type &x , const state_type &x_old , time_type t_old , const state_type &x_new , time_type t_new ) { const size_t n = m_g1.m_v.size(); time_type dt = t_new - t_old; time_type s = ( t - t_old ) / dt; time_type s1 = 1.0 - s; for( size_t i=0 ; i<n ; ++i ) x[i] = x_old[i] * s1 + s * ( x_new[i] + s1 * ( m_cont3.m_v[i] + s * m_cont4.m_v[i] ) ); } template< class StateType > void adjust_size( const StateType &x ) { resize_impl( x ); resize_x_err( x ); } protected: template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_dfdt , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_dxdtnew , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_xtmp , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_g1 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_g2 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_g3 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_g4 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_g5 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_cont3 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_cont4 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_jac , x , typename is_resizeable<matrix_type>::type() ); resized |= adjust_size_by_resizeability( m_pm , x , typename is_resizeable<pmatrix_type>::type() ); return resized; } template< class StateIn > bool resize_x_err( const StateIn &x ) { return adjust_size_by_resizeability( m_x_err , x , typename is_resizeable<state_type>::type() ); } private: resizer_type m_resizer; resizer_type m_x_err_resizer; wrapped_matrix_type m_jac; wrapped_pmatrix_type m_pm; wrapped_deriv_type m_dfdt , m_dxdt , m_dxdtnew; wrapped_state_type m_g1 , m_g2 , m_g3 , m_g4 , m_g5; wrapped_state_type m_cont3 , m_cont4; wrapped_state_type m_xtmp; wrapped_state_type m_x_err; const rosenbrock_coefficients m_coef; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_HPP_INCLUDED PK 䄟[�����4 �4 stepper/velocity_verlet.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/velocity_verlet.hpp [begin_description] tba. [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_VELOCITY_VERLET_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_STEPPER_VELOCITY_VERLET_HPP_DEFINED #include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/util/resizer.hpp> #include <boost/numeric/odeint/util/state_wrapper.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/util/copy.hpp> #include <boost/numeric/odeint/util/resizer.hpp> // #include <boost/numeric/odeint/util/is_pair.hpp> // #include <boost/array.hpp> namespace boost { namespace numeric { namespace odeint { template < class Coor , class Velocity = Coor , class Value = double , class Acceleration = Coor , class Time = Value , class TimeSq = Time , class Algebra = typename algebra_dispatcher< Coor >::algebra_type , class Operations = typename operations_dispatcher< Coor >::operations_type , class Resizer = initially_resizer > class velocity_verlet : 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; typedef Coor coor_type; typedef Velocity velocity_type; typedef Acceleration acceleration_type; typedef std::pair< coor_type , velocity_type > state_type; typedef std::pair< velocity_type , acceleration_type > deriv_type; typedef state_wrapper< acceleration_type > wrapped_acceleration_type; typedef Value value_type; typedef Time time_type; typedef TimeSq time_square_type; typedef Resizer resizer_type; typedef stepper_tag stepper_category; typedef unsigned short order_type; static const order_type order_value = 1; /** * \return Returns the order of the stepper. */ order_type order( void ) const { return order_value; } velocity_verlet( const algebra_type & algebra = algebra_type() ) : algebra_stepper_base_type( algebra ) , m_first_call( true ) , m_a1() , m_a2() , m_current_a1( true ) { } 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 ); } 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 ); } template< class System , class CoorIn , class VelocityIn , class AccelerationIn , class CoorOut , class VelocityOut , class AccelerationOut > void do_step( System system , CoorIn const & qin , VelocityIn const & pin , AccelerationIn const & ain , CoorOut & qout , VelocityOut & pout , AccelerationOut & aout , time_type t , time_type dt ) { const value_type one = static_cast< value_type >( 1.0 ); const value_type one_half = static_cast< value_type >( 0.5 ); algebra_stepper_base_type::m_algebra.for_each4( qout , qin , pin , ain , typename operations_type::template scale_sum3< value_type , time_type , time_square_type >( one , one * dt , one_half * dt * dt ) ); typename odeint::unwrap_reference< System >::type & sys = system; sys( qout , pin , aout , t + dt ); algebra_stepper_base_type::m_algebra.for_each4( pout , pin , ain , aout , typename operations_type::template scale_sum3< value_type , time_type , time_type >( one , one_half * dt , one_half * dt ) ); } template< class StateIn > void adjust_size( const StateIn & x ) { if( resize_impl( x ) ) m_first_call = true; } void reset( void ) { m_first_call = true; } /** * \fn velocity_verlet::initialize( const AccelerationIn &qin ) * \brief Initializes the internal state of the stepper. * \param deriv The acceleration of x. The next call of `do_step` expects that the acceleration of `x` passed to `do_step` * has the value of `qin`. */ template< class AccelerationIn > void initialize( const AccelerationIn & ain ) { // alloc a m_resizer.adjust_size( ain , detail::bind( &velocity_verlet::template resize_impl< AccelerationIn > , detail::ref( *this ) , detail::_1 ) ); boost::numeric::odeint::copy( ain , get_current_acc() ); m_first_call = false; } template< class System , class CoorIn , class VelocityIn > void initialize( System system , const CoorIn & qin , const VelocityIn & pin , time_type t ) { m_resizer.adjust_size( qin , detail::bind( &velocity_verlet::template resize_impl< CoorIn > , detail::ref( *this ) , detail::_1 ) ); initialize_acc( system , qin , pin , t ); } bool is_initialized( void ) const { return ! m_first_call; } private: template< class System , class CoorIn , class VelocityIn > void initialize_acc( System system , const CoorIn & qin , const VelocityIn & pin , time_type t ) { typename odeint::unwrap_reference< System >::type & sys = system; sys( qin , pin , get_current_acc() , t ); m_first_call = false; } template< class System , class StateInOut > void do_step_v1( System system , StateInOut & x , time_type t , time_type dt ) { typedef typename odeint::unwrap_reference< StateInOut >::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; typedef typename boost::remove_reference< coor_in_type >::type xyz_type; state_in_type & statein = x; coor_in_type & qinout = statein.first; momentum_in_type & pinout = statein.second; // alloc a if( m_resizer.adjust_size( qinout , detail::bind( &velocity_verlet::template resize_impl< xyz_type > , detail::ref( *this ) , detail::_1 ) ) || m_first_call ) { initialize_acc( system , qinout , pinout , t ); } // check first do_step( system , qinout , pinout , get_current_acc() , qinout , pinout , get_old_acc() , t , dt ); toggle_current_acc(); } template< class StateIn > bool resize_impl( const StateIn & x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_a1 , x , typename is_resizeable< acceleration_type >::type() ); resized |= adjust_size_by_resizeability( m_a2 , x , typename is_resizeable< acceleration_type >::type() ); return resized; } acceleration_type & get_current_acc( void ) { return m_current_a1 ? m_a1.m_v : m_a2.m_v ; } const acceleration_type & get_current_acc( void ) const { return m_current_a1 ? m_a1.m_v : m_a2.m_v ; } acceleration_type & get_old_acc( void ) { return m_current_a1 ? m_a2.m_v : m_a1.m_v ; } const acceleration_type & get_old_acc( void ) const { return m_current_a1 ? m_a2.m_v : m_a1.m_v ; } void toggle_current_acc( void ) { m_current_a1 = ! m_current_a1; } resizer_type m_resizer; bool m_first_call; wrapped_acceleration_type m_a1 , m_a2; bool m_current_a1; }; /** * \class velocity_verlet * \brief The Velocity-Verlet algorithm. * * <a href="http://en.wikipedia.org/wiki/Verlet_integration" >The Velocity-Verlet algorithm</a> is a method for simulation of molecular dynamics systems. It solves the ODE * a=f(r,v',t) where r are the coordinates, v are the velocities and a are the accelerations, hence v = dr/dt, a=dv/dt. * * \tparam Coor The type representing the coordinates. * \tparam Velocity The type representing the velocities. * \tparam Value The type value type. * \tparam Acceleration The type representing the acceleration. * \tparam Time The time representing the independent variable - the time. * \tparam TimeSq The time representing the square of the time. * \tparam Algebra The algebra. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn velocity_verlet::velocity_verlet( const algebra_type &algebra ) * \brief Constructs the velocity_verlet 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. */ /** * \fn velocity_verlet::do_step( System system , StateInOut &x , time_type t , time_type dt ) * \brief This method performs one step. It transforms the result in-place. * * It can be used like * \code * pair< coordinates , velocities > state; * stepper.do_step( sys , x , t , dt ); * \endcode * * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the * Second Order System concept. * \param x The state of the ODE which should be solved. The state is pair of Coor and Velocity. * \param t The value of the time, at which the step should be performed. * \param dt The step size. */ /** * \fn velocity_verlet::do_step( System system , const StateInOut &x , time_type t , time_type dt ) * \brief This method performs one step. It transforms the result in-place. * * It can be used like * \code * pair< coordinates , velocities > state; * stepper.do_step( sys , x , t , dt ); * \endcode * * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the * Second Order System concept. * \param x The state of the ODE which should be solved. The state is pair of Coor and Velocity. * \param t The value of the time, at which the step should be performed. * \param dt The step size. */ /** * \fn velocity_verlet::do_step( System system , CoorIn const & qin , VelocityIn const & pin , AccelerationIn const & ain , CoorOut & qout , VelocityOut & pout , AccelerationOut & aout , time_type t , time_type dt ) * \brief This method performs one step. It transforms the result in-place. Additionally to the other methods * the coordinates, velocities and accelerations are passed directly to do_step and they are transformed out-of-place. * * It can be used like * \code * coordinates qin , qout; * velocities pin , pout; * accelerations ain, aout; * stepper.do_step( sys , qin , pin , ain , qout , pout , aout , t , dt ); * \endcode * * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the * Second Order System concept. * \param x The state of the ODE which should be solved. The state is pair of Coor and Velocity. * \param t The value of the time, at which the step should be performed. * \param dt The step size. */ /** * \fn void velocity_verlet::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 velocity_verlet::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 velocity_verlet::initialize( System system , const CoorIn &qin , const VelocityIn &pin , time_type t ) * \brief Initializes the internal state of the stepper. * * This method is equivalent to * \code * Acceleration a; * system( qin , pin , a , t ); * stepper.initialize( a ); * \endcode * * \param system The system function for the next calls of `do_step`. * \param qin The current coordinates of the ODE. * \param pin The current velocities of the ODE. * \param t The current time of the ODE. */ /** * \fn velocity_verlet::is_initialized() * \returns Returns if the stepper is initialized. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_VELOCITY_VERLET_HPP_DEFINED PK 䄟[<u6b ) stepper/symplectic_rkn_sb3a_mclachlan.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp [begin_description] Implementation of the symplectic MacLachlan stepper for separable Hamiltonian system. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-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_STEPPER_SYMPLECTIC_RKN_SB3A_MCLACHLAN_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_MCLACHLAN_HPP_INCLUDED #include <boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/util/resizer.hpp> #include <boost/array.hpp> namespace boost { namespace numeric { namespace odeint { #ifndef DOXYGEN_SKIP namespace detail { namespace symplectic_rkn_sb3a_mclachlan { /* exp( a1 t A ) exp( b1 t B ) exp( a2 t A ) exp( b2 t B ) exp( a3 t A ) exp( b3 t B ) exp( a3 t A ) exp( b2 t B ) exp( a2 t A ) exp( b1 t B ) exp( a1 t A ) */ template< class Value > struct coef_a_type : public boost::array< Value , 6 > { coef_a_type( void ) { (*this)[0] = static_cast< Value >( 0.40518861839525227722 ); (*this)[1] = static_cast< Value >( -0.28714404081652408900 ); (*this)[2] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ) - ( (*this)[0] + (*this)[1] ); (*this)[3] = (*this)[2]; (*this)[4] = (*this)[1]; (*this)[5] = (*this)[0]; } }; template< class Value > struct coef_b_type : public boost::array< Value , 6 > { coef_b_type( void ) { (*this)[0] = static_cast< Value >( -3 ) / static_cast< Value >( 73 ); (*this)[1] = static_cast< Value >( 17 ) / static_cast< Value >( 59 ); (*this)[2] = static_cast< Value >( 1 ) - static_cast< Value >( 2 ) * ( (*this)[0] + (*this)[1] ); (*this)[3] = (*this)[1]; (*this)[4] = (*this)[0]; (*this)[5] = static_cast< Value >( 0 ); } }; } // namespace symplectic_rkn_sb3a_mclachlan } // namespace detail #endif // DOXYGEN_SKIP template< class Coor , class Momentum = Coor , class Value = double , class CoorDeriv = Coor , class MomentumDeriv = Coor , class Time = Value , class Algebra = typename algebra_dispatcher< Coor >::algebra_type , class Operations = typename operations_dispatcher< Coor >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class symplectic_rkn_sb3a_mclachlan : public symplectic_nystroem_stepper_base < 6 , 4 , Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > #else class symplectic_rkn_sb3a_mclachlan : public symplectic_nystroem_stepper_base #endif { public: #ifndef DOXYGEN_SKIP typedef symplectic_nystroem_stepper_base < 6 , 4 , Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > stepper_base_type; #endif typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::value_type value_type; symplectic_rkn_sb3a_mclachlan( const algebra_type &algebra = algebra_type() ) : stepper_base_type( detail::symplectic_rkn_sb3a_mclachlan::coef_a_type< value_type >() , detail::symplectic_rkn_sb3a_mclachlan::coef_b_type< value_type >() , algebra ) { } }; /************* DOXYGEN ***********/ /** * \class symplectic_rkn_sb3a_mclachlan * \brief Implement of the symmetric B3A method of Runge-Kutta-Nystroem method of sixth order. * * The method is of fourth order and has six stages. It is described HERE. This method cannot be used * with multiprecision types since the coefficients are not defined analytically. * * ToDo Add reference to the paper. * * \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_rkn_sb3a_mclachlan::symplectic_rkn_sb3a_mclachlan( const algebra_type &algebra ) * \brief Constructs the symplectic_rkn_sb3a_mclachlan. 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. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_MCLACHLAN_HPP_INCLUDED PK 䄟[GLk��8 �8 $ stepper/dense_output_runge_kutta.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp [begin_description] Implementation of the Dense-output stepper for all steppers. Note, that this class does not computes the result but serves as an interface. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-2015 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_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED #include <utility> #include <stdexcept> #include <boost/throw_exception.hpp> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/util/copy.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/controlled_step_result.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/integrate/max_step_checker.hpp> namespace boost { namespace numeric { namespace odeint { template< class Stepper , class StepperCategory = typename Stepper::stepper_category > class dense_output_runge_kutta; /** * \brief The class representing dense-output Runge-Kutta steppers. * \note In this stepper, the initialize method has to be called before using * the do_step method. * * The dense-output functionality allows to interpolate the solution between * subsequent integration points using intermediate results obtained during the * computation. This version works based on a normal stepper without step-size * control. * * * \tparam Stepper The stepper type of the underlying algorithm. */ template< class Stepper > class dense_output_runge_kutta< Stepper , stepper_tag > { public: /* * We do not need all typedefs. */ typedef Stepper stepper_type; typedef typename stepper_type::state_type state_type; typedef typename stepper_type::wrapped_state_type wrapped_state_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type; typedef typename stepper_type::time_type time_type; typedef typename stepper_type::algebra_type algebra_type; typedef typename stepper_type::operations_type operations_type; typedef typename stepper_type::resizer_type resizer_type; typedef dense_output_stepper_tag stepper_category; typedef dense_output_runge_kutta< Stepper > dense_output_stepper_type; /** * \brief Constructs the dense_output_runge_kutta class. An instance of the * underlying stepper can be provided. * \param stepper An instance of the underlying stepper. */ dense_output_runge_kutta( const stepper_type &stepper = stepper_type() ) : m_stepper( stepper ) , m_resizer() , m_x1() , m_x2() , m_current_state_x1( true ) , m_t() , m_t_old() , m_dt() { } /** * \brief Initializes the stepper. Has to be called before do_step can be * used to set the initial conditions and the step size. * \param x0 The initial state of the ODE which should be solved. * \param t0 The initial time, at which the step should be performed. * \param dt0 The step size. */ template< class StateType > void initialize( const StateType &x0 , time_type t0 , time_type dt0 ) { m_resizer.adjust_size( x0 , detail::bind( &dense_output_stepper_type::template resize_impl< StateType > , detail::ref( *this ) , detail::_1 ) ); boost::numeric::odeint::copy( x0 , get_current_state() ); m_t = t0; m_dt = dt0; } /** * \brief Does one time step. * \note initialize has to be called before using this method to set the * initial conditions x,t and the stepsize. * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the * Simple System concept. * \return Pair with start and end time of the integration step. */ template< class System > std::pair< time_type , time_type > do_step( System system ) { m_stepper.do_step( system , get_current_state() , m_t , get_old_state() , m_dt ); m_t_old = m_t; m_t += m_dt; toggle_current_state(); return std::make_pair( m_t_old , m_t ); } /* * The next two overloads are needed to solve the forwarding problem */ /** * \brief Calculates the solution at an intermediate point. * \param t The time at which the solution should be calculated, has to be * in the current time interval. * \param x The output variable where the result is written into. */ template< class StateOut > void calc_state( time_type t , StateOut &x ) const { if( t == current_time() ) { boost::numeric::odeint::copy( get_current_state() , x ); } m_stepper.calc_state( x , t , get_old_state() , m_t_old , get_current_state() , m_t ); } /** * \brief Calculates the solution at an intermediate point. Solves the forwarding problem * \param t The time at which the solution should be calculated, has to be * in the current time interval. * \param x The output variable where the result is written into, can be a boost range. */ template< class StateOut > void calc_state( time_type t , const StateOut &x ) const { m_stepper.calc_state( x , t , get_old_state() , m_t_old , get_current_state() , m_t ); } /** * \brief Adjust the size of all temporaries in the stepper manually. * \param x A state from which the size of the temporaries to be resized is deduced. */ template< class StateType > void adjust_size( const StateType &x ) { resize_impl( x ); m_stepper.stepper().resize( x ); } /** * \brief Returns the current state of the solution. * \return The current state of the solution x(t). */ const state_type& current_state( void ) const { return get_current_state(); } /** * \brief Returns the current time of the solution. * \return The current time of the solution t. */ time_type current_time( void ) const { return m_t; } /** * \brief Returns the last state of the solution. * \return The last state of the solution x(t-dt). */ const state_type& previous_state( void ) const { return get_old_state(); } /** * \brief Returns the last time of the solution. * \return The last time of the solution t-dt. */ time_type previous_time( void ) const { return m_t_old; } /** * \brief Returns the current time step. * \return dt. */ time_type current_time_step( void ) const { return m_dt; } private: state_type& get_current_state( void ) { return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ; } const state_type& get_current_state( void ) const { return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ; } state_type& get_old_state( void ) { return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ; } const state_type& get_old_state( void ) const { return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ; } void toggle_current_state( void ) { m_current_state_x1 = ! m_current_state_x1; } template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() ); return resized; } stepper_type m_stepper; resizer_type m_resizer; wrapped_state_type m_x1 , m_x2; bool m_current_state_x1; // if true, the current state is m_x1 time_type m_t , m_t_old , m_dt; }; /** * \brief The class representing dense-output Runge-Kutta steppers with FSAL property. * * The interface is the same as for dense_output_runge_kutta< Stepper , stepper_tag >. * This class provides dense output functionality based on methods with step size controlled * * * \tparam Stepper The stepper type of the underlying algorithm. */ template< class Stepper > class dense_output_runge_kutta< Stepper , explicit_controlled_stepper_fsal_tag > { public: /* * We do not need all typedefs. */ typedef Stepper controlled_stepper_type; typedef typename controlled_stepper_type::stepper_type stepper_type; typedef typename stepper_type::state_type state_type; typedef typename stepper_type::wrapped_state_type wrapped_state_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type; typedef typename stepper_type::time_type time_type; typedef typename stepper_type::algebra_type algebra_type; typedef typename stepper_type::operations_type operations_type; typedef typename stepper_type::resizer_type resizer_type; typedef dense_output_stepper_tag stepper_category; typedef dense_output_runge_kutta< Stepper > dense_output_stepper_type; dense_output_runge_kutta( const controlled_stepper_type &stepper = controlled_stepper_type() ) : m_stepper( stepper ) , m_resizer() , m_current_state_x1( true ) , m_x1() , m_x2() , m_dxdt1() , m_dxdt2() , m_t() , m_t_old() , m_dt() , m_is_deriv_initialized( false ) { } template< class StateType > void initialize( const StateType &x0 , time_type t0 , time_type dt0 ) { m_resizer.adjust_size( x0 , detail::bind( &dense_output_stepper_type::template resize< StateType > , detail::ref( *this ) , detail::_1 ) ); boost::numeric::odeint::copy( x0 , get_current_state() ); m_t = t0; m_dt = dt0; m_is_deriv_initialized = false; } template< class System > std::pair< time_type , time_type > do_step( System system ) { if( !m_is_deriv_initialized ) { typename odeint::unwrap_reference< System >::type &sys = system; sys( get_current_state() , get_current_deriv() , m_t ); m_is_deriv_initialized = true; } failed_step_checker fail_checker; // to throw a runtime_error if step size adjustment fails controlled_step_result res = fail; m_t_old = m_t; do { res = m_stepper.try_step( system , get_current_state() , get_current_deriv() , m_t , get_old_state() , get_old_deriv() , m_dt ); fail_checker(); // check for overflow of failed steps } while( res == fail ); toggle_current_state(); return std::make_pair( m_t_old , m_t ); } /* * The two overloads are needed in order to solve the forwarding problem. */ template< class StateOut > void calc_state( time_type t , StateOut &x ) const { m_stepper.stepper().calc_state( t , x , get_old_state() , get_old_deriv() , m_t_old , get_current_state() , get_current_deriv() , m_t ); } template< class StateOut > void calc_state( time_type t , const StateOut &x ) const { m_stepper.stepper().calc_state( t , x , get_old_state() , get_old_deriv() , m_t_old , get_current_state() , get_current_deriv() , m_t ); } template< class StateIn > bool resize( const StateIn &x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_dxdt1 , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_dxdt2 , x , typename is_resizeable<deriv_type>::type() ); return resized; } template< class StateType > void adjust_size( const StateType &x ) { resize( x ); m_stepper.stepper().resize( x ); } const state_type& current_state( void ) const { return get_current_state(); } time_type current_time( void ) const { return m_t; } const state_type& previous_state( void ) const { return get_old_state(); } time_type previous_time( void ) const { return m_t_old; } time_type current_time_step( void ) const { return m_dt; } private: state_type& get_current_state( void ) { return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ; } const state_type& get_current_state( void ) const { return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ; } state_type& get_old_state( void ) { return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ; } const state_type& get_old_state( void ) const { return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ; } deriv_type& get_current_deriv( void ) { return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ; } const deriv_type& get_current_deriv( void ) const { return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ; } deriv_type& get_old_deriv( void ) { return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ; } const deriv_type& get_old_deriv( void ) const { return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ; } void toggle_current_state( void ) { m_current_state_x1 = ! m_current_state_x1; } controlled_stepper_type m_stepper; resizer_type m_resizer; bool m_current_state_x1; wrapped_state_type m_x1 , m_x2; wrapped_deriv_type m_dxdt1 , m_dxdt2; time_type m_t , m_t_old , m_dt; bool m_is_deriv_initialized; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED PK 䄟[����a a stepper/symplectic_euler.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/symplectic_euler.hpp [begin_description] Implementation of the symplectic Euler for separable Hamiltonian systems. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-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_STEPPER_SYMPLECTIC_EULER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_EULER_HPP_INCLUDED #include <boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/array.hpp> namespace boost { namespace numeric { namespace odeint { #ifndef DOXYGEN_SKIP namespace detail { namespace symplectic_euler_coef { template< class Value > struct coef_a_type : public boost::array< Value , 1 > { coef_a_type( void ) { (*this)[0] = static_cast< Value >( 1 ); } }; template< class Value > struct coef_b_type : public boost::array< Value , 1 > { coef_b_type( void ) { (*this)[0] = static_cast< Value >( 1 ); } }; } // namespace symplectic_euler_coef } // namespace detail #endif template< class Coor , class Momentum = Coor , class Value = double , class CoorDeriv = Coor , class MomentumDeriv = Coor , class Time = Value , class Algebra = typename algebra_dispatcher< Coor >::algebra_type , class Operations = typename operations_dispatcher< Coor >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class symplectic_euler : public symplectic_nystroem_stepper_base < 1 , 1 , Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > #else class symplectic_euler : public symplectic_nystroem_stepper_base #endif { public: #ifndef DOXYGEN_SKIP typedef symplectic_nystroem_stepper_base< 1 , 1 , Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > stepper_base_type; #endif typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::value_type value_type; symplectic_euler( const algebra_type &algebra = algebra_type() ) : stepper_base_type( detail::symplectic_euler_coef::coef_a_type< value_type >() , detail::symplectic_euler_coef::coef_b_type< value_type >() , algebra ) { } }; /*************** DOXYGEN ***************/ /** * \class symplectic_euler * \brief Implementation of the symplectic Euler method. * * The method is of first order and has one stage. It is described HERE. * * \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_euler::symplectic_euler( const algebra_type &algebra ) * \brief Constructs the symplectic_euler. 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. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_EULER_HPP_INCLUDED PK 䄟[-'d�`' `' . stepper/controlled_adams_bashforth_moulton.hppnu �[��� /* boost/numeric/odeint/stepper/detail/controlled_adams_bashforth_moulton.hpp [begin_description] Implemetation of an controlled adams bashforth moulton stepper. [end_description] Copyright 2017 Valentin Noah Hartmann 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_CONTROLLED_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/stepper/adaptive_adams_bashforth_moulton.hpp> #include <boost/numeric/odeint/stepper/detail/pid_step_adjuster.hpp> #include <boost/numeric/odeint/util/unwrap_reference.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/util/bind.hpp> #include <iostream> namespace boost { namespace numeric { namespace odeint { template< size_t MaxOrder, class State, class Value = double, class Algebra = typename algebra_dispatcher< State >::algebra_type > class default_order_adjuster { public: typedef State state_type; typedef Value value_type; typedef state_wrapper< state_type > wrapped_state_type; typedef Algebra algebra_type; default_order_adjuster( const algebra_type &algebra = algebra_type() ) : m_algebra( algebra ) {}; size_t adjust_order(size_t order, size_t init, boost::array<wrapped_state_type, 4> &xerr) { using std::abs; value_type errc = abs(m_algebra.norm_inf(xerr[2].m_v)); value_type errm1 = 3*errc; value_type errm2 = 3*errc; if(order > 2) { errm2 = abs(m_algebra.norm_inf(xerr[0].m_v)); } if(order >= 2) { errm1 = abs(m_algebra.norm_inf(xerr[1].m_v)); } size_t o_new = order; if(order == 2 && errm1 <= 0.5*errc) { o_new = order - 1; } else if(order > 2 && errm2 < errc && errm1 < errc) { o_new = order - 1; } if(init < order) { return order+1; } else if(o_new == order - 1) { return order-1; } else if(order <= MaxOrder) { value_type errp = abs(m_algebra.norm_inf(xerr[3].m_v)); if(order > 1 && errm1 < errc && errp) { return order-1; } else if(order < MaxOrder && errp < (0.5-0.25*order/MaxOrder) * errc) { return order+1; } } return order; }; private: algebra_type m_algebra; }; template< class ErrorStepper, class StepAdjuster = detail::pid_step_adjuster< typename ErrorStepper::state_type, typename ErrorStepper::value_type, typename ErrorStepper::deriv_type, typename ErrorStepper::time_type, typename ErrorStepper::algebra_type, typename ErrorStepper::operations_type, detail::H211PI >, class OrderAdjuster = default_order_adjuster< ErrorStepper::order_value, typename ErrorStepper::state_type, typename ErrorStepper::value_type, typename ErrorStepper::algebra_type >, class Resizer = initially_resizer > class controlled_adams_bashforth_moulton { public: typedef ErrorStepper stepper_type; static const typename stepper_type::order_type order_value = stepper_type::order_value; typedef typename stepper_type::state_type state_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::time_type time_type; typedef typename stepper_type::algebra_type algebra_type; typedef typename stepper_type::operations_type operations_type; typedef Resizer resizer_type; typedef StepAdjuster step_adjuster_type; typedef OrderAdjuster order_adjuster_type; typedef controlled_stepper_tag stepper_category; typedef typename stepper_type::wrapped_state_type wrapped_state_type; typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type; typedef boost::array< wrapped_state_type , 4 > error_storage_type; typedef typename stepper_type::coeff_type coeff_type; typedef controlled_adams_bashforth_moulton< ErrorStepper , StepAdjuster , OrderAdjuster , Resizer > controlled_stepper_type; controlled_adams_bashforth_moulton(step_adjuster_type step_adjuster = step_adjuster_type()) :m_stepper(), m_dxdt_resizer(), m_xerr_resizer(), m_xnew_resizer(), m_step_adjuster( step_adjuster ), m_order_adjuster() {}; template< class ExplicitStepper, class System > void initialize(ExplicitStepper stepper, System system, state_type &inOut, time_type &t, time_type dt) { m_stepper.initialize(stepper, system, inOut, t, dt); }; template< class System > void initialize(System system, state_type &inOut, time_type &t, time_type dt) { m_stepper.initialize(system, inOut, t, dt); }; template< class ExplicitStepper, class System > void initialize_controlled(ExplicitStepper stepper, System system, state_type &inOut, time_type &t, time_type &dt) { reset(); coeff_type &coeff = m_stepper.coeff(); m_dxdt_resizer.adjust_size( inOut , detail::bind( &controlled_stepper_type::template resize_dxdt_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); controlled_step_result res = fail; for( size_t i=0 ; i<order_value; ++i ) { do { res = stepper.try_step( system, inOut, t, dt ); } while(res != success); system( inOut , m_dxdt.m_v , t ); coeff.predict(t-dt, dt); coeff.do_step(m_dxdt.m_v); coeff.confirm(); if(coeff.m_eo < order_value) { ++coeff.m_eo; } } } template< class System > controlled_step_result try_step(System system, state_type & inOut, time_type &t, time_type &dt) { m_xnew_resizer.adjust_size( inOut , detail::bind( &controlled_stepper_type::template resize_xnew_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); controlled_step_result res = try_step(system, inOut, t, m_xnew.m_v, dt); if(res == success) { boost::numeric::odeint::copy( m_xnew.m_v , inOut); } return res; }; template< class System > controlled_step_result try_step(System system, const state_type & in, time_type &t, state_type & out, time_type &dt) { m_xerr_resizer.adjust_size( in , detail::bind( &controlled_stepper_type::template resize_xerr_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); m_dxdt_resizer.adjust_size( in , detail::bind( &controlled_stepper_type::template resize_dxdt_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); m_stepper.do_step_impl(system, in, t, out, dt, m_xerr[2].m_v); coeff_type &coeff = m_stepper.coeff(); time_type dtPrev = dt; dt = m_step_adjuster.adjust_stepsize(coeff.m_eo, dt, m_xerr[2].m_v, out, m_stepper.dxdt() ); if(dt / dtPrev >= step_adjuster_type::threshold()) { system(out, m_dxdt.m_v, t+dtPrev); coeff.do_step(m_dxdt.m_v); coeff.confirm(); t += dtPrev; size_t eo = coeff.m_eo; // estimate errors for next step double factor = 1; algebra_type m_algebra; m_algebra.for_each2(m_xerr[2].m_v, coeff.phi[1][eo].m_v, typename operations_type::template scale_sum1<double>(factor*dt*(coeff.gs[eo]))); if(eo > 1) { m_algebra.for_each2(m_xerr[1].m_v, coeff.phi[1][eo-1].m_v, typename operations_type::template scale_sum1<double>(factor*dt*(coeff.gs[eo-1]))); } if(eo > 2) { m_algebra.for_each2(m_xerr[0].m_v, coeff.phi[1][eo-2].m_v, typename operations_type::template scale_sum1<double>(factor*dt*(coeff.gs[eo-2]))); } if(eo < order_value && coeff.m_eo < coeff.m_steps_init-1) { m_algebra.for_each2(m_xerr[3].m_v, coeff.phi[1][eo+1].m_v, typename operations_type::template scale_sum1<double>(factor*dt*(coeff.gs[eo+1]))); } // adjust order coeff.m_eo = m_order_adjuster.adjust_order(coeff.m_eo, coeff.m_steps_init-1, m_xerr); return success; } else { return fail; } }; void reset() { m_stepper.reset(); }; private: template< class StateType > bool resize_dxdt_impl( const StateType &x ) { return adjust_size_by_resizeability( m_dxdt, x, typename is_resizeable<deriv_type>::type() ); }; template< class StateType > bool resize_xerr_impl( const StateType &x ) { bool resized( false ); for(size_t i=0; i<m_xerr.size(); ++i) { resized |= adjust_size_by_resizeability( m_xerr[i], x, typename is_resizeable<state_type>::type() ); } return resized; }; template< class StateType > bool resize_xnew_impl( const StateType &x ) { return adjust_size_by_resizeability( m_xnew, x, typename is_resizeable<state_type>::type() ); }; stepper_type m_stepper; wrapped_deriv_type m_dxdt; error_storage_type m_xerr; wrapped_state_type m_xnew; resizer_type m_dxdt_resizer; resizer_type m_xerr_resizer; resizer_type m_xnew_resizer; step_adjuster_type m_step_adjuster; order_adjuster_type m_order_adjuster; }; } // odeint } // numeric } // boost #endifPK 䄟[��'� � stepper/adams_moulton.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/adams_moulton.hpp [begin_description] Implementation of the Adams-Moulton method. This is method is not a real stepper, it is more a helper class which computes the corrector step in the Adams-Bashforth-Moulton method. [end_description] Copyright 2011-2012 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_ADAMS_MOULTON_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_MOULTON_HPP_INCLUDED #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.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/runge_kutta4_classic.hpp> #include <boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp> #include <boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp> #include <boost/numeric/odeint/stepper/detail/rotating_buffer.hpp> namespace boost { namespace numeric { namespace odeint { /* * Static implicit Adams-Moulton multistep-solver without step size control and without dense output. */ template< size_t Steps , class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > class adams_moulton { private: public : typedef State state_type; typedef state_wrapper< state_type > wrapped_state_type; typedef Value value_type; typedef Deriv deriv_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef Time time_type; typedef Algebra algebra_type; typedef Operations operations_type; typedef Resizer resizer_type; typedef stepper_tag stepper_category; typedef adams_moulton< Steps , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_type; static const size_t steps = Steps; typedef unsigned short order_type; static const order_type order_value = steps + 1; typedef detail::rotating_buffer< wrapped_deriv_type , steps > step_storage_type; adams_moulton( ) : m_coefficients() , m_dxdt() , m_resizer() , m_algebra_instance() , m_algebra( m_algebra_instance ) { } adams_moulton( algebra_type &algebra ) : m_coefficients() , m_dxdt() , m_resizer() , m_algebra_instance() , m_algebra( algebra ) { } adams_moulton& operator=( const adams_moulton &stepper ) { m_dxdt = stepper.m_dxdt; m_resizer = stepper.m_resizer; m_algebra = stepper.m_algebra; return *this; } order_type order( void ) const { return order_value; } /* * Version 1 : do_step( system , x , t , dt , buf ); * * solves the forwarding problem */ template< class System , class StateInOut , class StateIn , class ABBuf > void do_step( System system , StateInOut &x , StateIn const & pred , time_type t , time_type dt , const ABBuf &buf ) { do_step( system , x , pred , t , x , dt , buf ); } template< class System , class StateInOut , class StateIn , class ABBuf > void do_step( System system , const StateInOut &x , StateIn const & pred , time_type t , time_type dt , const ABBuf &buf ) { do_step( system , x , pred , t , x , dt , buf ); } /* * Version 2 : do_step( system , in , t , out , dt , buf ); * * solves the forwarding problem */ template< class System , class StateIn , class PredIn , class StateOut , class ABBuf > void do_step( System system , const StateIn &in , const PredIn &pred , time_type t , StateOut &out , time_type dt , const ABBuf &buf ) { do_step_impl( system , in , pred , t , out , dt , buf ); } template< class System , class StateIn , class PredIn , class StateOut , class ABBuf > void do_step( System system , const StateIn &in , const PredIn &pred , time_type t , const StateOut &out , time_type dt , const ABBuf &buf ) { do_step_impl( system , in , pred , t , out , dt , buf ); } template< class StateType > void adjust_size( const StateType &x ) { resize_impl( x ); } algebra_type& algebra() { return m_algebra; } const algebra_type& algebra() const { return m_algebra; } private: template< class System , class StateIn , class PredIn , class StateOut , class ABBuf > void do_step_impl( System system , const StateIn &in , const PredIn &pred , time_type t , StateOut &out , time_type dt , const ABBuf &buf ) { typename odeint::unwrap_reference< System >::type &sys = system; m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ); sys( pred , m_dxdt.m_v , t ); detail::adams_moulton_call_algebra< steps , algebra_type , operations_type >()( m_algebra , in , out , m_dxdt.m_v , buf , m_coefficients , dt ); } template< class StateIn > bool resize_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() ); } const detail::adams_moulton_coefficients< value_type , steps > m_coefficients; wrapped_deriv_type m_dxdt; resizer_type m_resizer; protected: algebra_type m_algebra_instance; algebra_type &m_algebra; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_MOULTON_HPP_INCLUDED PK 䄟[�ثݠ; �; stepper/adams_bashforth.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/adams_bashforth.hpp [begin_description] Implementaton of the Adam-Bashforth method a multistep method used for the predictor step in the Adams-Bashforth-Moulton method. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-2013 Mario Mulansky Copyright 2012 Christoph Koke Copyright 2013 Pascal Germroth 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_ADAMS_BASHFORTH_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_HPP_INCLUDED #include <boost/static_assert.hpp> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.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/runge_kutta4.hpp> #include <boost/numeric/odeint/stepper/extrapolation_stepper.hpp> #include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp> #include <boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp> #include <boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp> #include <boost/numeric/odeint/stepper/detail/rotating_buffer.hpp> #include <boost/mpl/arithmetic.hpp> #include <boost/mpl/min_max.hpp> #include <boost/mpl/equal_to.hpp> namespace mpl = boost::mpl; namespace boost { namespace numeric { namespace odeint { using mpl::int_; /* if N >= 4, returns the smallest even number > N, otherwise returns 4 */ template < int N > struct order_helper : mpl::max< typename mpl::eval_if< mpl::equal_to< mpl::modulus< int_< N >, int_< 2 > >, int_< 0 > >, int_< N >, int_< N + 1 > >::type, int_< 4 > >::type { }; template< size_t Steps , class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer , class InitializingStepper = extrapolation_stepper< order_helper<Steps>::value, State, Value, Deriv, Time, Algebra, Operations, Resizer > > class adams_bashforth : public algebra_stepper_base< Algebra , Operations > { #ifndef DOXYGEN_SKIP BOOST_STATIC_ASSERT(( Steps > 0 )); BOOST_STATIC_ASSERT(( Steps < 9 )); #endif public : typedef State state_type; typedef state_wrapper< state_type > wrapped_state_type; typedef Value value_type; typedef Deriv deriv_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef Time time_type; typedef Resizer resizer_type; typedef stepper_tag stepper_category; typedef InitializingStepper initializing_stepper_type; 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; #ifndef DOXYGEN_SKIP typedef adams_bashforth< Steps , State , Value , Deriv , Time , Algebra , Operations , Resizer , InitializingStepper > stepper_type; #endif static const size_t steps = Steps; typedef unsigned short order_type; static const order_type order_value = steps; typedef detail::rotating_buffer< wrapped_deriv_type , steps > step_storage_type; order_type order( void ) const { return order_value; } adams_bashforth( const algebra_type &algebra = algebra_type() ) : algebra_stepper_base_type( algebra ) , m_step_storage() , m_resizer() , m_coefficients() , m_steps_initialized( 0 ) , m_initializing_stepper() { } /* * Version 1 : do_step( system , x , t , dt ); * * solves the forwarding problem */ template< class System , class StateInOut > void do_step( System system , StateInOut &x , time_type t , time_type dt ) { do_step( system , x , t , x , 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( system , x , t , x , dt ); } /* * Version 2 : do_step( system , in , t , out , dt ); * * solves the forwarding problem */ template< class System , class StateIn , class StateOut > void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt ) { do_step_impl( system , in , t , out , dt ); } /** * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateOut. */ template< class System , class StateIn , class StateOut > void do_step( System system , const StateIn &in , time_type t , const StateOut &out , time_type dt ) { do_step_impl( system , in , t , out , dt ); } template< class StateType > void adjust_size( const StateType &x ) { resize_impl( x ); } const step_storage_type& step_storage( void ) const { return m_step_storage; } step_storage_type& step_storage( void ) { return m_step_storage; } template< class ExplicitStepper , class System , class StateIn > void initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt ) { typename odeint::unwrap_reference< ExplicitStepper >::type &stepper = explicit_stepper; typename odeint::unwrap_reference< System >::type &sys = system; m_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ); for( size_t i=0 ; i+1<steps ; ++i ) { if( i != 0 ) m_step_storage.rotate(); sys( x , m_step_storage[0].m_v , t ); stepper.do_step_dxdt_impl( system, x, m_step_storage[0].m_v, t, dt ); t += dt; } m_steps_initialized = steps; } template< class System , class StateIn > void initialize( System system , StateIn &x , time_type &t , time_type dt ) { initialize( detail::ref( m_initializing_stepper ) , system , x , t , dt ); } void reset( void ) { m_steps_initialized = 0; } bool is_initialized( void ) const { return m_steps_initialized >= ( steps - 1 ); } const initializing_stepper_type& initializing_stepper( void ) const { return m_initializing_stepper; } initializing_stepper_type& initializing_stepper( void ) { return m_initializing_stepper; } private: template< class System , class StateIn , class StateOut > void do_step_impl( System system , const StateIn &in , time_type t , StateOut &out , time_type dt ) { typename odeint::unwrap_reference< System >::type &sys = system; if( m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ) ) { m_steps_initialized = 0; } if( m_steps_initialized + 1 < steps ) { if( m_steps_initialized != 0 ) m_step_storage.rotate(); sys( in , m_step_storage[0].m_v , t ); m_initializing_stepper.do_step_dxdt_impl( system, in, m_step_storage[0].m_v, t, out, dt ); ++m_steps_initialized; } else { m_step_storage.rotate(); sys( in , m_step_storage[0].m_v , t ); detail::adams_bashforth_call_algebra< steps , algebra_type , operations_type >()( this->m_algebra , in , out , m_step_storage , m_coefficients , dt ); } } template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized( false ); for( size_t i=0 ; i<steps ; ++i ) { resized |= adjust_size_by_resizeability( m_step_storage[i] , x , typename is_resizeable<deriv_type>::type() ); } return resized; } step_storage_type m_step_storage; resizer_type m_resizer; detail::adams_bashforth_coefficients< value_type , steps > m_coefficients; size_t m_steps_initialized; initializing_stepper_type m_initializing_stepper; }; /***** DOXYGEN *****/ /** * \class adams_bashforth * \brief The Adams-Bashforth multistep algorithm. * * The Adams-Bashforth method is a multi-step algorithm with configurable step * number. The step number is specified as template parameter Steps and it * then uses the result from the previous Steps steps. See also * <a href="http://en.wikipedia.org/wiki/Linear_multistep_method">en.wikipedia.org/wiki/Linear_multistep_method</a>. * Currently, a maximum of Steps=8 is supported. * The method is explicit and fulfills the Stepper concept. Step size control * or continuous output are not provided. * * This class derives from algebra_base and inherits its interface via * CRTP (current recurring template pattern). For more details see * algebra_stepper_base. * * \tparam Steps The number of steps (maximal 8). * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. * \tparam InitializingStepper The stepper for the first two steps. */ /** * \fn adams_bashforth::adams_bashforth( const algebra_type &algebra ) * \brief Constructs the adams_bashforth 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. */ /** * \fn order_type adams_bashforth::order( void ) const * \brief Returns the order of the algorithm, which is equal to the number of steps. * \return order of the method. */ /** * \fn void adams_bashforth::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 void adams_bashforth::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. * * \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 adams_bashforth::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. */ /** * \fn const step_storage_type& adams_bashforth::step_storage( void ) const * \brief Returns the storage of intermediate results. * \return The storage of intermediate results. */ /** * \fn step_storage_type& adams_bashforth::step_storage( void ) * \brief Returns the storage of intermediate results. * \return The storage of intermediate results. */ /** * \fn void adams_bashforth::initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt ) * \brief Initialized the stepper. Does Steps-1 steps with the explicit_stepper to fill the buffer. * \param explicit_stepper the stepper used to fill the buffer of previous step results * \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 void adams_bashforth::initialize( System system , StateIn &x , time_type &t , time_type dt ) * \brief Initialized the stepper. Does Steps-1 steps with an internal instance of InitializingStepper to fill the buffer. * \note The state x and time t are updated to the values after Steps-1 initial steps. * \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 initial state of the ODE which should be solved, updated in this method. * \param t The initial value of the time, updated in this method. * \param dt The step size. */ /** * \fn void adams_bashforth::reset( void ) * \brief Resets the internal buffer of the stepper. */ /** * \fn bool adams_bashforth::is_initialized( void ) const * \brief Returns true if the stepper has been initialized. * \return bool true if stepper is initialized, false otherwise */ /** * \fn const initializing_stepper_type& adams_bashforth::initializing_stepper( void ) const * \brief Returns the internal initializing stepper instance. * \return initializing_stepper */ /** * \fn const initializing_stepper_type& adams_bashforth::initializing_stepper( void ) const * \brief Returns the internal initializing stepper instance. * \return initializing_stepper */ /** * \fn initializing_stepper_type& adams_bashforth::initializing_stepper( void ) * \brief Returns the internal initializing stepper instance. * \return initializing_stepper */ } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_HPP_INCLUDED PK 䄟[YH��� � stepper/generation.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation.hpp [begin_description] Forward header for the factory functions. Includes all files from the generation directory. [end_description] Copyright 2011 Karsten Ahnert Copyright 2011 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_GENERATION_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_HPP_INCLUDED #include <boost/numeric/odeint/stepper/generation/make_controlled.hpp> #include <boost/numeric/odeint/stepper/generation/make_dense_output.hpp> #include <boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp> #include <boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp> #include <boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp> #include <boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp> #include <boost/numeric/odeint/stepper/generation/generation_controlled_adams_bashforth_moulton.hpp> #include <boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp> #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_HPP_INCLUDED PK 䄟[3zL z z " stepper/rosenbrock4_controller.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/rosenbrock4_controller.hpp [begin_description] Controller for the Rosenbrock4 method. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_ROSENBROCK4_CONTROLLER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_CONTROLLER_HPP_INCLUDED #include <boost/config.hpp> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/util/copy.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> #include <boost/numeric/odeint/stepper/rosenbrock4.hpp> namespace boost { namespace numeric { namespace odeint { template< class Stepper > class rosenbrock4_controller { private: public: typedef Stepper stepper_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::state_type state_type; typedef typename stepper_type::wrapped_state_type wrapped_state_type; typedef typename stepper_type::time_type time_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type; typedef typename stepper_type::resizer_type resizer_type; typedef controlled_stepper_tag stepper_category; typedef rosenbrock4_controller< Stepper > controller_type; rosenbrock4_controller( value_type atol = 1.0e-6 , value_type rtol = 1.0e-6 , const stepper_type &stepper = stepper_type() ) : m_stepper( stepper ) , m_atol( atol ) , m_rtol( rtol ) , m_max_dt( static_cast<time_type>(0) ) , m_first_step( true ) , m_err_old( 0.0 ) , m_dt_old( 0.0 ) , m_last_rejected( false ) { } rosenbrock4_controller( value_type atol, value_type rtol, time_type max_dt, const stepper_type &stepper = stepper_type() ) : m_stepper( stepper ) , m_atol( atol ) , m_rtol( rtol ) , m_max_dt( max_dt ) , m_first_step( true ) , m_err_old( 0.0 ) , m_dt_old( 0.0 ) , m_last_rejected( false ) { } value_type error( const state_type &x , const state_type &xold , const state_type &xerr ) { BOOST_USING_STD_MAX(); using std::abs; using std::sqrt; const size_t n = x.size(); value_type err = 0.0 , sk = 0.0; for( size_t i=0 ; i<n ; ++i ) { sk = m_atol + m_rtol * max BOOST_PREVENT_MACRO_SUBSTITUTION ( abs( xold[i] ) , abs( x[i] ) ); err += xerr[i] * xerr[i] / sk / sk; } return sqrt( err / value_type( n ) ); } value_type last_error( void ) const { return m_err_old; } template< class System > boost::numeric::odeint::controlled_step_result try_step( System sys , state_type &x , time_type &t , time_type &dt ) { m_xnew_resizer.adjust_size( x , detail::bind( &controller_type::template resize_m_xnew< state_type > , detail::ref( *this ) , detail::_1 ) ); boost::numeric::odeint::controlled_step_result res = try_step( sys , x , t , m_xnew.m_v , dt ); if( res == success ) { boost::numeric::odeint::copy( m_xnew.m_v , x ); } return res; } template< class System > boost::numeric::odeint::controlled_step_result try_step( System sys , const state_type &x , time_type &t , state_type &xout , time_type &dt ) { if( m_max_dt != static_cast<time_type>(0) && detail::less_with_sign(m_max_dt, dt, dt) ) { // given step size is bigger then max_dt // set limit and return fail dt = m_max_dt; return fail; } BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); using std::pow; static const value_type safe = 0.9 , fac1 = 5.0 , fac2 = 1.0 / 6.0; m_xerr_resizer.adjust_size( x , detail::bind( &controller_type::template resize_m_xerr< state_type > , detail::ref( *this ) , detail::_1 ) ); m_stepper.do_step( sys , x , t , xout , dt , m_xerr.m_v ); value_type err = error( xout , x , m_xerr.m_v ); value_type fac = max BOOST_PREVENT_MACRO_SUBSTITUTION ( fac2 , min BOOST_PREVENT_MACRO_SUBSTITUTION ( fac1 , static_cast< value_type >( pow( err , 0.25 ) / safe ) ) ); value_type dt_new = dt / fac; if ( err <= 1.0 ) { if( m_first_step ) { m_first_step = false; } else { value_type fac_pred = ( m_dt_old / dt ) * pow( err * err / m_err_old , 0.25 ) / safe; fac_pred = max BOOST_PREVENT_MACRO_SUBSTITUTION ( fac2 , min BOOST_PREVENT_MACRO_SUBSTITUTION ( fac1 , fac_pred ) ); fac = max BOOST_PREVENT_MACRO_SUBSTITUTION ( fac , fac_pred ); dt_new = dt / fac; } m_dt_old = dt; m_err_old = max BOOST_PREVENT_MACRO_SUBSTITUTION ( static_cast< value_type >( 0.01 ) , err ); if( m_last_rejected ) dt_new = ( dt >= 0.0 ? min BOOST_PREVENT_MACRO_SUBSTITUTION ( dt_new , dt ) : max BOOST_PREVENT_MACRO_SUBSTITUTION ( dt_new , dt ) ); t += dt; // limit step size to max_dt if( m_max_dt != static_cast<time_type>(0) ) { dt = detail::min_abs(m_max_dt, dt_new); } else { dt = dt_new; } m_last_rejected = false; return success; } else { dt = dt_new; m_last_rejected = true; return fail; } } template< class StateType > void adjust_size( const StateType &x ) { resize_m_xerr( x ); resize_m_xnew( x ); } stepper_type& stepper( void ) { return m_stepper; } const stepper_type& stepper( void ) const { return m_stepper; } protected: template< class StateIn > bool resize_m_xerr( const StateIn &x ) { return adjust_size_by_resizeability( m_xerr , x , typename is_resizeable<state_type>::type() ); } template< class StateIn > bool resize_m_xnew( const StateIn &x ) { return adjust_size_by_resizeability( m_xnew , x , typename is_resizeable<state_type>::type() ); } stepper_type m_stepper; resizer_type m_xerr_resizer; resizer_type m_xnew_resizer; wrapped_state_type m_xerr; wrapped_state_type m_xnew; value_type m_atol , m_rtol; time_type m_max_dt; bool m_first_step; value_type m_err_old , m_dt_old; bool m_last_rejected; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_CONTROLLER_HPP_INCLUDED PK 䄟[��t t stepper/implicit_euler.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/implicit_euler.hpp [begin_description] Impementation of the implicit Euler method. Works with ublas::vector as state type. [end_description] Copyright 2010-2012 Mario Mulansky Copyright 2010-2012 Karsten Ahnert 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_IMPLICIT_EULER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_IMPLICIT_EULER_HPP_INCLUDED #include <utility> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/util/ublas_wrapper.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resizer.hpp> #include <boost/numeric/ublas/vector.hpp> #include <boost/numeric/ublas/matrix.hpp> #include <boost/numeric/ublas/lu.hpp> namespace boost { namespace numeric { namespace odeint { template< class ValueType , class Resizer = initially_resizer > class implicit_euler { public: typedef ValueType value_type; typedef value_type time_type; typedef boost::numeric::ublas::vector< value_type > state_type; typedef state_wrapper< state_type > wrapped_state_type; typedef state_type deriv_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef boost::numeric::ublas::matrix< value_type > matrix_type; typedef state_wrapper< matrix_type > wrapped_matrix_type; typedef boost::numeric::ublas::permutation_matrix< size_t > pmatrix_type; typedef state_wrapper< pmatrix_type > wrapped_pmatrix_type; typedef Resizer resizer_type; typedef stepper_tag stepper_category; typedef implicit_euler< ValueType , Resizer > stepper_type; implicit_euler( value_type epsilon = 1E-6 ) : m_epsilon( epsilon ) { } template< class System > void do_step( System system , state_type &x , time_type t , time_type dt ) { typedef typename odeint::unwrap_reference< System >::type system_type; typedef typename odeint::unwrap_reference< typename system_type::first_type >::type deriv_func_type; typedef typename odeint::unwrap_reference< typename system_type::second_type >::type jacobi_func_type; system_type &sys = system; deriv_func_type &deriv_func = sys.first; jacobi_func_type &jacobi_func = sys.second; m_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_impl<state_type> , detail::ref( *this ) , detail::_1 ) ); for( size_t i=0 ; i<x.size() ; ++i ) m_pm.m_v[i] = i; t += dt; // apply first Newton step deriv_func( x , m_dxdt.m_v , t ); m_b.m_v = dt * m_dxdt.m_v; jacobi_func( x , m_jacobi.m_v , t ); m_jacobi.m_v *= dt; m_jacobi.m_v -= boost::numeric::ublas::identity_matrix< value_type >( x.size() ); solve( m_b.m_v , m_jacobi.m_v ); m_x.m_v = x - m_b.m_v; // iterate Newton until some precision is reached // ToDo: maybe we should apply only one Newton step -> linear implicit one-step scheme while( boost::numeric::ublas::norm_2( m_b.m_v ) > m_epsilon ) { deriv_func( m_x.m_v , m_dxdt.m_v , t ); m_b.m_v = x - m_x.m_v + dt*m_dxdt.m_v; // simplified version, only the first Jacobian is used // jacobi( m_x , m_jacobi , t ); // m_jacobi *= dt; // m_jacobi -= boost::numeric::ublas::identity_matrix< value_type >( x.size() ); solve( m_b.m_v , m_jacobi.m_v ); m_x.m_v -= m_b.m_v; } x = m_x.m_v; } template< class StateType > void adjust_size( const StateType &x ) { resize_impl( x ); } private: template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_x , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_b , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_jacobi , x , typename is_resizeable<matrix_type>::type() ); resized |= adjust_size_by_resizeability( m_pm , x , typename is_resizeable<pmatrix_type>::type() ); return resized; } void solve( state_type &x , matrix_type &m ) { int res = boost::numeric::ublas::lu_factorize( m , m_pm.m_v ); if( res != 0 ) std::exit(0); boost::numeric::ublas::lu_substitute( m , m_pm.m_v , x ); } private: value_type m_epsilon; resizer_type m_resizer; wrapped_deriv_type m_dxdt; wrapped_state_type m_x; wrapped_deriv_type m_b; wrapped_matrix_type m_jacobi; wrapped_pmatrix_type m_pm; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_IMPLICIT_EULER_HPP_INCLUDED PK 䄟[d����: �: " stepper/runge_kutta_fehlberg78.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/runge_kutta_fehlberg87.hpp [begin_description] Implementation of the Runge-Kutta-Fehlberg stepper with the generic stepper. [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2012-2013 Karsten Ahnert 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_RUNGE_KUTTA_FEHLBERG87_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_FEHLBERG87_HPP_INCLUDED #include <boost/fusion/container/vector.hpp> #include <boost/fusion/container/generation/make_vector.hpp> #include <boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/array.hpp> #include <boost/numeric/odeint/util/state_wrapper.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resizer.hpp> namespace boost { namespace numeric { namespace odeint { #ifndef DOXYGEN_SKIP template< class Value = double > struct rk78_coefficients_a1 : boost::array< Value , 1 > { rk78_coefficients_a1( void ) { (*this)[0] = static_cast< Value >( 2 )/static_cast< Value >( 27 ); } }; template< class Value = double > struct rk78_coefficients_a2 : boost::array< Value , 2 > { rk78_coefficients_a2( void ) { (*this)[0] = static_cast< Value >( 1 )/static_cast< Value >( 36 ); (*this)[1] = static_cast< Value >( 1 )/static_cast< Value >( 12 ); } }; template< class Value = double > struct rk78_coefficients_a3 : boost::array< Value , 3 > { rk78_coefficients_a3( void ) { (*this)[0] = static_cast< Value >( 1 )/static_cast< Value >( 24 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 1 )/static_cast< Value >( 8 ); } }; template< class Value = double > struct rk78_coefficients_a4 : boost::array< Value , 4 > { rk78_coefficients_a4( void ) { (*this)[0] = static_cast< Value >( 5 )/static_cast< Value >( 12 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( -25 )/static_cast< Value >( 16 ); (*this)[3] = static_cast< Value >( 25 )/static_cast< Value >( 16 ); } }; template< class Value = double > struct rk78_coefficients_a5 : boost::array< Value , 5 > { rk78_coefficients_a5( void ) { (*this)[0] = static_cast< Value >( 1 )/static_cast< Value >( 20 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( 1 )/static_cast< Value >( 4 ); (*this)[4] = static_cast< Value >( 1 )/static_cast< Value >( 5 ); } }; template< class Value = double > struct rk78_coefficients_a6 : boost::array< Value , 6 > { rk78_coefficients_a6( void ) { (*this)[0] = static_cast< Value >( -25 )/static_cast< Value >( 108 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( 125 )/static_cast< Value >( 108 ); (*this)[4] = static_cast< Value >( -65 )/static_cast< Value >( 27 ); (*this)[5] = static_cast< Value >( 125 )/static_cast< Value >( 54 ); } }; template< class Value = double > struct rk78_coefficients_a7 : boost::array< Value , 7 > { rk78_coefficients_a7( void ) { (*this)[0] = static_cast< Value >( 31 )/static_cast< Value >( 300 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( 0 ); (*this)[4] = static_cast< Value >( 61 )/static_cast< Value >( 225 ); (*this)[5] = static_cast< Value >( -2 )/static_cast< Value >( 9 ); (*this)[6] = static_cast< Value >( 13 )/static_cast< Value >( 900 ); } }; template< class Value = double > struct rk78_coefficients_a8 : boost::array< Value , 8 > { rk78_coefficients_a8( void ) { (*this)[0] = static_cast< Value >( 2 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( -53 )/static_cast< Value >( 6 ); (*this)[4] = static_cast< Value >( 704 )/static_cast< Value >( 45 ); (*this)[5] = static_cast< Value >( -107 )/static_cast< Value >( 9 ); (*this)[6] = static_cast< Value >( 67 )/static_cast< Value >( 90 ); (*this)[7] = static_cast< Value >( 3 ); } }; template< class Value = double > struct rk78_coefficients_a9 : boost::array< Value , 9 > { rk78_coefficients_a9( void ) { (*this)[0] = static_cast< Value >( -91 )/static_cast< Value >( 108 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( 23 )/static_cast< Value >( 108 ); (*this)[4] = static_cast< Value >( -976 )/static_cast< Value >( 135 ); (*this)[5] = static_cast< Value >( 311 )/static_cast< Value >( 54 ); (*this)[6] = static_cast< Value >( -19 )/static_cast< Value >( 60 ); (*this)[7] = static_cast< Value >( 17 )/static_cast< Value >( 6 ); (*this)[8] = static_cast< Value >( -1 )/static_cast< Value >( 12 ); } }; template< class Value = double > struct rk78_coefficients_a10 : boost::array< Value , 10 > { rk78_coefficients_a10( void ) { (*this)[0] = static_cast< Value >( 2383 )/static_cast< Value >( 4100 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( -341 )/static_cast< Value >( 164 ); (*this)[4] = static_cast< Value >( 4496 )/static_cast< Value >( 1025 ); (*this)[5] = static_cast< Value >( -301 )/static_cast< Value >( 82 ); (*this)[6] = static_cast< Value >( 2133 )/static_cast< Value >( 4100 ); (*this)[7] = static_cast< Value >( 45 )/static_cast< Value >( 82 ); (*this)[8] = static_cast< Value >( 45 )/static_cast< Value >( 164 ); (*this)[9] = static_cast< Value >( 18 )/static_cast< Value >( 41 ); } }; template< class Value = double > struct rk78_coefficients_a11 : boost::array< Value , 11 > { rk78_coefficients_a11( void ) { (*this)[0] = static_cast< Value >( 3 )/static_cast< Value >( 205 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( 0 ); (*this)[4] = static_cast< Value >( 0 ); (*this)[5] = static_cast< Value >( -6 )/static_cast< Value >( 41 ); (*this)[6] = static_cast< Value >( -3 )/static_cast< Value >( 205 ); (*this)[7] = static_cast< Value >( -3 )/static_cast< Value >( 41 ); (*this)[8] = static_cast< Value >( 3 )/static_cast< Value >( 41 ); (*this)[9] = static_cast< Value >( 6 )/static_cast< Value >( 41 ); (*this)[10] = static_cast< Value >( 0 ); } }; template< class Value = double > struct rk78_coefficients_a12 : boost::array< Value , 12 > { rk78_coefficients_a12( void ) { (*this)[0] = static_cast< Value >( -1777 )/static_cast< Value >( 4100 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( -341 )/static_cast< Value >( 164 ); (*this)[4] = static_cast< Value >( 4496 )/static_cast< Value >( 1025 ); (*this)[5] = static_cast< Value >( -289 )/static_cast< Value >( 82 ); (*this)[6] = static_cast< Value >( 2193 )/static_cast< Value >( 4100 ); (*this)[7] = static_cast< Value >( 51 )/static_cast< Value >( 82 ); (*this)[8] = static_cast< Value >( 33 )/static_cast< Value >( 164 ); (*this)[9] = static_cast< Value >( 12 )/static_cast< Value >( 41 ); (*this)[10] = static_cast< Value >( 0 ); (*this)[11] = static_cast< Value >( 1 ); } }; template< class Value = double > struct rk78_coefficients_b : boost::array< Value , 13 > { rk78_coefficients_b( void ) { (*this)[0] = static_cast< Value >( 0 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( 0 ); (*this)[4] = static_cast< Value >( 0 ); (*this)[5] = static_cast< Value >( 34 )/static_cast<Value>( 105 ); (*this)[6] = static_cast< Value >( 9 )/static_cast<Value>( 35 ); (*this)[7] = static_cast< Value >( 9 )/static_cast<Value>( 35 ); (*this)[8] = static_cast< Value >( 9 )/static_cast<Value>( 280 ); (*this)[9] = static_cast< Value >( 9 )/static_cast<Value>( 280 ); (*this)[10] = static_cast< Value >( 0 ); (*this)[11] = static_cast< Value >( 41 )/static_cast<Value>( 840 ); (*this)[12] = static_cast< Value >( 41 )/static_cast<Value>( 840 ); } }; template< class Value = double > struct rk78_coefficients_db : boost::array< Value , 13 > { rk78_coefficients_db( void ) { (*this)[0] = static_cast< Value >( 0 ) - static_cast< Value >( 41 )/static_cast<Value>( 840 ); (*this)[1] = static_cast< Value >( 0 ); (*this)[2] = static_cast< Value >( 0 ); (*this)[3] = static_cast< Value >( 0 ); (*this)[4] = static_cast< Value >( 0 ); (*this)[5] = static_cast< Value >( 0 ); (*this)[6] = static_cast< Value >( 0 ); (*this)[7] = static_cast< Value >( 0 ); (*this)[8] = static_cast< Value >( 0 ); (*this)[9] = static_cast< Value >( 0 ); (*this)[10] = static_cast< Value >( 0 ) - static_cast< Value >( 41 )/static_cast<Value>( 840 ); (*this)[11] = static_cast< Value >( 41 )/static_cast<Value>( 840 ); (*this)[12] = static_cast< Value >( 41 )/static_cast<Value>( 840 ); } }; template< class Value = double > struct rk78_coefficients_c : boost::array< Value , 13 > { rk78_coefficients_c( void ) { (*this)[0] = static_cast< Value >( 0 ); (*this)[1] = static_cast< Value >( 2 )/static_cast< Value >( 27 ); (*this)[2] = static_cast< Value >( 1 )/static_cast< Value >( 9 ); (*this)[3] = static_cast< Value >( 1 )/static_cast<Value>( 6 ); (*this)[4] = static_cast< Value >( 5 )/static_cast<Value>( 12 ); (*this)[5] = static_cast< Value >( 1 )/static_cast<Value>( 2 ); (*this)[6] = static_cast< Value >( 5 )/static_cast<Value>( 6 ); (*this)[7] = static_cast< Value >( 1 )/static_cast<Value>( 6 ); (*this)[8] = static_cast< Value >( 2 )/static_cast<Value>( 3 ); (*this)[9] = static_cast< Value >( 1 )/static_cast<Value>( 3 ); (*this)[10] = static_cast< Value >( 1 ); (*this)[11] = static_cast< Value >( 0 ); (*this)[12] = static_cast< Value >( 1 ); } }; #endif // DOXYGEN_SKIP template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class runge_kutta_fehlberg78 : public explicit_error_generic_rk< 13 , 8 , 8 , 7 , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else class runge_kutta_fehlberg78 : public explicit_error_generic_rk #endif { public: #ifndef DOXYGEN_SKIP typedef explicit_error_generic_rk< 13 , 8 , 8 , 7 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; #ifndef DOXYGEN_SKIP typedef typename stepper_base_type::stepper_type stepper_type; typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; #endif // DOXYGEN_SKIP runge_kutta_fehlberg78( const algebra_type &algebra = algebra_type() ) : stepper_base_type( boost::fusion::make_vector( rk78_coefficients_a1<Value>() , rk78_coefficients_a2<Value>() , rk78_coefficients_a3<Value>() , rk78_coefficients_a4<Value>() , rk78_coefficients_a5<Value>() , rk78_coefficients_a6<Value>() , rk78_coefficients_a7<Value>() , rk78_coefficients_a8<Value>() , rk78_coefficients_a9<Value>() , rk78_coefficients_a10<Value>() , rk78_coefficients_a11<Value>() , rk78_coefficients_a12<Value>() ) , rk78_coefficients_b<Value>() , rk78_coefficients_db<Value>() , rk78_coefficients_c<Value>() , algebra ) { } }; /************* DOXYGEN *************/ /** * \class runge_kutta_fehlberg78 * \brief The Runge-Kutta Fehlberg 78 method. * * The Runge-Kutta Fehlberg 78 method is a standard method for high-precision applications. * The method is explicit and fulfills the Error Stepper concept. Step size control * is provided but continuous output is not available for this method. * * This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern). * Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation. * For more details see explicit_error_stepper_base and explicit_error_generic_rk. * * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn runge_kutta_fehlberg78::runge_kutta_fehlberg78( const algebra_type &algebra ) * \brief Constructs the runge_kutta_cash_fehlberg78 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. */ } } } #endif //BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_FEHLBERG87_HPP_INCLUDED PK 䄟[r�� ( stepper/generation/make_dense_output.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation/make_dense_output.hpp [begin_description] Factory function to simplify the creation of dense output steppers from error steppers. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_GENERATION_MAKE_DENSE_OUTPUT_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_DENSE_OUTPUT_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { // default template for the dense output template< class Stepper > struct get_dense_output { }; // default dense output factory template< class Stepper , class DenseOutput > struct dense_output_factory { DenseOutput operator()( typename Stepper::value_type abs_error , typename Stepper::value_type rel_error , const Stepper &stepper ) { return DenseOutput( abs_error , rel_error , stepper ); } DenseOutput operator()( typename Stepper::value_type abs_error , typename Stepper::value_type rel_error , typename Stepper::time_type max_dt , const Stepper &stepper ) { return DenseOutput( abs_error , rel_error , max_dt , stepper ); } }; namespace result_of { template< class Stepper > struct make_dense_output { typedef typename get_dense_output< Stepper >::type type; }; } template< class Stepper > typename result_of::make_dense_output< Stepper >::type make_dense_output( typename Stepper::value_type abs_error , typename Stepper::value_type rel_error , const Stepper &stepper = Stepper() ) { typedef Stepper stepper_type; typedef typename result_of::make_dense_output< stepper_type >::type dense_output_type; typedef dense_output_factory< stepper_type , dense_output_type > factory_type; factory_type factory; return factory( abs_error , rel_error , stepper ); } template< class Stepper > typename result_of::make_dense_output< Stepper >::type make_dense_output( typename Stepper::value_type abs_error , typename Stepper::value_type rel_error , typename Stepper::time_type max_dt , const Stepper &stepper = Stepper() ) { typedef Stepper stepper_type; typedef typename result_of::make_dense_output< stepper_type >::type dense_output_type; typedef dense_output_factory< stepper_type , dense_output_type > factory_type; factory_type factory; return factory( abs_error , rel_error , max_dt, stepper ); } } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_DENSE_OUTPUT_HPP_INCLUDED PK 䄟[�}� � D stepper/generation/generation_controlled_adams_bashforth_moulton.hppnu �[��� /* boost/numeric/odeint/stepper/detail/generation_controlled_adams_bashforth_moulton.hpp [begin_description] Spezialization of the generation functions for creation of the controlled adams bashforth moulton stepper. [end_description] Copyright 2017 Valentin Noah Hartmann 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 GENERATION_CONTROLLED_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED #define GENERATION_CONTROLLED_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED #include <boost/numeric/odeint/stepper/adaptive_adams_bashforth_moulton.hpp> #include <boost/numeric/odeint/stepper/controlled_adams_bashforth_moulton.hpp> #include <boost/numeric/odeint/stepper/generation/make_controlled.hpp> namespace boost { namespace numeric { namespace odeint { template< size_t Steps, class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resizer > struct get_controller< adaptive_adams_bashforth_moulton< Steps, State , Value , Deriv , Time , Algebra , Operations , Resizer > > { typedef adaptive_adams_bashforth_moulton<Steps, State, Value, Deriv, Time, Algebra, Operations, Resizer> stepper_type; typedef controlled_adams_bashforth_moulton< stepper_type > type; }; // controller factory for controlled_adams_bashforth_moulton template< class Stepper > struct controller_factory< Stepper , controlled_adams_bashforth_moulton< Stepper > > { typedef Stepper stepper_type; typedef controlled_adams_bashforth_moulton< stepper_type > controller_type; typedef typename controller_type::step_adjuster_type step_adjuster_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::value_type time_type; controller_type operator()( value_type abs_error , value_type rel_error , const stepper_type &stepper ) { return controller_type(step_adjuster_type(abs_error, rel_error)); } controller_type operator()( value_type abs_error , value_type rel_error , time_type max_dt, const stepper_type &stepper ) { return controller_type( step_adjuster_type(abs_error, rel_error, max_dt)); } }; } } } #endifPK 䄟[Nh��N N A stepper/generation/generation_runge_kutta_cash_karp54_classic.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp [begin_description] Enable the factory functions for the controller and the dense output of the Runge-Kutta-Cash-Karp 54 method with the classical implementation. [end_description] Copyright 2011 Karsten Ahnert Copyright 2011 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_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp> #include <boost/numeric/odeint/stepper/generation/make_controlled.hpp> namespace boost { namespace numeric { namespace odeint { // Specializations for runge_kutta_cash_karp54 template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize > struct get_controller< runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resize > > { typedef runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type; typedef controlled_runge_kutta< stepper_type > type; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED PK 䄟[�8k - stepper/generation/generation_rosenbrock4.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp [begin_description] Enable the factory functions for the controller and the dense output of the Rosenbrock4 method. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_GENERATION_GENERATION_ROSENBROCK4_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_ROSENBROCK4_HPP_INCLUDED #include <boost/numeric/odeint/stepper/rosenbrock4.hpp> #include <boost/numeric/odeint/stepper/rosenbrock4_controller.hpp> #include <boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp> namespace boost { namespace numeric { namespace odeint { template< class Value , class Coefficients , class Resize > struct get_controller< rosenbrock4< Value , Coefficients , Resize > > { typedef rosenbrock4< Value , Coefficients , Resize > stepper_type; typedef rosenbrock4_controller< stepper_type > type; }; template< class Value , class Coefficients , class Resize > struct get_dense_output< rosenbrock4< Value , Coefficients , Resize > > { typedef rosenbrock4< Value , Coefficients , Resize > stepper_type; typedef rosenbrock4_controller< stepper_type > controller_type; typedef rosenbrock4_dense_output< controller_type > type; }; // controller factory for controlled_runge_kutta template< class Stepper > struct dense_output_factory< Stepper , rosenbrock4_dense_output< rosenbrock4_controller< Stepper > > > { typedef Stepper stepper_type; typedef rosenbrock4_controller< stepper_type > controller_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::time_type time_type; typedef rosenbrock4_dense_output< controller_type > dense_output_type; dense_output_type operator()( value_type abs_error , value_type rel_error , const stepper_type &stepper ) { return dense_output_type( controller_type( abs_error , rel_error , stepper ) ); } dense_output_type operator()( value_type abs_error , value_type rel_error , time_type max_dt, const stepper_type &stepper ) { return dense_output_type( controller_type( abs_error , rel_error , max_dt , stepper ) ); } }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_ROSENBROCK4_HPP_INCLUDED PK 䄟[�ybL( ( 8 stepper/generation/generation_controlled_runge_kutta.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp [begin_description] Specialization of the controller factory for the controlled_runge_kutta class. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_GENERATION_GENERATION_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/generation/make_controlled.hpp> namespace boost { namespace numeric { namespace odeint { // controller factory for controlled_runge_kutta template< class Stepper > struct controller_factory< Stepper , controlled_runge_kutta< Stepper > > { typedef Stepper stepper_type; typedef controlled_runge_kutta< stepper_type > controller_type; typedef typename controller_type::error_checker_type error_checker_type; typedef typename controller_type::step_adjuster_type step_adjuster_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::value_type time_type; controller_type operator()( value_type abs_error , value_type rel_error , const stepper_type &stepper ) { return controller_type( error_checker_type( abs_error , rel_error ) , step_adjuster_type() , stepper ); } controller_type operator()( value_type abs_error , value_type rel_error , time_type max_dt, const stepper_type &stepper ) { return controller_type( error_checker_type( abs_error , rel_error ) , step_adjuster_type(max_dt) , stepper ); } }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED PK 䄟[N�. 4 stepper/generation/generation_runge_kutta_dopri5.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp [begin_description] Enable the factory functions for the controller and the dense output of the Runge-Kutta-Dormand-Prince5 method. [end_description] Copyright 2011 Karsten Ahnert Copyright 2011 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_GENERATION_GENERATION_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp> #include <boost/numeric/odeint/stepper/generation/make_controlled.hpp> #include <boost/numeric/odeint/stepper/generation/make_dense_output.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize > struct get_controller< runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resize > > { typedef runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type; typedef controlled_runge_kutta< stepper_type > type; }; template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize > struct get_dense_output< runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resize > > { typedef runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type; typedef controlled_runge_kutta< stepper_type > controller_type; typedef dense_output_runge_kutta< controller_type > type; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED PK 䄟['�� � 8 stepper/generation/generation_runge_kutta_fehlberg78.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp [begin_description] Enable the factory functions for the controller and the dense output of the Runge-Kutta-Fehlberg 78 method. [end_description] Copyright 2011 Karsten Ahnert Copyright 2011 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_GENERATION_GENERATION_RUNGE_KUTTA_FEHLBERG78_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_FEHLBERG78_HPP_INCLUDED #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp> #include <boost/numeric/odeint/stepper/generation/make_controlled.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize > struct get_controller< runge_kutta_fehlberg78< State , Value , Deriv , Time , Algebra , Operations , Resize > > { typedef runge_kutta_fehlberg78< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type; typedef controlled_runge_kutta< stepper_type > type; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_FEHLBERG78_HPP_INCLUDED PK 䄟[��8 8 : stepper/generation/generation_dense_output_runge_kutta.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp [begin_description] Specialization of the controller factory for the dense_output_runge_kutta class. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_GENERATION_GENERATION_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/generation/make_dense_output.hpp> namespace boost { namespace numeric { namespace odeint { // controller factory for controlled_runge_kutta template< class Stepper > struct dense_output_factory< Stepper , dense_output_runge_kutta< controlled_runge_kutta< Stepper > > > { typedef Stepper stepper_type; typedef controlled_runge_kutta< stepper_type > controller_type; typedef typename controller_type::error_checker_type error_checker_type; typedef typename controller_type::step_adjuster_type step_adjuster_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::time_type time_type; typedef dense_output_runge_kutta< controller_type > dense_output_type; dense_output_type operator()( value_type abs_error , value_type rel_error , const stepper_type &stepper ) { return dense_output_type( controller_type( error_checker_type( abs_error , rel_error ) , step_adjuster_type() , stepper ) ); } dense_output_type operator()( value_type abs_error , value_type rel_error , time_type max_dt , const stepper_type &stepper ) { return dense_output_type( controller_type( error_checker_type( abs_error , rel_error) , step_adjuster_type( max_dt ) , stepper ) ); } }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED PK 䄟[�N�� � & stepper/generation/make_controlled.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation/make_controlled.hpp [begin_description] Factory function to simplify the creation of controlled steppers from error steppers. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_GENERATION_MAKE_CONTROLLED_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_CONTROLLED_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { // default template for the controller template< class Stepper > struct get_controller { }; // default controller factory template< class Stepper , class Controller > struct controller_factory { Controller operator()( typename Stepper::value_type abs_error , typename Stepper::value_type rel_error , const Stepper &stepper ) { return Controller( abs_error , rel_error , stepper ); } Controller operator()( typename Stepper::value_type abs_error , typename Stepper::value_type rel_error , typename Stepper::time_type max_dt , const Stepper &stepper ) { return Controller( abs_error , rel_error , max_dt, stepper ); } }; namespace result_of { template< class Stepper > struct make_controlled { typedef typename get_controller< Stepper >::type type; }; } template< class Stepper > typename result_of::make_controlled< Stepper >::type make_controlled( typename Stepper::value_type abs_error , typename Stepper::value_type rel_error , const Stepper & stepper = Stepper() ) { typedef Stepper stepper_type; typedef typename result_of::make_controlled< stepper_type >::type controller_type; typedef controller_factory< stepper_type , controller_type > factory_type; factory_type factory; return factory( abs_error , rel_error , stepper ); } template< class Stepper > typename result_of::make_controlled< Stepper >::type make_controlled( typename Stepper::value_type abs_error , typename Stepper::value_type rel_error , typename Stepper::time_type max_dt , const Stepper & stepper = Stepper() ) { typedef Stepper stepper_type; typedef typename result_of::make_controlled< stepper_type >::type controller_type; typedef controller_factory< stepper_type , controller_type > factory_type; factory_type factory; return factory( abs_error , rel_error , max_dt, stepper ); } } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_CONTROLLED_HPP_INCLUDED PK 䄟[�55� � 9 stepper/generation/generation_runge_kutta_cash_karp54.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp [begin_description] Enable the factory functions for the controller and the dense output of the Runge-Kutta-Cash-Karp 54 method. [end_description] Copyright 2011 Karsten Ahnert Copyright 2011 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_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp> #include <boost/numeric/odeint/stepper/generation/make_controlled.hpp> namespace boost { namespace numeric { namespace odeint { // Specializations for runge_kutta_cash_karp54 template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize > struct get_controller< runge_kutta_cash_karp54< State , Value , Deriv , Time , Algebra , Operations , Resize > > { typedef runge_kutta_cash_karp54< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type; typedef controlled_runge_kutta< stepper_type > type; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED PK 䄟[���� � stepper/runge_kutta4.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/runge_kutta4.hpp [begin_description] Implementation of the classical Runge-Kutta stepper with the generic stepper. [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_RUNGE_KUTTA4_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_HPP_INCLUDED #include <boost/fusion/container/vector.hpp> #include <boost/fusion/container/generation/make_vector.hpp> #include <boost/numeric/odeint/stepper/explicit_generic_rk.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/array.hpp> #include <boost/numeric/odeint/util/resizer.hpp> namespace boost { namespace numeric { namespace odeint { #ifndef DOXYGEN_SKIP template< class Value = double > struct rk4_coefficients_a1 : boost::array< Value , 1 > { rk4_coefficients_a1( void ) { (*this)[0] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ); } }; template< class Value = double > struct rk4_coefficients_a2 : boost::array< Value , 2 > { rk4_coefficients_a2( void ) { (*this)[0] = static_cast<Value>(0); (*this)[1] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ); } }; template< class Value = double > struct rk4_coefficients_a3 : boost::array< Value , 3 > { rk4_coefficients_a3( void ) { (*this)[0] = static_cast<Value>(0); (*this)[1] = static_cast<Value>(0); (*this)[2] = static_cast<Value>(1); } }; template< class Value = double > struct rk4_coefficients_b : boost::array< Value , 4 > { rk4_coefficients_b( void ) { (*this)[0] = static_cast<Value>(1)/static_cast<Value>(6); (*this)[1] = static_cast<Value>(1)/static_cast<Value>(3); (*this)[2] = static_cast<Value>(1)/static_cast<Value>(3); (*this)[3] = static_cast<Value>(1)/static_cast<Value>(6); } }; template< class Value = double > struct rk4_coefficients_c : boost::array< Value , 4 > { rk4_coefficients_c( void ) { (*this)[0] = static_cast<Value>(0); (*this)[1] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ); (*this)[2] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ); (*this)[3] = static_cast<Value>(1); } }; #endif template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class runge_kutta4 : public explicit_generic_rk< 4 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else class runge_kutta4 : public explicit_generic_rk #endif { public: #ifndef DOXYGEN_SKIP typedef explicit_generic_rk< 4 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; #ifndef DOXYGEN_SKIP typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; typedef typename stepper_base_type::stepper_type stepper_type; #endif runge_kutta4( const algebra_type &algebra = algebra_type() ) : stepper_base_type( boost::fusion::make_vector( rk4_coefficients_a1<Value>() , rk4_coefficients_a2<Value>() , rk4_coefficients_a3<Value>() ) , rk4_coefficients_b<Value>() , rk4_coefficients_c<Value>() , algebra ) { } }; /** * \class runge_kutta4 * \brief The classical Runge-Kutta stepper of fourth order. * * The Runge-Kutta method of fourth order is one standard method for * solving ordinary differential equations and is widely used, see also * <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods">en.wikipedia.org/wiki/Runge-Kutta_methods</a> * The method is explicit and fulfills the Stepper concept. Step size control * or continuous output are not provided. * * This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern). * Furthermore, it derivs from explicit_generic_rk which is a generic Runge-Kutta algorithm. For more details see * explicit_stepper_base and explicit_generic_rk. * * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn runge_kutta4::runge_kutta4( const algebra_type &algebra = algebra_type() ) * \brief Constructs the runge_kutta4 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. */ } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_HPP_INCLUDED PK 䄟[�1�MV V $ stepper/detail/pid_step_adjuster.hppnu �[��� /* boost/numeric/odeint/stepper/detail/pid_step_adjuster.hpp [begin_description] Implementation of the stepsize controller for the controlled adams bashforth moulton stepper. [end_description] Copyright 2017 Valentin Noah Hartmann 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_DETAIL_PID_STEP_ADJUSTER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_PID_STEP_ADJUSTER_HPP_INCLUDED #include <boost/numeric/odeint/stepper/detail/rotating_buffer.hpp> #include <boost/numeric/odeint/stepper/detail/pid_step_adjuster_coefficients.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <math.h> namespace boost { namespace numeric { namespace odeint { namespace detail { template< class Value = double, class Time = double > struct pid_op { public: typedef Value value_type; typedef Time time_type; const double beta1; const double beta2; const double beta3; const double alpha1; const double alpha2; const time_type dt1; const time_type dt2; const time_type dt3; const size_t m_steps; pid_op(const size_t steps, const double _dt1, const double _dt2, const double _dt3, const double b1 = 1, const double b2 = 0, const double b3 = 0, const double a1 = 0, const double a2 = 0) :beta1(b1), beta2(b2), beta3(b3), alpha1(a1), alpha2(a2), dt1(_dt1), dt2(_dt2), dt3(_dt3), m_steps(steps) {}; template<class T1, class T2, class T3, class T4> void operator()(T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4) { using std::abs; t1 = adapted_pow(abs(t2), -beta1/(m_steps + 1)) * adapted_pow(abs(t3), -beta2/(m_steps + 1)) * adapted_pow(abs(t4), -beta3/(m_steps + 1)) * adapted_pow(abs(dt1/dt2), -alpha1/(m_steps + 1))* adapted_pow(abs(dt2/dt3), -alpha2/(m_steps + 1)); t1 = 1/t1; }; template<class T1, class T2> void operator()(T1 &t1, const T2 &t2) { using std::abs; t1 = adapted_pow(abs(t2), -beta1/(m_steps + 1)); t1 = 1/t1; }; private: template<class T> inline value_type adapted_pow(T base, double exp) { if(exp == 0) { return 1; } else if (exp > 0) { return pow(base, exp); } else { return 1/pow(base, -exp); } }; }; template< class State, class Value = double, class Deriv = State, class Time = double, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< Deriv >::operations_type, size_t Type = BASIC > struct pid_step_adjuster { public: static double threshold() { return 0.9; }; typedef State state_type; typedef Value value_type; typedef Deriv deriv_type; typedef Time time_type; typedef Algebra algebra_type; typedef Operations operations_type; typedef rotating_buffer<state_type, 3> error_storage_type; typedef rotating_buffer<time_type, 3> time_storage_type; typedef pid_step_adjuster_coefficients<Type> coeff_type; pid_step_adjuster(double abs_tol = 1e-6, double rel_tol = 1e-6, time_type dtmax = 1.0) :m_dtmax(dtmax), m_error_storage(), m_dt_storage(), m_init(0), m_abs_tol(abs_tol), m_rel_tol(rel_tol) {}; time_type adjust_stepsize(const size_t steps, time_type dt, state_type &err, const state_type &x, const deriv_type &dxdt) { using std::abs; m_algebra.for_each3( err , x , dxdt , typename operations_type::template rel_error< value_type >( m_abs_tol , m_rel_tol , 1.0 , 1.0 * abs(get_unit_value( dt )) ) ); m_error_storage[0] = err; m_dt_storage[0] = dt; if(m_init >= 2) { m_algebra.for_each4(err, m_error_storage[0], m_error_storage[1], m_error_storage[2], pid_op<>(steps, m_dt_storage[0], m_dt_storage[1], m_dt_storage[2], m_coeff[0], m_coeff[1], m_coeff[2], m_coeff[3], m_coeff[4])); } else { m_algebra.for_each2(err, m_error_storage[0], pid_op<>(steps, m_dt_storage[0], m_dt_storage[1], m_dt_storage[2], 0.7)); } value_type ratio = 1 / m_algebra.norm_inf(err); value_type kappa = 1.0; ratio = 1.0 + kappa*atan((ratio - 1) / kappa); if(ratio*dt >= m_dtmax) { ratio = m_dtmax / dt; } if(ratio >= threshold()) { m_error_storage.rotate(); m_dt_storage.rotate(); ++m_init; } else { m_init = 0; } return dt * static_cast<time_type>(ratio); }; private: algebra_type m_algebra; time_type m_dtmax; error_storage_type m_error_storage; time_storage_type m_dt_storage; size_t m_init; double m_abs_tol; double m_rel_tol; coeff_type m_coeff; }; } // detail } // odeint } // numeric } // boost #endifPK 䄟[�ѬJJ J ' stepper/detail/generic_rk_algorithm.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp [begin_description] Implementation of the generic Runge-Kutta method. [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2011-2012 Karsten Ahnert 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_DETAIL_GENERIC_RK_ALGORITHM_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_ALGORITHM_HPP_INCLUDED #include <boost/static_assert.hpp> #include <boost/mpl/vector.hpp> #include <boost/mpl/push_back.hpp> #include <boost/mpl/for_each.hpp> #include <boost/mpl/range_c.hpp> #include <boost/mpl/copy.hpp> #include <boost/mpl/size_t.hpp> #include <boost/fusion/algorithm.hpp> #include <boost/fusion/iterator.hpp> #include <boost/fusion/mpl.hpp> #include <boost/fusion/sequence.hpp> #include <boost/array.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp> #include <boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp> #include <boost/numeric/odeint/util/bind.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { template< class T , class Constant > struct array_wrapper { typedef const typename boost::array< T , Constant::value > type; }; template< class T , size_t i > struct stage { T c; boost::array< T , i > a; }; template< class T , class Constant > struct stage_wrapper { typedef stage< T , Constant::value > type; }; template< size_t StageCount, class Value , class Algebra , class Operations > class generic_rk_algorithm { public: typedef mpl::range_c< size_t , 1 , StageCount > stage_indices; typedef typename boost::fusion::result_of::as_vector < typename boost::mpl::copy < stage_indices , boost::mpl::inserter < boost::mpl::vector0< > , boost::mpl::push_back< boost::mpl::_1 , array_wrapper< Value , boost::mpl::_2 > > > >::type >::type coef_a_type; typedef boost::array< Value , StageCount > coef_b_type; typedef boost::array< Value , StageCount > coef_c_type; typedef typename boost::fusion::result_of::as_vector < typename boost::mpl::push_back < typename boost::mpl::copy < stage_indices, boost::mpl::inserter < boost::mpl::vector0<> , boost::mpl::push_back< boost::mpl::_1 , stage_wrapper< Value , boost::mpl::_2 > > > >::type , stage< Value , StageCount > >::type >::type stage_vector_base; struct stage_vector : public stage_vector_base { struct do_insertion { stage_vector_base &m_base; const coef_a_type &m_a; const coef_c_type &m_c; do_insertion( stage_vector_base &base , const coef_a_type &a , const coef_c_type &c ) : m_base( base ) , m_a( a ) , m_c( c ) { } template< class Index > void operator()( Index ) const { //boost::fusion::at< Index >( m_base ) = stage< double , Index::value+1 , intermediate_stage >( m_c[ Index::value ] , boost::fusion::at< Index >( m_a ) ); boost::fusion::at< Index >( m_base ).c = m_c[ Index::value ]; boost::fusion::at< Index >( m_base ).a = boost::fusion::at< Index >( m_a ); } }; struct print_butcher { const stage_vector_base &m_base; std::ostream &m_os; print_butcher( const stage_vector_base &base , std::ostream &os ) : m_base( base ) , m_os( os ) { } template<class Index> void operator()(Index) const { m_os << boost::fusion::at<Index>(m_base).c << " | "; for( size_t i=0 ; i<Index::value ; ++i ) m_os << boost::fusion::at<Index>(m_base).a[i] << " "; m_os << std::endl; } }; stage_vector( const coef_a_type &a , const coef_b_type &b , const coef_c_type &c ) { typedef boost::mpl::range_c< size_t , 0 , StageCount-1 > indices; boost::mpl::for_each< indices >( do_insertion( *this , a , c ) ); boost::fusion::at_c< StageCount - 1 >( *this ).c = c[ StageCount - 1 ]; boost::fusion::at_c< StageCount - 1 >( *this ).a = b; } void print( std::ostream &os ) const { typedef boost::mpl::range_c< size_t , 0 , StageCount > indices; boost::mpl::for_each< indices >( print_butcher( *this , os ) ); } }; template< class System , class StateIn , class StateTemp , class DerivIn , class Deriv , class StateOut , class Time > struct calculate_stage { Algebra &algebra; System &system; const StateIn &x; StateTemp &x_tmp; StateOut &x_out; const DerivIn &dxdt; Deriv *F; Time t; Time dt; calculate_stage( Algebra &_algebra , System &_system , const StateIn &_x , const DerivIn &_dxdt , StateOut &_out , StateTemp &_x_tmp , Deriv *_F , Time _t , Time _dt ) : algebra( _algebra ) , system( _system ) , x( _x ) , x_tmp( _x_tmp ) , x_out( _out) , dxdt( _dxdt ) , F( _F ) , t( _t ) , dt( _dt ) {} template< typename T , size_t stage_number > void inline operator()( stage< T , stage_number > const &stage ) const //typename stage_fusion_wrapper< T , mpl::size_t< stage_number > , intermediate_stage >::type const &stage ) const { if( stage_number > 1 ) { #ifdef BOOST_MSVC #pragma warning( disable : 4307 34 ) #endif system( x_tmp , F[stage_number-2].m_v , t + stage.c * dt ); #ifdef BOOST_MSVC #pragma warning( default : 4307 34 ) #endif } //std::cout << stage_number-2 << ", t': " << t + stage.c * dt << std::endl; if( stage_number < StageCount ) detail::template generic_rk_call_algebra< stage_number , Algebra >()( algebra , x_tmp , x , dxdt , F , detail::generic_rk_scale_sum< stage_number , Operations , Value , Time >( stage.a , dt) ); // algebra_type::template for_eachn<stage_number>( x_tmp , x , dxdt , F , // typename operations_type::template scale_sumn< stage_number , time_type >( stage.a , dt ) ); else detail::template generic_rk_call_algebra< stage_number , Algebra >()( algebra , x_out , x , dxdt , F , detail::generic_rk_scale_sum< stage_number , Operations , Value , Time >( stage.a , dt ) ); // algebra_type::template for_eachn<stage_number>( x_out , x , dxdt , F , // typename operations_type::template scale_sumn< stage_number , time_type >( stage.a , dt ) ); } }; generic_rk_algorithm( const coef_a_type &a , const coef_b_type &b , const coef_c_type &c ) : m_stages( a , b , c ) { } template< class System , class StateIn , class DerivIn , class Time , class StateOut , class StateTemp , class Deriv > void inline do_step( Algebra &algebra , System system , const StateIn &in , const DerivIn &dxdt , Time t , StateOut &out , Time dt , StateTemp &x_tmp , Deriv F[StageCount-1] ) const { typedef typename odeint::unwrap_reference< System >::type unwrapped_system_type; unwrapped_system_type &sys = system; boost::fusion::for_each( m_stages , calculate_stage< unwrapped_system_type , StateIn , StateTemp , DerivIn , Deriv , StateOut , Time > ( algebra , sys , in , dxdt , out , x_tmp , F , t , dt ) ); } private: stage_vector m_stages; }; } } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_ALGORITHM_HPP_INCLUDED PK 䄟[�>g>G& G& ( stepper/detail/generic_rk_operations.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp [begin_description] Operations caller for the generic Runge Kutta method. [end_description] Copyright 2011 Mario Mulansky Copyright 2011-2012 Karsten Ahnert 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_DETAIL_GENERIC_RK_OPERATIONS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_OPERATIONS_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { namespace detail { template< size_t StageNumber , class Operations , class Fac , class Time > struct generic_rk_scale_sum; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 1 , Operations , Fac , Time > : public Operations::template scale_sum2< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,1> &a , Time dt ) : Operations::template scale_sum2< Fac , Time >( 1.0 , a[0]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 2 , Operations , Fac , Time > : public Operations::template scale_sum3< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,2> &a , Time dt ) : Operations::template scale_sum3< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 3 , Operations , Fac , Time > : public Operations::template scale_sum4< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,3> &a , Time dt ) : Operations::template scale_sum4< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 4 , Operations , Fac , Time > : public Operations::template scale_sum5< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,4> &a , Time dt ) : Operations::template scale_sum5< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 5 , Operations , Fac , Time > : public Operations::template scale_sum6< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,5> &a , Time dt ) : Operations::template scale_sum6< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 6 , Operations , Fac , Time > : public Operations::template scale_sum7< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,6> &a , Time dt ) : Operations::template scale_sum7< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 7 , Operations , Fac , Time > : public Operations::template scale_sum8< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,7> &a , Time dt ) : Operations::template scale_sum8< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt , a[6]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 8 , Operations , Fac , Time > : public Operations::template scale_sum9< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,8> &a , Time dt ) : Operations::template scale_sum9< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt , a[6]*dt , a[7]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 9 , Operations , Fac , Time > : public Operations::template scale_sum10< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,9> &a , Time dt ) : Operations::template scale_sum10< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 10 , Operations , Fac , Time > : public Operations::template scale_sum11< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,10> &a , Time dt ) : Operations::template scale_sum11< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 11 , Operations , Fac , Time > : public Operations::template scale_sum12< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,11> &a , Time dt ) : Operations::template scale_sum12< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt , a[10]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 12 , Operations , Fac , Time > : public Operations::template scale_sum13< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,12> &a , Time dt ) : Operations::template scale_sum13< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt , a[10]*dt , a[11]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum< 13 , Operations , Fac , Time > : public Operations::template scale_sum14< Fac , Time > { generic_rk_scale_sum( const boost::array<Fac,13> &a , Time dt ) : Operations::template scale_sum14< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt , a[10]*dt , a[11]*dt , a[12]*dt ) { } typedef void result_type; }; // for error estimates template< size_t StageNumber , class Operations , class Fac , class Time > struct generic_rk_scale_sum_err; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum_err< 1 , Operations , Fac , Time > : public Operations::template scale_sum1< Time > { generic_rk_scale_sum_err( const boost::array<Fac,1> &a , Time dt ) : Operations::template scale_sum1< Time >( a[0]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum_err< 2 , Operations , Fac , Time > : public Operations::template scale_sum2< Time > { generic_rk_scale_sum_err( const boost::array<Fac,2> &a , Time dt ) : Operations::template scale_sum2< Time >( a[0]*dt , a[1]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum_err< 3 , Operations , Fac , Time > : public Operations::template scale_sum3< Time > { generic_rk_scale_sum_err( const boost::array<Fac,3> &a , Time dt ) : Operations::template scale_sum3< Time >( a[0]*dt , a[1]*dt , a[2]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum_err< 4 , Operations , Fac , Time > : public Operations::template scale_sum4< Time > { generic_rk_scale_sum_err( const boost::array<Fac,4> &a , Time dt ) : Operations::template scale_sum4< Time >( a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum_err< 5 , Operations , Fac , Time > : public Operations::template scale_sum5< Fac > { generic_rk_scale_sum_err( const boost::array<Fac,5> &a , Time dt ) : Operations::template scale_sum5< Time >( a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt ) { } typedef void result_type; }; template< class Operations , class Fac , class Time > struct generic_rk_scale_sum_err< 6 , Operations , Fac , Time > : public Operations::template scale_sum6< Time > { generic_rk_scale_sum_err( const boost::array<Fac,6> &a , Time dt ) : Operations::template scale_sum6< Time >( a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt ) { } typedef void result_type; }; // for rk87 template< class Operations , class Fac , class Time > struct generic_rk_scale_sum_err< 13 , Operations , Fac , Time > : public Operations::template scale_sum13< Time > { generic_rk_scale_sum_err( const boost::array<Fac,13> &a , Time dt ) : Operations::template scale_sum13< Time >( a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt , a[10]*dt , a[11]*dt , a[12]*dt ) { } typedef void result_type; }; } } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_OPERATIONS_HPP_INCLUDED PK 䄟[�CҪ) ) * stepper/detail/generic_rk_call_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp [begin_description] Algebra caller for the generic Runge-Kutta methods. [end_description] Copyright 2011-2012 Mario Mulansky Copyright 2011-2012 Karsten Ahnert 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_DETAIL_GENERIC_RK_CALL_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_CALL_ALGEBRA_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { namespace detail { template< size_t StageNumber , class Algebra > struct generic_rk_call_algebra; template< class Algebra > struct generic_rk_call_algebra< 1 , Algebra > { typedef Algebra algebra_type; template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( algebra_type &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 * /* s4_array */ , Op op ) const { algebra.for_each3( s1 , s2 , s3 , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( algebra_type &algebra , S1 &s1 , S2 &s2 , S4 * /* s4_array */ , Op op ) const { algebra.for_each2( s1 , s2 , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 2 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[1] , Op op ) const { algebra.for_each4( s1 , s2 , s3 , s4_array[0].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[1] , Op op ) const { algebra.for_each3( s1 , s2 , s4_array[0].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 3 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[2] , Op op ) const { algebra.for_each5( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[2] , Op op ) const { algebra.for_each4( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 4 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[3] , Op op ) const { algebra.for_each6( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[3] , Op op ) const { algebra.for_each5( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 5 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[4] , Op op ) const { algebra.for_each7( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[4] , Op op ) const { algebra.for_each6( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 6 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[5] , Op op ) const { algebra.for_each8( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[5] , Op op ) const { algebra.for_each7( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 7 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[6] , Op op ) const { algebra.for_each9( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[6] , Op op ) const { algebra.for_each8( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 8 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[7] , Op op ) const { algebra.for_each10( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[7] , Op op ) const { algebra.for_each9( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 9 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[8] , Op op ) const { algebra.for_each11( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[8] , Op op ) const { algebra.for_each10( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 10 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[9] , Op op ) const { algebra.for_each12( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[9] , Op op ) const { algebra.for_each11( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 11 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[10] , Op op ) const { algebra.for_each13( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[10] , Op op ) const { algebra.for_each12( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 12 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[11] , Op op ) const { algebra.for_each14( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , s4_array[10].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[11] , Op op ) const { algebra.for_each13( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , s4_array[10].m_v , op ); } }; template< class Algebra > struct generic_rk_call_algebra< 13 , Algebra > { template< class S1 , class S2 , class S3 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[12] , Op op ) const { algebra.for_each15( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , s4_array[10].m_v , s4_array[11].m_v , op ); } template< class S1 , class S2 , class S4 , class Op> void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[12] , Op op ) const { algebra.for_each14( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , s4_array[10].m_v , s4_array[11].m_v , op ); } }; } } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_CALL_ALGEBRA_HPP_INCLUDED PK 䄟[d � / stepper/detail/adams_bashforth_call_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp [begin_description] Algebra caller for the Adams Bashforth stepper. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011 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_DETAIL_ADAMS_BASHFORTH_CALL_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_CALL_ALGEBRA_HPP_INCLUDED #include <boost/assert.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { template< size_t Step , class Algebra , class Operations > struct adams_bashforth_call_algebra; template< class Algebra , class Operations > struct adams_bashforth_call_algebra< 1 , Algebra , Operations > { template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each3( out , in , steps[0].m_v , typename Operations::template scale_sum2< value_type , Time >( 1.0 , dt * coef[0] ) ); } }; template< class Algebra , class Operations > struct adams_bashforth_call_algebra< 2 , Algebra , Operations > { template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each4( out , in , steps[0].m_v , steps[1].m_v , typename Operations::template scale_sum3< value_type , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] ) ); } }; template< class Algebra , class Operations > struct adams_bashforth_call_algebra< 3 , Algebra , Operations > { template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each5( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , typename Operations::template scale_sum4< value_type , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] ) ); } }; template< class Algebra , class Operations > struct adams_bashforth_call_algebra< 4 , Algebra , Operations > { template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each6( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , typename Operations::template scale_sum5< value_type , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] ) ); } }; template< class Algebra , class Operations > struct adams_bashforth_call_algebra< 5 , Algebra , Operations > { template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each7( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , typename Operations::template scale_sum6< value_type , Time , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] ) ); } }; template< class Algebra , class Operations > struct adams_bashforth_call_algebra< 6 , Algebra , Operations > { template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each8( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , typename Operations::template scale_sum7< value_type , Time , Time , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] ) ); } }; template< class Algebra , class Operations > struct adams_bashforth_call_algebra< 7 , Algebra , Operations > { template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const { //BOOST_ASSERT( false ); // not implemented typedef typename Coefficients::value_type value_type; algebra.for_each9( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , steps[6].m_v , typename Operations::template scale_sum8< value_type , Time , Time , Time , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] ) ); } }; template< class Algebra , class Operations > struct adams_bashforth_call_algebra< 8 , Algebra , Operations > { template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const { //BOOST_ASSERT( false ); // not implemented typedef typename Coefficients::value_type value_type; algebra.for_each10( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , steps[6].m_v , steps[7].m_v , typename Operations::template scale_sum9< value_type , Time , Time , Time , Time , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] , dt * coef[7] ) ); } }; } // detail } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_CALL_ALGEBRA_HPP_INCLUDED PK 䄟[:�|� � / stepper/detail/adams_bashforth_coefficients.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp [begin_description] Definition of the coefficients for the Adams-Bashforth method. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_DETAIL_ADAMS_BASHFORTH_COEFFICIENTS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_COEFFICIENTS_HPP_INCLUDED #include <boost/array.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { template< class Value , size_t Steps > class adams_bashforth_coefficients ; template< class Value > class adams_bashforth_coefficients< Value , 1 > : public boost::array< Value , 1 > { public: adams_bashforth_coefficients( void ) : boost::array< Value , 1 >() { (*this)[0] = static_cast< Value >( 1 ); } }; template< class Value > class adams_bashforth_coefficients< Value , 2 > : public boost::array< Value , 2 > { public: adams_bashforth_coefficients( void ) : boost::array< Value , 2 >() { (*this)[0] = static_cast< Value >( 3 ) / static_cast< Value >( 2 ); (*this)[1] = -static_cast< Value >( 1 ) / static_cast< Value >( 2 ); } }; template< class Value > class adams_bashforth_coefficients< Value , 3 > : public boost::array< Value , 3 > { public: adams_bashforth_coefficients( void ) : boost::array< Value , 3 >() { (*this)[0] = static_cast< Value >( 23 ) / static_cast< Value >( 12 ); (*this)[1] = -static_cast< Value >( 4 ) / static_cast< Value >( 3 ); (*this)[2] = static_cast< Value >( 5 ) / static_cast< Value >( 12 ); } }; template< class Value > class adams_bashforth_coefficients< Value , 4 > : public boost::array< Value , 4 > { public: adams_bashforth_coefficients( void ) : boost::array< Value , 4 >() { (*this)[0] = static_cast< Value >( 55 ) / static_cast< Value >( 24 ); (*this)[1] = -static_cast< Value >( 59 ) / static_cast< Value >( 24 ); (*this)[2] = static_cast< Value >( 37 ) / static_cast< Value >( 24 ); (*this)[3] = -static_cast< Value >( 3 ) / static_cast< Value >( 8 ); } }; template< class Value > class adams_bashforth_coefficients< Value , 5 > : public boost::array< Value , 5 > { public: adams_bashforth_coefficients( void ) : boost::array< Value , 5 >() { (*this)[0] = static_cast< Value >( 1901 ) / static_cast< Value >( 720 ); (*this)[1] = -static_cast< Value >( 1387 ) / static_cast< Value >( 360 ); (*this)[2] = static_cast< Value >( 109 ) / static_cast< Value >( 30 ); (*this)[3] = -static_cast< Value >( 637 ) / static_cast< Value >( 360 ); (*this)[4] = static_cast< Value >( 251 ) / static_cast< Value >( 720 ); } }; template< class Value > class adams_bashforth_coefficients< Value , 6 > : public boost::array< Value , 6 > { public: adams_bashforth_coefficients( void ) : boost::array< Value , 6 >() { (*this)[0] = static_cast< Value >( 4277 ) / static_cast< Value >( 1440 ); (*this)[1] = -static_cast< Value >( 2641 ) / static_cast< Value >( 480 ); (*this)[2] = static_cast< Value >( 4991 ) / static_cast< Value >( 720 ); (*this)[3] = -static_cast< Value >( 3649 ) / static_cast< Value >( 720 ); (*this)[4] = static_cast< Value >( 959 ) / static_cast< Value >( 480 ); (*this)[5] = -static_cast< Value >( 95 ) / static_cast< Value >( 288 ); } }; template< class Value > class adams_bashforth_coefficients< Value , 7 > : public boost::array< Value , 7 > { public: adams_bashforth_coefficients( void ) : boost::array< Value , 7 >() { (*this)[0] = static_cast< Value >( 198721 ) / static_cast< Value >( 60480 ); (*this)[1] = -static_cast< Value >( 18637 ) / static_cast< Value >( 2520 ); (*this)[2] = static_cast< Value >( 235183 ) / static_cast< Value >( 20160 ); (*this)[3] = -static_cast< Value >( 10754 ) / static_cast< Value >( 945 ); (*this)[4] = static_cast< Value >( 135713 ) / static_cast< Value >( 20160 ); (*this)[5] = -static_cast< Value >( 5603 ) / static_cast< Value >( 2520 ); (*this)[6] = static_cast< Value >( 19087 ) / static_cast< Value >( 60480 ); } }; template< class Value > class adams_bashforth_coefficients< Value , 8 > : public boost::array< Value , 8 > { public: adams_bashforth_coefficients( void ) : boost::array< Value , 8 >() { (*this)[0] = static_cast< Value >( 16083 ) / static_cast< Value >( 4480 ); (*this)[1] = -static_cast< Value >( 1152169 ) / static_cast< Value >( 120960 ); (*this)[2] = static_cast< Value >( 242653 ) / static_cast< Value >( 13440 ); (*this)[3] = -static_cast< Value >( 296053 ) / static_cast< Value >( 13440 ); (*this)[4] = static_cast< Value >( 2102243 ) / static_cast< Value >( 120960 ); (*this)[5] = -static_cast< Value >( 115747 ) / static_cast< Value >( 13440 ); (*this)[6] = static_cast< Value >( 32863 ) / static_cast< Value >( 13440 ); (*this)[7] = -static_cast< Value >( 5257 ) / static_cast< Value >( 17280 ); } }; } // detail } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_COEFFICIENTS_HPP_INCLUDED PK 䄟[ɿ�BA A - stepper/detail/adams_moulton_coefficients.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp [begin_description] Coefficients for the Adams Moulton method. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_DETAIL_ADAMS_MOULTON_COEFFICIENTS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_COEFFICIENTS_HPP_INCLUDED #include <boost/array.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { template< class Value , size_t Steps > class adams_moulton_coefficients ; template< class Value > class adams_moulton_coefficients< Value , 1 > : public boost::array< Value , 1 > { public: adams_moulton_coefficients( void ) : boost::array< Value , 1 >() { (*this)[0] = static_cast< Value >( 1 ); } }; template< class Value > class adams_moulton_coefficients< Value , 2 > : public boost::array< Value , 2 > { public: adams_moulton_coefficients( void ) : boost::array< Value , 2 >() { (*this)[0] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ); (*this)[1] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ); } }; template< class Value > class adams_moulton_coefficients< Value , 3 > : public boost::array< Value , 3 > { public: adams_moulton_coefficients( void ) : boost::array< Value , 3 >() { (*this)[0] = static_cast< Value >( 5 ) / static_cast< Value >( 12 ); (*this)[1] = static_cast< Value >( 2 ) / static_cast< Value >( 3 ); (*this)[2] = -static_cast< Value >( 1 ) / static_cast< Value >( 12 ); } }; template< class Value > class adams_moulton_coefficients< Value , 4 > : public boost::array< Value , 4 > { public: adams_moulton_coefficients( void ) : boost::array< Value , 4 >() { (*this)[0] = static_cast< Value >( 3 ) / static_cast< Value >( 8 ); (*this)[1] = static_cast< Value >( 19 ) / static_cast< Value >( 24 ); (*this)[2] = -static_cast< Value >( 5 ) / static_cast< Value >( 24 ); (*this)[3] = static_cast< Value >( 1 ) / static_cast< Value >( 24 ); } }; template< class Value > class adams_moulton_coefficients< Value , 5 > : public boost::array< Value , 5 > { public: adams_moulton_coefficients( void ) : boost::array< Value , 5 >() { (*this)[0] = static_cast< Value >( 251 ) / static_cast< Value >( 720 ); (*this)[1] = static_cast< Value >( 323 ) / static_cast< Value >( 360 ); (*this)[2] = -static_cast< Value >( 11 ) / static_cast< Value >( 30 ); (*this)[3] = static_cast< Value >( 53 ) / static_cast< Value >( 360 ); (*this)[4] = -static_cast< Value >( 19 ) / static_cast< Value >( 720 ); } }; template< class Value > class adams_moulton_coefficients< Value , 6 > : public boost::array< Value , 6 > { public: adams_moulton_coefficients( void ) : boost::array< Value , 6 >() { (*this)[0] = static_cast< Value >( 95 ) / static_cast< Value >( 288 ); (*this)[1] = static_cast< Value >( 1427 ) / static_cast< Value >( 1440 ); (*this)[2] = -static_cast< Value >( 133 ) / static_cast< Value >( 240 ); (*this)[3] = static_cast< Value >( 241 ) / static_cast< Value >( 720 ); (*this)[4] = -static_cast< Value >( 173 ) / static_cast< Value >( 1440 ); (*this)[5] = static_cast< Value >( 3 ) / static_cast< Value >( 160 ); } }; template< class Value > class adams_moulton_coefficients< Value , 7 > : public boost::array< Value , 7 > { public: adams_moulton_coefficients( void ) : boost::array< Value , 7 >() { (*this)[0] = static_cast< Value >( 19087 ) / static_cast< Value >( 60480 ); (*this)[1] = static_cast< Value >( 2713 ) / static_cast< Value >( 2520 ); (*this)[2] = -static_cast< Value >( 15487 ) / static_cast< Value >( 20160 ); (*this)[3] = static_cast< Value >( 586 ) / static_cast< Value >( 945 ); (*this)[4] = -static_cast< Value >( 6737 ) / static_cast< Value >( 20160 ); (*this)[5] = static_cast< Value >( 263 ) / static_cast< Value >( 2520 ); (*this)[6] = -static_cast< Value >( 863 ) / static_cast< Value >( 60480 ); } }; template< class Value > class adams_moulton_coefficients< Value , 8 > : public boost::array< Value , 8 > { public: adams_moulton_coefficients( void ) : boost::array< Value , 8 >() { (*this)[0] = static_cast< Value >( 5257 ) / static_cast< Value >( 17280 ); (*this)[1] = static_cast< Value >( 139849 ) / static_cast< Value >( 120960 ); (*this)[2] = -static_cast< Value >( 4511 ) / static_cast< Value >( 4480 ); (*this)[3] = static_cast< Value >( 123133 ) / static_cast< Value >( 120960 ); (*this)[4] = -static_cast< Value >( 88547 ) / static_cast< Value >( 120960 ); (*this)[5] = static_cast< Value >( 1537 ) / static_cast< Value >( 4480 ); (*this)[6] = -static_cast< Value >( 11351 ) / static_cast< Value >( 120960 ); (*this)[7] = static_cast< Value >( 275 ) / static_cast< Value >( 24192 ); } }; } // detail } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_COEFFICIENTS_HPP_INCLUDED PK 䄟[y��> > . stepper/detail/adaptive_adams_coefficients.hppnu �[��� /* boost/numeric/odeint/stepper/detail/adaptive_adams_coefficients.hpp [begin_description] Calculation of the coefficients for the adaptive adams stepper. [end_description] Copyright 2017 Valentin Noah Hartmann 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_DETAIL_ADAPTIVE_ADAMS_COEFFICIENTS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAPTIVE_ADAMS_COEFFICIENTS_HPP_INCLUDED #include <boost/numeric/odeint/stepper/detail/rotating_buffer.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/unwrap_reference.hpp> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/array.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { template< size_t Steps, class Deriv, class Value = double, class Time = double, class Algebra = typename algebra_dispatcher< Deriv >::algebra_type, class Operations = typename operations_dispatcher< Deriv >::operations_type, class Resizer = initially_resizer > class adaptive_adams_coefficients { public: static const size_t steps = Steps; typedef unsigned short order_type; static const order_type order_value = steps; typedef Value value_type; typedef Deriv deriv_type; typedef Time time_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef rotating_buffer< time_type , steps+1 > time_storage_type; typedef Algebra algebra_type; typedef Operations operations_type; typedef Resizer resizer_type; typedef adaptive_adams_coefficients< Steps , Deriv , Value , Time , Algebra , Operations , Resizer > aac_type; adaptive_adams_coefficients( const algebra_type &algebra = algebra_type()) :m_eo(1), m_steps_init(1), beta(), phi(), m_ns(0), m_time_storage(), m_algebra(algebra), m_phi_resizer() { for (size_t i=0; i<order_value+2; ++i) { c[i] = 1.0/(i+1); c[c_size+i] = 1.0/((i+1)*(i+2)); } g[0] = c[0]; g[1] = c[c_size]; beta[0][0] = 1; beta[1][0] = 1; gs[0] = 1.0; gs[1] = -1.0/2; gs[2] = -1.0/12; gs[3] = -1.0/24; gs[4] = -19.0/720; gs[5] = -3.0/160; gs[6] = -863.0/60480; gs[7] = -275.0/24192; gs[8] = -33953.0/3628800; gs[9] = 35.0/4436; gs[10] = 40.0/5891; gs[11] = 37.0/6250; gs[12] = 25.0/4771; gs[13] = 40.0/8547; }; void predict(time_type t, time_type dt) { using std::abs; m_time_storage[0] = t; if (abs(m_time_storage[0] - m_time_storage[1] - dt) > 1e-16 || m_eo >= m_ns) { m_ns = 0; } else if (m_ns < order_value + 2) { m_ns++; } for(size_t i=1+m_ns; i<m_eo+1 && i<m_steps_init; ++i) { time_type diff = m_time_storage[0] - m_time_storage[i]; beta[0][i] = beta[0][i-1]*(m_time_storage[0] + dt - m_time_storage[i-1])/diff; } for(size_t i=2+m_ns; i<m_eo+2 && i<m_steps_init+1; ++i) { time_type diff = m_time_storage[0] + dt - m_time_storage[i-1]; for(size_t j=0; j<m_eo+1-i+1; ++j) { c[c_size*i+j] = c[c_size*(i-1)+j] - c[c_size*(i-1)+j+1]*dt/diff; } g[i] = c[c_size*i]; } }; void do_step(const deriv_type &dxdt, const int o = 0) { m_phi_resizer.adjust_size( dxdt , detail::bind( &aac_type::template resize_phi_impl< deriv_type > , detail::ref( *this ) , detail::_1 ) ); phi[o][0].m_v = dxdt; for(size_t i=1; i<m_eo+3 && i<m_steps_init+2 && i<order_value+2; ++i) { if (o == 0) { this->m_algebra.for_each3(phi[o][i].m_v, phi[o][i-1].m_v, phi[o+1][i-1].m_v, typename Operations::template scale_sum2<value_type, value_type>(1.0, -beta[o][i-1])); } else { this->m_algebra.for_each2(phi[o][i].m_v, phi[o][i-1].m_v, typename Operations::template scale_sum1<value_type>(1.0)); } } }; void confirm() { beta.rotate(); phi.rotate(); m_time_storage.rotate(); if(m_steps_init < order_value+1) { ++m_steps_init; } }; void reset() { m_eo = 1; m_steps_init = 1; }; size_t m_eo; size_t m_steps_init; rotating_buffer<boost::array<value_type, order_value+1>, 2> beta; // beta[0] = beta(n) rotating_buffer<boost::array<wrapped_deriv_type, order_value+2>, 3> phi; // phi[0] = phi(n+1) boost::array<value_type, order_value + 2> g; boost::array<value_type, 14> gs; private: template< class StateType > bool resize_phi_impl( const StateType &x ) { bool resized( false ); for(size_t i=0; i<(order_value + 2); ++i) { resized |= adjust_size_by_resizeability( phi[0][i], x, typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( phi[1][i], x, typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( phi[2][i], x, typename is_resizeable<deriv_type>::type() ); } return resized; }; size_t m_ns; time_storage_type m_time_storage; static const size_t c_size = order_value + 2; boost::array<value_type, c_size*c_size> c; algebra_type m_algebra; resizer_type m_phi_resizer; }; } // detail } // odeint } // numeric } // boost #endifPK 䄟[$��EH H - stepper/detail/adams_moulton_call_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp [begin_description] Algebra caller for the Adams Moulton method. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011 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_DETAIL_ADAMS_MOULTON_CALL_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_CALL_ALGEBRA_HPP_INCLUDED #include <boost/assert.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { template< size_t Step , class Algebra , class Operations > struct adams_moulton_call_algebra; template< class Algebra , class Operations > struct adams_moulton_call_algebra< 1 , Algebra , Operations > { template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage& /* steps */ , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each3( out , in , dxdt , typename Operations::template scale_sum2< value_type , Time >( 1.0 , dt * coef[0] ) ); } }; template< class Algebra , class Operations > struct adams_moulton_call_algebra< 2 , Algebra , Operations > { template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each4( out , in , dxdt , steps[0].m_v , typename Operations::template scale_sum3< value_type , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] ) ); } }; template< class Algebra , class Operations > struct adams_moulton_call_algebra< 3 , Algebra , Operations > { template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each5( out , in , dxdt , steps[0].m_v , steps[1].m_v , typename Operations::template scale_sum4< value_type , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] ) ); } }; template< class Algebra , class Operations > struct adams_moulton_call_algebra< 4 , Algebra , Operations > { template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each6( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v , typename Operations::template scale_sum5< value_type , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] ) ); } }; template< class Algebra , class Operations > struct adams_moulton_call_algebra< 5 , Algebra , Operations > { template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each7( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , typename Operations::template scale_sum6< value_type , Time , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] ) ); } }; template< class Algebra , class Operations > struct adams_moulton_call_algebra< 6 , Algebra , Operations > { template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each8( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , typename Operations::template scale_sum7< value_type , Time , Time , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] ) ); } }; template< class Algebra , class Operations > struct adams_moulton_call_algebra< 7 , Algebra , Operations > { template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each9( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , typename Operations::template scale_sum8< value_type , Time , Time , Time , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] ) ); } }; template< class Algebra , class Operations > struct adams_moulton_call_algebra< 8 , Algebra , Operations > { template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time > void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const { typedef typename Coefficients::value_type value_type; algebra.for_each10( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , steps[6].m_v , typename Operations::template scale_sum9< value_type , Time , Time , Time , Time , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] , dt * coef[7] ) ); } }; } // detail } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_CALL_ALGEBRA_HPP_INCLUDED PK 䄟[�U�� � " stepper/detail/rotating_buffer.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/detail/rotating_buffer.hpp [begin_description] Implemetation of a rotating (cyclic) buffer for use in the Adam Bashforth stepper [end_description] Copyright 2011 Karsten Ahnert Copyright 2011 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_DETAIL_ROTATING_BUFFER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ROTATING_BUFFER_HPP_INCLUDED #include <boost/array.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { template< class T , size_t N > class rotating_buffer { public: typedef T value_type; const static size_t dim = N; rotating_buffer( void ) : m_first( 0 ) { } size_t size( void ) const { return dim; } value_type& operator[]( size_t i ) { return m_data[ get_index( i ) ]; } const value_type& operator[]( size_t i ) const { return m_data[ get_index( i ) ]; } void rotate( void ) { if( m_first == 0 ) m_first = dim-1; else --m_first; } protected: value_type m_data[N]; private: size_t get_index( size_t i ) const { return ( ( i + m_first ) % dim ); } size_t m_first; }; } // detail } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ROTATING_BUFFER_HPP_INCLUDED PK 䄟[+A$�: : 1 stepper/detail/pid_step_adjuster_coefficients.hppnu �[��� /* boost/numeric/odeint/stepper/detail/pid_step_adjuster_coefficients.hpp [begin_description] Coefficients for the PID stepsize controller. [end_description] Copyright 2017 Valentin Noah Hartmann 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_DETAIL_PID_STEP_ADJUSTER_COEFFICIENTS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_PID_STEP_ADJUSTER_COEFFICIENTS_HPP_INCLUDED #include <boost/array.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { enum adjuster_type{ BASIC, H0211, H211b, H211PI, H0312, H312b, H312PID, H0321, H321 }; template<int Type> class pid_step_adjuster_coefficients; template<> class pid_step_adjuster_coefficients<BASIC> : public boost::array<double, 5> { public: pid_step_adjuster_coefficients() : boost::array<double, 5>() { (*this)[0] = 1.0; (*this)[1] = 0.0; (*this)[2] = 0.0; (*this)[3] = 0.0; (*this)[4] = 0.0; } }; template<> class pid_step_adjuster_coefficients<H0211> : public boost::array<double, 5> { public: pid_step_adjuster_coefficients() : boost::array<double, 5>() { (*this)[0] = 1.0 / 2.0; (*this)[1] = 1.0 / 2.0; (*this)[2] = 0.0; (*this)[3] = 1.0 / 2.0; (*this)[4] = 0.0; } }; template<> class pid_step_adjuster_coefficients<H211b> : public boost::array<double, 5> { public: pid_step_adjuster_coefficients() : boost::array<double, 5>() { (*this)[0] = 1.0 / 5.0; (*this)[1] = 2.0 / 5.0; (*this)[2] = 0.0; (*this)[3] = 1.0 / 5.0; (*this)[4] = 0.0; } }; template<> class pid_step_adjuster_coefficients<H211PI> : public boost::array<double, 5> { public: pid_step_adjuster_coefficients() : boost::array<double, 5>() { (*this)[0] = 1.0 / 6.0; (*this)[1] = 2.0 / 6.0; (*this)[2] = 0.0; (*this)[3] = 0.0; (*this)[4] = 0.0; } }; template<> class pid_step_adjuster_coefficients<H0312> : public boost::array<double, 5> { public: pid_step_adjuster_coefficients() : boost::array<double, 5>() { (*this)[0] = 1.0 / 4.0; (*this)[1] = 2.0 / 2.0; (*this)[2] = 1.0 / 4.0; (*this)[3] = 3.0 / 4.0; (*this)[4] = 1.0 / 4.0; } }; template<> class pid_step_adjuster_coefficients<H312b> : public boost::array<double, 5> { public: pid_step_adjuster_coefficients() : boost::array<double, 5>() { (*this)[0] = 1.0 / 6.0; (*this)[1] = 2.0 / 6.0; (*this)[2] = 1.0 / 6.0; (*this)[3] = 3.0 / 6.0; (*this)[4] = 1.0 / 6.0; } }; template<> class pid_step_adjuster_coefficients<H312PID> : public boost::array<double, 5> { public: pid_step_adjuster_coefficients() : boost::array<double, 5>() { (*this)[0] = 1.0 / 18.0; (*this)[1] = 2.0 / 9.0; (*this)[2] = 1.0 / 18.0; (*this)[3] = 0.0; (*this)[4] = 0.0; } }; template<> class pid_step_adjuster_coefficients<H0321> : public boost::array<double, 5> { public: pid_step_adjuster_coefficients() : boost::array<double, 5>() { (*this)[0] = 5.0 / 4.0; (*this)[1] = 1.0 / 2.0; (*this)[2] = -3.0 / 4.0; (*this)[3] = -1.0 / 4.0; (*this)[4] = -3.0 / 4.0; } }; template<> class pid_step_adjuster_coefficients<H321> : public boost::array<double, 5> { public: pid_step_adjuster_coefficients() : boost::array<double, 5>() { (*this)[0] = 1.0 / 3.0; (*this)[1] = 1.0 / 18.0; (*this)[2] = -5.0 / 18.0; (*this)[3] = -5.0 / 16.0; (*this)[4] = -1.0 / 6.0; } }; } // detail } // odeint } // numeric } // boost #endifPK 䄟[u�� �� �� " stepper/controlled_runge_kutta.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/controlled_runge_kutta.hpp [begin_description] The default controlled stepper which can be used with all explicit Runge-Kutta error steppers. [end_description] Copyright 2010-2013 Karsten Ahnert Copyright 2010-2015 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_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED #include <cmath> #include <boost/config.hpp> #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/copy.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/detail/less_with_sign.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> namespace boost { namespace numeric { namespace odeint { template < class Value , class Algebra , class Operations > class default_error_checker { public: typedef Value value_type; typedef Algebra algebra_type; typedef Operations operations_type; default_error_checker( value_type eps_abs = static_cast< value_type >( 1.0e-6 ) , value_type eps_rel = static_cast< value_type >( 1.0e-6 ) , value_type a_x = static_cast< value_type >( 1 ) , value_type a_dxdt = static_cast< value_type >( 1 )) : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt ) { } template< class State , class Deriv , class Err, class Time > value_type error( const State &x_old , const Deriv &dxdt_old , Err &x_err , Time dt ) const { return error( algebra_type() , x_old , dxdt_old , x_err , dt ); } template< class State , class Deriv , class Err, class Time > value_type error( algebra_type &algebra , const State &x_old , const Deriv &dxdt_old , Err &x_err , Time dt ) const { using std::abs; // this overwrites x_err ! algebra.for_each3( x_err , x_old , dxdt_old , typename operations_type::template rel_error< value_type >( m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt * abs(get_unit_value( dt )) ) ); // value_type res = algebra.reduce( x_err , // typename operations_type::template maximum< value_type >() , static_cast< value_type >( 0 ) ); return algebra.norm_inf( x_err ); } private: value_type m_eps_abs; value_type m_eps_rel; value_type m_a_x; value_type m_a_dxdt; }; template< typename Value, typename Time > class default_step_adjuster { public: typedef Time time_type; typedef Value value_type; default_step_adjuster(const time_type max_dt=static_cast<time_type>(0)) : m_max_dt(max_dt) {} time_type decrease_step(time_type dt, const value_type error, const int error_order) const { // returns the decreased time step BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); using std::pow; dt *= max BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( static_cast<value_type>(9) / static_cast<value_type>(10) * pow(error, static_cast<value_type>(-1) / (error_order - 1))), static_cast<value_type>( static_cast<value_type>(1) / static_cast<value_type> (5))); if(m_max_dt != static_cast<time_type >(0)) // limit to maximal stepsize even when decreasing dt = detail::min_abs(dt, m_max_dt); return dt; } time_type increase_step(time_type dt, value_type error, const int stepper_order) const { // returns the increased time step BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); using std::pow; // adjust the size if dt is smaller than max_dt (providede max_dt is not zero) if(error < 0.5) { // error should be > 0 error = max BOOST_PREVENT_MACRO_SUBSTITUTION ( static_cast<value_type>( pow( static_cast<value_type>(5.0) , -static_cast<value_type>(stepper_order) ) ) , error); // time_type dt_old = dt; unused variable warning //error too small - increase dt and keep the evolution and limit scaling factor to 5.0 dt *= static_cast<value_type>(9)/static_cast<value_type>(10) * pow(error, static_cast<value_type>(-1) / stepper_order); if(m_max_dt != static_cast<time_type >(0)) // limit to maximal stepsize dt = detail::min_abs(dt, m_max_dt); } return dt; } bool check_step_size_limit(const time_type dt) { if(m_max_dt != static_cast<time_type >(0)) return detail::less_eq_with_sign(dt, m_max_dt, dt); return true; } time_type get_max_dt() { return m_max_dt; } protected: time_type m_max_dt; }; /* * error stepper category dispatcher */ template< class ErrorStepper , class ErrorChecker = default_error_checker< typename ErrorStepper::value_type , typename ErrorStepper::algebra_type , typename ErrorStepper::operations_type > , class StepAdjuster = default_step_adjuster< typename ErrorStepper::value_type , typename ErrorStepper::time_type > , class Resizer = typename ErrorStepper::resizer_type , class ErrorStepperCategory = typename ErrorStepper::stepper_category > class controlled_runge_kutta ; /* * explicit stepper version * * this class introduces the following try_step overloads * try_step( sys , x , t , dt ) * try_step( sys , x , dxdt , t , dt ) * try_step( sys , in , t , out , dt ) * try_step( sys , in , dxdt , t , out , dt ) */ /** * \brief Implements step size control for Runge-Kutta steppers with error * estimation. * * This class implements the step size control for standard Runge-Kutta * steppers with error estimation. * * \tparam ErrorStepper The stepper type with error estimation, has to fulfill the ErrorStepper concept. * \tparam ErrorChecker The error checker * \tparam Resizer The resizer policy type. */ template< class ErrorStepper, class ErrorChecker, class StepAdjuster, class Resizer > class controlled_runge_kutta< ErrorStepper , ErrorChecker , StepAdjuster, Resizer , explicit_error_stepper_tag > { public: typedef ErrorStepper stepper_type; typedef typename stepper_type::state_type state_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::time_type time_type; typedef typename stepper_type::algebra_type algebra_type; typedef typename stepper_type::operations_type operations_type; typedef Resizer resizer_type; typedef ErrorChecker error_checker_type; typedef StepAdjuster step_adjuster_type; typedef explicit_controlled_stepper_tag stepper_category; #ifndef DOXYGEN_SKIP typedef typename stepper_type::wrapped_state_type wrapped_state_type; typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type; typedef controlled_runge_kutta< ErrorStepper , ErrorChecker , StepAdjuster , Resizer , explicit_error_stepper_tag > controlled_stepper_type; #endif //DOXYGEN_SKIP /** * \brief Constructs the controlled Runge-Kutta stepper. * \param error_checker An instance of the error checker. * \param stepper An instance of the underlying stepper. */ controlled_runge_kutta( const error_checker_type &error_checker = error_checker_type( ) , const step_adjuster_type &step_adjuster = step_adjuster_type() , const stepper_type &stepper = stepper_type( ) ) : m_stepper(stepper), m_error_checker(error_checker) , m_step_adjuster(step_adjuster) { } /* * Version 1 : try_step( sys , x , t , dt ) * * The overloads are needed to solve the forwarding problem */ /** * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. Overwritten if * the step is successful. * \param t The value of the time. Updated if the step is successful. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateInOut > controlled_step_result try_step( System system , StateInOut &x , time_type &t , time_type &dt ) { return try_step_v1( system , x , t, dt ); } /** * \brief Tries to perform one step. Solves the forwarding problem and * allows for using boost range as state_type. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. Overwritten if * the step is successful. Can be a boost range. * \param t The value of the time. Updated if the step is successful. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateInOut > controlled_step_result try_step( System system , const StateInOut &x , time_type &t , time_type &dt ) { return try_step_v1( system , x , t, dt ); } /* * Version 2 : try_step( sys , x , dxdt , t , dt ) * * this version does not solve the forwarding problem, boost.range can not be used */ /** * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. Overwritten if * the step is successful. * \param dxdt The derivative of state. * \param t The value of the time. Updated if the step is successful. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateInOut , class DerivIn > controlled_step_result try_step( System system , StateInOut &x , const DerivIn &dxdt , time_type &t , time_type &dt ) { m_xnew_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_xnew_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ); controlled_step_result res = try_step( system , x , dxdt , t , m_xnew.m_v , dt ); if( res == success ) { boost::numeric::odeint::copy( m_xnew.m_v , x ); } return res; } /* * Version 3 : try_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 */ /** * \brief Tries to perform one step. * * \note This method is disabled if state_type=time_type to avoid ambiguity. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. * \param t The value of the time. Updated if the step is successful. * \param out Used to store the result of the step. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateIn , class StateOut > typename boost::disable_if< boost::is_same< StateIn , time_type > , controlled_step_result >::type try_step( System system , const StateIn &in , time_type &t , StateOut &out , time_type &dt ) { typename odeint::unwrap_reference< System >::type &sys = system; m_dxdt_resizer.adjust_size( in , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ); sys( in , m_dxdt.m_v , t ); return try_step( system , in , m_dxdt.m_v , t , out , dt ); } /* * Version 4 : try_step( sys , in , dxdt , t , out , dt ) * * this version does not solve the forwarding problem, boost.range can not be used */ /** * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. * \param dxdt The derivative of state. * \param t The value of the time. Updated if the step is successful. * \param out Used to store the result of the step. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateIn , class DerivIn , class StateOut > controlled_step_result try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , time_type &dt ) { unwrapped_step_adjuster &step_adjuster = m_step_adjuster; if( !step_adjuster.check_step_size_limit(dt) ) { // given dt was above step size limit - adjust and return fail; dt = step_adjuster.get_max_dt(); return fail; } m_xerr_resizer.adjust_size( in , detail::bind( &controlled_runge_kutta::template resize_m_xerr_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ); // do one step with error calculation m_stepper.do_step( system , in , dxdt , t , out , dt , m_xerr.m_v ); value_type max_rel_err = m_error_checker.error( m_stepper.algebra() , in , dxdt , m_xerr.m_v , dt ); if( max_rel_err > 1.0 ) { // error too big, decrease step size and reject this step dt = step_adjuster.decrease_step(dt, max_rel_err, m_stepper.error_order()); return fail; } else { // otherwise, increase step size and accept t += dt; dt = step_adjuster.increase_step(dt, max_rel_err, m_stepper.stepper_order()); return success; } } /** * \brief Adjust the size of all temporaries in the stepper manually. * \param x A state from which the size of the temporaries to be resized is deduced. */ template< class StateType > void adjust_size( const StateType &x ) { resize_m_xerr_impl( x ); resize_m_dxdt_impl( x ); resize_m_xnew_impl( x ); m_stepper.adjust_size( x ); } /** * \brief Returns the instance of the underlying stepper. * \returns The instance of the underlying stepper. */ stepper_type& stepper( void ) { return m_stepper; } /** * \brief Returns the instance of the underlying stepper. * \returns The instance of the underlying stepper. */ const stepper_type& stepper( void ) const { return m_stepper; } private: template< class System , class StateInOut > controlled_step_result try_step_v1( System system , StateInOut &x , time_type &t , time_type &dt ) { typename odeint::unwrap_reference< System >::type &sys = system; m_dxdt_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ); sys( x , m_dxdt.m_v ,t ); return try_step( system , x , m_dxdt.m_v , t , dt ); } template< class StateIn > bool resize_m_xerr_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_xerr , x , typename is_resizeable<state_type>::type() ); } template< class StateIn > bool resize_m_dxdt_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() ); } template< class StateIn > bool resize_m_xnew_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_xnew , x , typename is_resizeable<state_type>::type() ); } stepper_type m_stepper; error_checker_type m_error_checker; step_adjuster_type m_step_adjuster; typedef typename unwrap_reference< step_adjuster_type >::type unwrapped_step_adjuster; resizer_type m_dxdt_resizer; resizer_type m_xerr_resizer; resizer_type m_xnew_resizer; wrapped_deriv_type m_dxdt; wrapped_state_type m_xerr; wrapped_state_type m_xnew; }; /* * explicit stepper fsal version * * the class introduces the following try_step overloads * try_step( sys , x , t , dt ) * try_step( sys , in , t , out , dt ) * try_step( sys , x , dxdt , t , dt ) * try_step( sys , in , dxdt_in , t , out , dxdt_out , dt ) */ /** * \brief Implements step size control for Runge-Kutta FSAL steppers with * error estimation. * * This class implements the step size control for FSAL Runge-Kutta * steppers with error estimation. * * \tparam ErrorStepper The stepper type with error estimation, has to fulfill the ErrorStepper concept. * \tparam ErrorChecker The error checker * \tparam Resizer The resizer policy type. */ template< class ErrorStepper , class ErrorChecker , class StepAdjuster , class Resizer > class controlled_runge_kutta< ErrorStepper , ErrorChecker , StepAdjuster , Resizer , explicit_error_stepper_fsal_tag > { public: typedef ErrorStepper stepper_type; typedef typename stepper_type::state_type state_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::time_type time_type; typedef typename stepper_type::algebra_type algebra_type; typedef typename stepper_type::operations_type operations_type; typedef Resizer resizer_type; typedef ErrorChecker error_checker_type; typedef StepAdjuster step_adjuster_type; typedef explicit_controlled_stepper_fsal_tag stepper_category; #ifndef DOXYGEN_SKIP typedef typename stepper_type::wrapped_state_type wrapped_state_type; typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type; typedef controlled_runge_kutta< ErrorStepper , ErrorChecker , StepAdjuster , Resizer , explicit_error_stepper_tag > controlled_stepper_type; #endif // DOXYGEN_SKIP /** * \brief Constructs the controlled Runge-Kutta stepper. * \param error_checker An instance of the error checker. * \param stepper An instance of the underlying stepper. */ controlled_runge_kutta( const error_checker_type &error_checker = error_checker_type() , const step_adjuster_type &step_adjuster = step_adjuster_type() , const stepper_type &stepper = stepper_type() ) : m_stepper( stepper ) , m_error_checker( error_checker ) , m_step_adjuster(step_adjuster) , m_first_call( true ) { } /* * Version 1 : try_step( sys , x , t , dt ) * * The two overloads are needed in order to solve the forwarding problem */ /** * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. Overwritten if * the step is successful. * \param t The value of the time. Updated if the step is successful. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateInOut > controlled_step_result try_step( System system , StateInOut &x , time_type &t , time_type &dt ) { return try_step_v1( system , x , t , dt ); } /** * \brief Tries to perform one step. Solves the forwarding problem and * allows for using boost range as state_type. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. Overwritten if * the step is successful. Can be a boost range. * \param t The value of the time. Updated if the step is successful. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateInOut > controlled_step_result try_step( System system , const StateInOut &x , time_type &t , time_type &dt ) { return try_step_v1( system , x , t , dt ); } /* * Version 2 : try_step( sys , in , t , out , dt ); * * This version does not solve the forwarding problem, boost::range can not be used. * * The disabler is needed to solve ambiguous overloads */ /** * \brief Tries to perform one step. * * \note This method is disabled if state_type=time_type to avoid ambiguity. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. * \param t The value of the time. Updated if the step is successful. * \param out Used to store the result of the step. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateIn , class StateOut > typename boost::disable_if< boost::is_same< StateIn , time_type > , controlled_step_result >::type try_step( System system , const StateIn &in , time_type &t , StateOut &out , time_type &dt ) { if( m_dxdt_resizer.adjust_size( in , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ) || m_first_call ) { initialize( system , in , t ); } return try_step( system , in , m_dxdt.m_v , t , out , dt ); } /* * Version 3 : try_step( sys , x , dxdt , t , dt ) * * This version does not solve the forwarding problem, boost::range can not be used. */ /** * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. Overwritten if * the step is successful. * \param dxdt The derivative of state. * \param t The value of the time. Updated if the step is successful. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateInOut , class DerivInOut > controlled_step_result try_step( System system , StateInOut &x , DerivInOut &dxdt , time_type &t , time_type &dt ) { m_xnew_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_xnew_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ); m_dxdt_new_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_new_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ); controlled_step_result res = try_step( system , x , dxdt , t , m_xnew.m_v , m_dxdtnew.m_v , dt ); if( res == success ) { boost::numeric::odeint::copy( m_xnew.m_v , x ); boost::numeric::odeint::copy( m_dxdtnew.m_v , dxdt ); } return res; } /* * Version 4 : try_step( sys , in , dxdt_in , t , out , dxdt_out , dt ) * * This version does not solve the forwarding problem, boost::range can not be used. */ /** * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. * * \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. * \param dxdt The derivative of state. * \param t The value of the time. Updated if the step is successful. * \param out Used to store the result of the step. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut > controlled_step_result try_step( System system , const StateIn &in , const DerivIn &dxdt_in , time_type &t , StateOut &out , DerivOut &dxdt_out , time_type &dt ) { unwrapped_step_adjuster &step_adjuster = m_step_adjuster; if( !step_adjuster.check_step_size_limit(dt) ) { // given dt was above step size limit - adjust and return fail; dt = step_adjuster.get_max_dt(); return fail; } m_xerr_resizer.adjust_size( in , detail::bind( &controlled_runge_kutta::template resize_m_xerr_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ); //fsal: m_stepper.get_dxdt( dxdt ); //fsal: m_stepper.do_step( sys , x , dxdt , t , dt , m_x_err ); m_stepper.do_step( system , in , dxdt_in , t , out , dxdt_out , dt , m_xerr.m_v ); // this potentially overwrites m_x_err! (standard_error_checker does, at least) value_type max_rel_err = m_error_checker.error( m_stepper.algebra() , in , dxdt_in , m_xerr.m_v , dt ); if( max_rel_err > 1.0 ) { // error too big, decrease step size and reject this step dt = step_adjuster.decrease_step(dt, max_rel_err, m_stepper.error_order()); return fail; } // otherwise, increase step size and accept t += dt; dt = step_adjuster.increase_step(dt, max_rel_err, m_stepper.stepper_order()); return success; } /** * \brief Resets the internal state of the underlying FSAL stepper. */ void reset( void ) { m_first_call = true; } /** * \brief Initializes the internal state storing an internal copy of the derivative. * * \param deriv The initial derivative of the ODE. */ template< class DerivIn > void initialize( const DerivIn &deriv ) { boost::numeric::odeint::copy( deriv , m_dxdt.m_v ); m_first_call = false; } /** * \brief Initializes the internal state storing an internal copy of the derivative. * * \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 initial state of the ODE which should be solved. * \param t The initial time. */ 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; } /** * \brief Returns true if the stepper has been initialized, false otherwise. * * \return true, if the stepper has been initialized, false otherwise. */ bool is_initialized( void ) const { return ! m_first_call; } /** * \brief Adjust the size of all temporaries in the stepper manually. * \param x A state from which the size of the temporaries to be resized is deduced. */ template< class StateType > void adjust_size( const StateType &x ) { resize_m_xerr_impl( x ); resize_m_dxdt_impl( x ); resize_m_dxdt_new_impl( x ); resize_m_xnew_impl( x ); } /** * \brief Returns the instance of the underlying stepper. * \returns The instance of the underlying stepper. */ stepper_type& stepper( void ) { return m_stepper; } /** * \brief Returns the instance of the underlying stepper. * \returns The instance of the underlying stepper. */ const stepper_type& stepper( void ) const { return m_stepper; } private: template< class StateIn > bool resize_m_xerr_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_xerr , x , typename is_resizeable<state_type>::type() ); } template< class StateIn > bool resize_m_dxdt_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() ); } template< class StateIn > bool resize_m_dxdt_new_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_dxdtnew , x , typename is_resizeable<deriv_type>::type() ); } template< class StateIn > bool resize_m_xnew_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_xnew , x , typename is_resizeable<state_type>::type() ); } template< class System , class StateInOut > controlled_step_result try_step_v1( System system , StateInOut &x , time_type &t , time_type &dt ) { if( m_dxdt_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ) || m_first_call ) { initialize( system , x , t ); } return try_step( system , x , m_dxdt.m_v , t , dt ); } stepper_type m_stepper; error_checker_type m_error_checker; step_adjuster_type m_step_adjuster; typedef typename unwrap_reference< step_adjuster_type >::type unwrapped_step_adjuster; resizer_type m_dxdt_resizer; resizer_type m_xerr_resizer; resizer_type m_xnew_resizer; resizer_type m_dxdt_new_resizer; wrapped_deriv_type m_dxdt; wrapped_state_type m_xerr; wrapped_state_type m_xnew; wrapped_deriv_type m_dxdtnew; bool m_first_call; }; /********** DOXYGEN **********/ /**** DEFAULT ERROR CHECKER ****/ /** * \class default_error_checker * \brief The default error checker to be used with Runge-Kutta error steppers * * This class provides the default mechanism to compare the error estimates * reported by Runge-Kutta error steppers with user defined error bounds. * It is used by the controlled_runge_kutta steppers. * * \tparam Value The value type. * \tparam Time The time type. * \tparam Algebra The algebra type. * \tparam Operations The operations type. */ /** * \fn default_error_checker( value_type eps_abs , value_type eps_rel , value_type a_x , value_type a_dxdt , * time_type max_dt) * \brief Constructs the error checker. * * The error is calculated as follows: ???? * * \param eps_abs Absolute tolerance level. * \param eps_rel Relative tolerance level. * \param a_x Factor for the weight of the state. * \param a_dxdt Factor for the weight of the derivative. * \param max_dt Maximum allowed step size. */ /** * \fn error( const State &x_old , const Deriv &dxdt_old , Err &x_err , time_type dt ) const * \brief Calculates the error level. * * If the returned error level is greater than 1, the estimated error was * larger than the permitted error bounds and the step should be repeated * with a smaller step size. * * \param x_old State at the beginning of the step. * \param dxdt_old Derivative at the beginning of the step. * \param x_err Error estimate. * \param dt Time step. * \return error */ /** * \fn error( algebra_type &algebra , const State &x_old , const Deriv &dxdt_old , Err &x_err , time_type dt ) const * \brief Calculates the error level using a given algebra. * * If the returned error level is greater than 1, the estimated error was * larger than the permitted error bounds and the step should be repeated * with a smaller step size. * * \param algebra The algebra used for calculation of the error. * \param x_old State at the beginning of the step. * \param dxdt_old Derivative at the beginning of the step. * \param x_err Error estimate. * \param dt Time step. * \return error */ /** * \fn time_type decrease_step(const time_type dt, const value_type error, const int error_order) * \brief Returns a decreased step size based on the given error and order * * Calculates a new smaller step size based on the given error and its order. * * \param dt The old step size. * \param error The computed error estimate. * \param error_order The error order of the stepper. * \return dt_new The new, reduced step size. */ /** * \fn time_type increase_step(const time_type dt, const value_type error, const int error_order) * \brief Returns an increased step size based on the given error and order. * * Calculates a new bigger step size based on the given error and its order. If max_dt != 0, the * new step size is limited to max_dt. * * \param dt The old step size. * \param error The computed error estimate. * \param error_order The order of the stepper. * \return dt_new The new, increased step size. */ } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED PK 䄟[p��Tw w , stepper/adaptive_adams_bashforth_moulton.hppnu �[��� /* boost/numeric/odeint/stepper/detail/adaptive_adams_bashforth_moulton.hpp [begin_description] Implemetation of an adaptive adams bashforth moulton stepper. Used as the stepper for the controlled adams bashforth moulton stepper. [end_description] Copyright 2017 Valentin Noah Hartmann 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_ADAPTIVE_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_ADAPTIVE_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED #include <boost/numeric/odeint/stepper/detail/adaptive_adams_coefficients.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/util/copy.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.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> #include <boost/numeric/odeint/stepper/detail/rotating_buffer.hpp> namespace boost { namespace numeric { namespace odeint { template< size_t Steps, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer > class adaptive_adams_bashforth_moulton: public algebra_stepper_base< Algebra , Operations > { public: static const size_t steps = Steps; typedef unsigned short order_type; static const order_type order_value = steps; typedef State state_type; typedef Value value_type; typedef Deriv deriv_type; typedef Time time_type; typedef state_wrapper< state_type > wrapped_state_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; 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 Resizer resizer_type; typedef error_stepper_tag stepper_category; typedef detail::adaptive_adams_coefficients< Steps , Deriv , Value , Time , Algebra , Operations , Resizer > coeff_type; typedef adaptive_adams_bashforth_moulton< Steps , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_type; order_type order() const { return order_value; }; order_type stepper_order() const { return order_value + 1; }; order_type error_order() const { return order_value; }; adaptive_adams_bashforth_moulton( const algebra_type &algebra = algebra_type() ) :algebra_stepper_base_type( algebra ), m_coeff(), m_dxdt_resizer(), m_xnew_resizer(), m_xerr_resizer() {}; template< class System > void do_step(System system, state_type &inOut, time_type t, time_type dt ) { m_xnew_resizer.adjust_size( inOut , detail::bind( &stepper_type::template resize_xnew_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); do_step(system, inOut, t, m_xnew.m_v, dt, m_xerr.m_v); boost::numeric::odeint::copy( m_xnew.m_v , inOut); }; template< class System > void do_step(System system, const state_type &in, time_type t, state_type &out, time_type dt ) { do_step(system, in, t, out, dt, m_xerr.m_v); }; template< class System > void do_step(System system, state_type &inOut, time_type t, time_type dt, state_type &xerr) { m_xnew_resizer.adjust_size( inOut , detail::bind( &stepper_type::template resize_xnew_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); do_step(system, inOut, t, m_xnew.m_v, dt, xerr); boost::numeric::odeint::copy( m_xnew.m_v , inOut); }; template< class System > void do_step(System system, const state_type &in, time_type t, state_type &out, time_type dt , state_type &xerr) { do_step_impl(system, in, t, out, dt, xerr); system(out, m_dxdt.m_v, t+dt); m_coeff.do_step(m_dxdt.m_v); m_coeff.confirm(); if(m_coeff.m_eo < order_value) { m_coeff.m_eo ++; } }; template< class ExplicitStepper, class System > void initialize(ExplicitStepper stepper, System system, state_type &inOut, time_type &t, time_type dt) { reset(); dt = dt/static_cast< time_type >(order_value); m_dxdt_resizer.adjust_size( inOut , detail::bind( &stepper_type::template resize_dxdt_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); system( inOut , m_dxdt.m_v , t ); for( size_t i=0 ; i<order_value; ++i ) { stepper.do_step_dxdt_impl( system, inOut, m_dxdt.m_v, t, dt ); system( inOut , m_dxdt.m_v , t + dt); m_coeff.predict(t, dt); m_coeff.do_step(m_dxdt.m_v); m_coeff.confirm(); t += dt; if(m_coeff.m_eo < order_value) { ++m_coeff.m_eo; } } }; template< class System > void initialize(System system, state_type &inOut, time_type &t, time_type dt) { reset(); dt = dt/static_cast< time_type >(order_value); for(size_t i=0; i<order_value; ++i) { this->do_step(system, inOut, t, dt); t += dt; }; }; template< class System > void do_step_impl(System system, const state_type & in, time_type t, state_type & out, time_type &dt, state_type &xerr) { size_t eO = m_coeff.m_eo; m_xerr_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_xerr_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); m_dxdt_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_dxdt_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); m_coeff.predict(t, dt); if (m_coeff.m_steps_init == 1) { system(in, m_dxdt.m_v, t); m_coeff.do_step(m_dxdt.m_v, 1); } boost::numeric::odeint::copy( in , out ); for(size_t i=0; i<eO; ++i) { this->m_algebra.for_each3(out, out, m_coeff.phi[1][i].m_v, typename Operations::template scale_sum2<double, double>(1.0, dt*m_coeff.g[i]*m_coeff.beta[0][i])); } system(out, m_dxdt.m_v, t+dt); m_coeff.do_step(m_dxdt.m_v); this->m_algebra.for_each3(out, out, m_coeff.phi[0][eO].m_v, typename Operations::template scale_sum2<double, double>(1.0, dt*m_coeff.g[eO])); // error for current order this->m_algebra.for_each2(xerr, m_coeff.phi[0][eO].m_v, typename Operations::template scale_sum1<double>(dt*(m_coeff.g[eO]))); }; const coeff_type& coeff() const { return m_coeff; }; coeff_type & coeff() { return m_coeff; }; void reset() { m_coeff.reset(); }; const deriv_type & dxdt() const { return m_dxdt.m_v; }; private: template< class StateType > bool resize_dxdt_impl( const StateType &x ) { return adjust_size_by_resizeability( m_dxdt, x, typename is_resizeable<deriv_type>::type() ); }; template< class StateType > bool resize_xnew_impl( const StateType &x ) { return adjust_size_by_resizeability( m_xnew, x, typename is_resizeable<state_type>::type() ); }; template< class StateType > bool resize_xerr_impl( const StateType &x ) { return adjust_size_by_resizeability( m_xerr, x, typename is_resizeable<state_type>::type() ); }; coeff_type m_coeff; resizer_type m_dxdt_resizer; resizer_type m_xnew_resizer; resizer_type m_xerr_resizer; wrapped_deriv_type m_dxdt; wrapped_state_type m_xnew; wrapped_state_type m_xerr; }; } // odeint } // numeric } // boost #endifPK 䄟[�����) �) % stepper/explicit_error_generic_rk.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp [begin_description] Implementation of the generic Runge Kutta error stepper. Base class for many RK error steppers. [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_EXPLICIT_ERROR_GENERIC_RK_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_ERROR_GENERIC_RK_HPP_INCLUDED #include <boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp> #include <boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp> #include <boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp> #include <boost/numeric/odeint/util/state_wrapper.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resizer.hpp> namespace boost { namespace numeric { namespace odeint { template< size_t StageCount, size_t Order, size_t StepperOrder , size_t ErrorOrder , class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class explicit_error_generic_rk : public explicit_error_stepper_base< explicit_error_generic_rk< StageCount , Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra , Operations , Resizer > , Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else class explicit_error_generic_rk : public explicit_error_stepper_base #endif { public: #ifndef DOXYGEN_SKIP typedef explicit_error_stepper_base< explicit_error_generic_rk< StageCount , Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra , Operations , Resizer > , Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; #else typedef explicit_stepper_base< ... > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; #ifndef DOXYGEN_SKIP typedef explicit_error_generic_rk< StageCount , Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_type; #endif typedef detail::generic_rk_algorithm< StageCount , Value , Algebra , Operations > rk_algorithm_type; typedef typename rk_algorithm_type::coef_a_type coef_a_type; typedef typename rk_algorithm_type::coef_b_type coef_b_type; typedef typename rk_algorithm_type::coef_c_type coef_c_type; static const size_t stage_count = StageCount; private: public: // we use an explicit_generic_rk to do the normal rk step // and add a separate calculation of the error estimate afterwards explicit_error_generic_rk( const coef_a_type &a , const coef_b_type &b , const coef_b_type &b2 , const coef_c_type &c , const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra ) , m_rk_algorithm( a , b , c ) , m_b2( b2 ) { } template< class System , class StateIn , class DerivIn , class StateOut , class Err > void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr ) { // normal step do_step_impl( system , in , dxdt , t , out , dt ); // additionally, perform the error calculation detail::template generic_rk_call_algebra< StageCount , algebra_type >()( stepper_base_type::m_algebra , xerr , dxdt , m_F , detail::generic_rk_scale_sum_err< StageCount , operations_type , value_type , time_type >( m_b2 , dt) ); } template< class System , class StateIn , class DerivIn , class StateOut > void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) { m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ); // actual calculation done in generic_rk.hpp m_rk_algorithm.do_step( stepper_base_type::m_algebra , system , in , dxdt , t , out , dt , m_x_tmp.m_v , m_F ); } template< class StateIn > void adjust_size( const StateIn &x ) { resize_impl( x ); stepper_base_type::adjust_size( x ); } private: template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized( false ); resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() ); for( size_t i = 0 ; i < StageCount-1 ; ++i ) { resized |= adjust_size_by_resizeability( m_F[i] , x , typename is_resizeable<deriv_type>::type() ); } return resized; } rk_algorithm_type m_rk_algorithm; coef_b_type m_b2; resizer_type m_resizer; wrapped_state_type m_x_tmp; wrapped_deriv_type m_F[StageCount-1]; }; /********* DOXYGEN *********/ /** * \class explicit_error_generic_rk * \brief A generic implementation of explicit Runge-Kutta algorithms with error estimation. This class is as a * base class for all explicit Runge-Kutta steppers with error estimation. * * This class implements the explicit Runge-Kutta algorithms with error estimation in a generic way. * The Butcher tableau is passed to the stepper which constructs the stepper scheme with the help of a * template-metaprogramming algorithm. ToDo : Add example! * * This class derives explicit_error_stepper_base which provides the stepper interface. * * \tparam StageCount The number of stages of the Runge-Kutta algorithm. * \tparam Order The order of a stepper if the stepper is used without error estimation. * \tparam StepperOrder The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have * the same value. * \tparam ErrorOrder The order of the error step if the stepper is used with error estimation. * \tparam State The type representing the state of the ODE. * \tparam Value The floating point type which is used in the computations. * \tparam Time The type representing the independent variable - the time - of the ODE. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn explicit_error_generic_rk::explicit_error_generic_rk( const coef_a_type &a , const coef_b_type &b , const coef_b_type &b2 , const coef_c_type &c , const algebra_type &algebra ) * \brief Constructs the explicit_error_generik_rk class with the given parameters a, b, b2 and c. See examples section for details on the coefficients. * * \param a Triangular matrix of parameters b in the Butcher tableau. * \param b Last row of the butcher tableau. * \param b2 Parameters for lower-order evaluation to estimate the error. * \param c Parameters to calculate the time points in the Butcher tableau. * \param algebra A copy of algebra is made and stored inside explicit_stepper_base. */ /** * \fn explicit_error_generic_rk::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr ) * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. * The result is updated out-of-place, hence the input is in `in` and the output in `out`. Futhermore, an * estimation of the error is stored in `xerr`. `do_step_impl` is used by explicit_error_stepper_base. * * \param system The system function to solve, hence the r.h.s. of the ODE. It must 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 result of the error estimation is written in xerr. */ /** * \fn explicit_error_generic_rk::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. * The result is updated out-of-place, hence the input is in `in` and the output in `out`. * Access to this step functionality is provided by explicit_stepper_base and * `do_step_impl` should not be called directly. * * \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_generic_rk::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. */ } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_ERROR_GENERIC_RK_HPP_INCLUDED PK 䄟[*w�x� � $ stepper/rosenbrock4_dense_output.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp [begin_description] Dense output for Rosenbrock 4. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-2015 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_ROSENBROCK4_DENSE_OUTPUT_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_DENSE_OUTPUT_HPP_INCLUDED #include <utility> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/stepper/rosenbrock4_controller.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/integrate/max_step_checker.hpp> namespace boost { namespace numeric { namespace odeint { template< class ControlledStepper > class rosenbrock4_dense_output { public: typedef ControlledStepper controlled_stepper_type; typedef typename unwrap_reference< controlled_stepper_type >::type unwrapped_controlled_stepper_type; typedef typename unwrapped_controlled_stepper_type::stepper_type stepper_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::state_type state_type; typedef typename stepper_type::wrapped_state_type wrapped_state_type; typedef typename stepper_type::time_type time_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type; typedef typename stepper_type::resizer_type resizer_type; typedef dense_output_stepper_tag stepper_category; typedef rosenbrock4_dense_output< ControlledStepper > dense_output_stepper_type; rosenbrock4_dense_output( const controlled_stepper_type &stepper = controlled_stepper_type() ) : m_stepper( stepper ) , m_x1() , m_x2() , m_current_state_x1( true ) , m_t() , m_t_old() , m_dt() { } template< class StateType > void initialize( const StateType &x0 , time_type t0 , time_type dt0 ) { m_resizer.adjust_size( x0 , detail::bind( &dense_output_stepper_type::template resize_impl< StateType > , detail::ref( *this ) , detail::_1 ) ); get_current_state() = x0; m_t = t0; m_dt = dt0; } template< class System > std::pair< time_type , time_type > do_step( System system ) { unwrapped_controlled_stepper_type &stepper = m_stepper; failed_step_checker fail_checker; // to throw a runtime_error if step size adjustment fails controlled_step_result res = fail; m_t_old = m_t; do { res = stepper.try_step( system , get_current_state() , m_t , get_old_state() , m_dt ); fail_checker(); // check for overflow of failed steps } while( res == fail ); stepper.stepper().prepare_dense_output(); this->toggle_current_state(); return std::make_pair( m_t_old , m_t ); } /* * The two overloads are needed in order to solve the forwarding problem. */ template< class StateOut > void calc_state( time_type t , StateOut &x ) { unwrapped_controlled_stepper_type &stepper = m_stepper; stepper.stepper().calc_state( t , x , get_old_state() , m_t_old , get_current_state() , m_t ); } template< class StateOut > void calc_state( time_type t , const StateOut &x ) { unwrapped_controlled_stepper_type &stepper = m_stepper; stepper.stepper().calc_state( t , x , get_old_state() , m_t_old , get_current_state() , m_t ); } template< class StateType > void adjust_size( const StateType &x ) { unwrapped_controlled_stepper_type &stepper = m_stepper; stepper.adjust_size( x ); resize_impl( x ); } const state_type& current_state( void ) const { return get_current_state(); } time_type current_time( void ) const { return m_t; } const state_type& previous_state( void ) const { return get_old_state(); } time_type previous_time( void ) const { return m_t_old; } time_type current_time_step( void ) const { return m_dt; } private: state_type& get_current_state( void ) { return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ; } const state_type& get_current_state( void ) const { return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ; } state_type& get_old_state( void ) { return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ; } const state_type& get_old_state( void ) const { return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ; } void toggle_current_state( void ) { m_current_state_x1 = ! m_current_state_x1; } template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() ); return resized; } controlled_stepper_type m_stepper; resizer_type m_resizer; wrapped_state_type m_x1 , m_x2; bool m_current_state_x1; time_type m_t , m_t_old , m_dt; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_DENSE_OUTPUT_HPP_INCLUDED PK 䄟[5X���+ �+ ! stepper/extrapolation_stepper.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/extrapolation_stepper.hpp [begin_description] extrapolation stepper [end_description] Copyright 2009-2015 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_EXTRAPOLATION_STEPPER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_EXTRAPOLATION_STEPPER_HPP_INCLUDED #include <iostream> #include <algorithm> #include <boost/config.hpp> // for min/max guidelines #include <boost/static_assert.hpp> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp> #include <boost/numeric/odeint/stepper/modified_midpoint.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.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/unit_helper.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> namespace boost { namespace numeric { namespace odeint { template < unsigned short Order, class State, class Value = double, class Deriv = State, class Time = Value, class Algebra = typename algebra_dispatcher< State >::algebra_type, class Operations = typename operations_dispatcher< State >::operations_type, class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class extrapolation_stepper : public explicit_error_stepper_base< extrapolation_stepper< Order, State, Value, Deriv, Time, Algebra, Operations, Resizer >, Order, Order, Order - 2, State, Value, Deriv, Time, Algebra, Operations, Resizer > #else class extrapolation_stepper : public explicit_error_stepper_base #endif { private: // check for Order being odd BOOST_STATIC_ASSERT_MSG( ( ( Order % 2 ) == 0 ) && ( Order > 2 ), "extrapolation_stepper requires even Order larger than 2" ); public: #ifndef DOXYGEN_SKIP typedef explicit_error_stepper_base< extrapolation_stepper< Order, State, Value, Deriv, Time, Algebra, Operations, Resizer >, Order, Order, Order - 2, State, Value, Deriv, Time, Algebra, Operations, Resizer > stepper_base_type; #else typedef explicit_error_stepper_base< extrapolation_stepper< ... >, ... > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; #ifndef DOXYGEN_SKIP typedef typename stepper_base_type::stepper_type stepper_type; typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; typedef std::vector< value_type > value_vector; typedef std::vector< value_vector > value_matrix; typedef std::vector< size_t > int_vector; typedef std::vector< wrapped_state_type > state_table_type; typedef modified_midpoint< state_type, value_type, deriv_type, time_type, algebra_type, operations_type, resizer_type > midpoint_stepper_type; #endif // DOXYGEN_SKIP typedef unsigned short order_type; static const order_type order_value = stepper_base_type::order_value; static const order_type stepper_order_value = stepper_base_type::stepper_order_value; static const order_type error_order_value = stepper_base_type::error_order_value; const static size_t m_k_max = ( order_value - 2 ) / 2; extrapolation_stepper( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra ), m_interval_sequence( m_k_max + 1 ), m_coeff( m_k_max + 1 ), m_table( m_k_max ) { for ( unsigned short i = 0; i < m_k_max + 1; i++ ) { m_interval_sequence[i] = 2 * ( i + 1 ); m_coeff[i].resize( i ); for ( size_t k = 0; k < i; ++k ) { const value_type r = static_cast< value_type >( m_interval_sequence[i] ) / static_cast< value_type >( m_interval_sequence[k] ); m_coeff[i][k] = static_cast< value_type >( 1 ) / ( r * r - static_cast< value_type >( 1 ) ); // coefficients for extrapolation } } } template < class System, class StateIn, class DerivIn, class StateOut, class Err > void do_step_impl( System system, const StateIn &in, const DerivIn &dxdt, time_type t, StateOut &out, time_type dt, Err &xerr ) { // std::cout << "dt: " << dt << std::endl; // normal step do_step_impl( system, in, dxdt, t, out, dt ); static const value_type val1( 1.0 ); // additionally, perform the error calculation stepper_base_type::m_algebra.for_each3( xerr, out, m_table[0].m_v, typename operations_type::template scale_sum2< value_type, value_type >( val1, -val1 ) ); } template < class System, class StateInOut, class DerivIn, class Err > void do_step_impl_io( System system, StateInOut &inout, const DerivIn &dxdt, time_type t, time_type dt, Err &xerr ) { // normal step do_step_impl_io( system, inout, dxdt, t, dt ); static const value_type val1( 1.0 ); // additionally, perform the error calculation stepper_base_type::m_algebra.for_each3( xerr, inout, m_table[0].m_v, typename operations_type::template scale_sum2< value_type, value_type >( val1, -val1 ) ); } template < class System, class StateIn, class DerivIn, class StateOut > void do_step_impl( System system, const StateIn &in, const DerivIn &dxdt, time_type t, StateOut &out, time_type dt ) { m_resizer.adjust_size( in, detail::bind( &stepper_type::template resize_impl< StateIn >, detail::ref( *this ), detail::_1 ) ); size_t k = 0; m_midpoint.set_steps( m_interval_sequence[k] ); m_midpoint.do_step( system, in, dxdt, t, out, dt ); for ( k = 1; k <= m_k_max; ++k ) { m_midpoint.set_steps( m_interval_sequence[k] ); m_midpoint.do_step( system, in, dxdt, t, m_table[k - 1].m_v, dt ); extrapolate( k, m_table, m_coeff, out ); } } template < class System, class StateInOut, class DerivIn > void do_step_impl_io( System system, StateInOut &inout, const DerivIn &dxdt, time_type t, time_type dt ) { // special care for inout m_xout_resizer.adjust_size( inout, detail::bind( &stepper_type::template resize_m_xout< StateInOut >, detail::ref( *this ), detail::_1 ) ); do_step_impl( system, inout, dxdt, t, m_xout.m_v, dt ); boost::numeric::odeint::copy( m_xout.m_v, inout ); } 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 ) { do_step_impl_io( system , x , dxdt , t , dt ); } 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 ) { do_step_impl( system , in , dxdt , t , out , dt ); } template < class StateIn > void adjust_size( const StateIn &x ) { resize_impl( x ); m_midpoint.adjust_size( x ); } private: template < class StateIn > bool resize_impl( const StateIn &x ) { bool resized( false ); for ( size_t i = 0; i < m_k_max; ++i ) resized |= adjust_size_by_resizeability( m_table[i], x, typename is_resizeable< state_type >::type() ); return resized; } template < class StateIn > bool resize_m_xout( const StateIn &x ) { return adjust_size_by_resizeability( m_xout, x, typename is_resizeable< state_type >::type() ); } template < class StateInOut > void extrapolate( size_t k, state_table_type &table, const value_matrix &coeff, StateInOut &xest ) /* polynomial extrapolation, see http://www.nr.com/webnotes/nr3web21.pdf uses the obtained intermediate results to extrapolate to dt->0 */ { static const value_type val1 = static_cast< value_type >( 1.0 ); for ( int j = k - 1; j > 0; --j ) { stepper_base_type::m_algebra.for_each3( table[j - 1].m_v, table[j].m_v, table[j - 1].m_v, typename operations_type::template scale_sum2< value_type, value_type >( val1 + coeff[k][j], -coeff[k][j] ) ); } stepper_base_type::m_algebra.for_each3( xest, table[0].m_v, xest, typename operations_type::template scale_sum2< value_type, value_type >( val1 + coeff[k][0], -coeff[k][0] ) ); } private: midpoint_stepper_type m_midpoint; resizer_type m_resizer; resizer_type m_xout_resizer; int_vector m_interval_sequence; // stores the successive interval counts value_matrix m_coeff; wrapped_state_type m_xout; state_table_type m_table; // sequence of states for extrapolation }; /******** DOXYGEN *******/ /** * \class extrapolation_stepper * \brief Extrapolation stepper with configurable order, and error estimation. * * The extrapolation stepper is a stepper with error estimation and configurable * order. The order is given as template parameter and needs to be an _odd_ * number. The stepper is based on several executions of the modified midpoint * method and a Richardson extrapolation. This is essentially the same technique * as for bulirsch_stoer, but without the variable order. * * \note The Order parameter has to be an even number greater 2. */ } } } #endif PK 䄟[6S , stepper/symplectic_rkn_sb3a_m4_mclachlan.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp [begin_description] tba. [end_description] Copyright 2012-2013 Karsten Ahnert Copyright 2012-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_STEPPER_SYMPLECTIC_RKN_SB3A_M4_MCLACHLAN_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_M4_MCLACHLAN_HPP_DEFINED #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/util/resizer.hpp> namespace boost { namespace numeric { namespace odeint { #ifndef DOXYGEN_SKIP namespace detail { namespace symplectic_rkn_sb3a_m4_mclachlan { /* exp( a1 t A ) exp( b1 t B ) exp( a2 t A ) exp( b2 t B ) exp( a3 t A ) exp( b2 t B ) exp( a2 t A ) exp( b1 t B ) exp( a1 t A ) */ template< class Value > struct coef_a_type : public boost::array< Value , 5 > { coef_a_type( void ) { using std::sqrt; Value z = sqrt( static_cast< Value >( 7 ) / static_cast< Value >( 8 ) ) / static_cast< Value >( 3 ); (*this)[0] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ) - z ; (*this)[1] = static_cast< Value >( -1 ) / static_cast< Value >( 3 ) + z ; (*this)[2] = static_cast< Value >( 2 ) / static_cast< Value >( 3 ); (*this)[3] = (*this)[1]; (*this)[4] = (*this)[0]; } }; template< class Value > struct coef_b_type : public boost::array< Value , 5 > { coef_b_type( void ) { (*this)[0] = static_cast< Value >( 1 ); (*this)[1] = static_cast< Value >( -1 ) / static_cast< Value >( 2 ); (*this)[2] = (*this)[1]; (*this)[3] = (*this)[0]; (*this)[4] = static_cast< Value >( 0 ); } }; } // namespace symplectic_rkn_sb3a_m4_mclachlan } // namespace detail #endif // DOXYGEN_SKIP template< class Coor , class Momentum = Coor , class Value = double , class CoorDeriv = Coor , class MomentumDeriv = Coor , class Time = Value , class Algebra = typename algebra_dispatcher< Coor >::algebra_type , class Operations = typename operations_dispatcher< Coor >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class symplectic_rkn_sb3a_m4_mclachlan : public symplectic_nystroem_stepper_base < 5 , 4 , Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > #else class symplectic_rkn_sb3a_m4_mclachlan : public symplectic_nystroem_stepper_base #endif { public: #ifndef DOXYGEN_SKIP typedef symplectic_nystroem_stepper_base < 5 , 4 , Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > stepper_base_type; #endif typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::value_type value_type; symplectic_rkn_sb3a_m4_mclachlan( const algebra_type &algebra = algebra_type() ) : stepper_base_type( detail::symplectic_rkn_sb3a_m4_mclachlan::coef_a_type< value_type >() , detail::symplectic_rkn_sb3a_m4_mclachlan::coef_b_type< value_type >() , algebra ) { } }; /***************** DOXYGEN ***************/ /** * \class symplectic_rkn_sb3a_m4_mclachlan * \brief Implementation of the symmetric B3A Runge-Kutta Nystroem method of fifth order. * * The method is of fourth order and has five stages. It is described HERE. This method can be used * with multiprecision types since the coefficients are defined analytically. * * ToDo: add reference to paper. * * \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_rkn_sb3a_m4_mclachlan::symplectic_rkn_sb3a_m4_mclachlan( const algebra_type &algebra ) * \brief Constructs the symplectic_rkn_sb3a_m4_mclachlan. 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. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_M4_MCLACHLAN_HPP_DEFINED PK 䄟[���S �S stepper/runge_kutta_dopri5.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp [begin_description] Implementation of the Dormand-Prince 5(4) method. This stepper can also be used with the dense-output controlled stepper. [end_description] Copyright 2010-2013 Karsten Ahnert Copyright 2010-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_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.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/same_instance.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > class runge_kutta_dopri5 #ifndef DOXYGEN_SKIP : public explicit_error_stepper_fsal_base< runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else : public explicit_error_stepper_fsal_base #endif { public : #ifndef DOXYGEN_SKIP typedef explicit_error_stepper_fsal_base< runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; #else typedef explicit_error_stepper_fsal_base< runge_kutta_dopri5< ... > , ... > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; #ifndef DOXYGEN_SKIP typedef typename stepper_base_type::stepper_type stepper_type; typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; #endif // DOXYGEN_SKIP runge_kutta_dopri5( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra ) { } template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut > void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt ) { const value_type a2 = static_cast<value_type> ( 1 ) / static_cast<value_type>( 5 ); const value_type a3 = static_cast<value_type> ( 3 ) / static_cast<value_type> ( 10 ); const value_type a4 = static_cast<value_type> ( 4 ) / static_cast<value_type> ( 5 ); const value_type a5 = static_cast<value_type> ( 8 )/static_cast<value_type> ( 9 ); const value_type b21 = static_cast<value_type> ( 1 ) / static_cast<value_type> ( 5 ); const value_type b31 = static_cast<value_type> ( 3 ) / static_cast<value_type>( 40 ); const value_type b32 = static_cast<value_type> ( 9 ) / static_cast<value_type>( 40 ); const value_type b41 = static_cast<value_type> ( 44 ) / static_cast<value_type> ( 45 ); const value_type b42 = static_cast<value_type> ( -56 ) / static_cast<value_type> ( 15 ); const value_type b43 = static_cast<value_type> ( 32 ) / static_cast<value_type> ( 9 ); const value_type b51 = static_cast<value_type> ( 19372 ) / static_cast<value_type>( 6561 ); const value_type b52 = static_cast<value_type> ( -25360 ) / static_cast<value_type> ( 2187 ); const value_type b53 = static_cast<value_type> ( 64448 ) / static_cast<value_type>( 6561 ); const value_type b54 = static_cast<value_type> ( -212 ) / static_cast<value_type>( 729 ); const value_type b61 = static_cast<value_type> ( 9017 ) / static_cast<value_type>( 3168 ); const value_type b62 = static_cast<value_type> ( -355 ) / static_cast<value_type>( 33 ); const value_type b63 = static_cast<value_type> ( 46732 ) / static_cast<value_type>( 5247 ); const value_type b64 = static_cast<value_type> ( 49 ) / static_cast<value_type>( 176 ); const value_type b65 = static_cast<value_type> ( -5103 ) / static_cast<value_type>( 18656 ); const value_type c1 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 384 ); const value_type c3 = static_cast<value_type> ( 500 ) / static_cast<value_type>( 1113 ); const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 192 ); const value_type c5 = static_cast<value_type> ( -2187 ) / static_cast<value_type>( 6784 ); const value_type c6 = static_cast<value_type> ( 11 ) / static_cast<value_type>( 84 ); typename odeint::unwrap_reference< System >::type &sys = system; m_k_x_tmp_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_k_x_tmp_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ); //m_x_tmp = x + dt*b21*dxdt stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , dxdt_in , typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , dt*b21 ) ); sys( m_x_tmp.m_v , m_k2.m_v , t + dt*a2 ); // m_x_tmp = x + dt*b31*dxdt + dt*b32*m_k2 stepper_base_type::m_algebra.for_each4( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , typename operations_type::template scale_sum3< value_type , time_type , time_type >( 1.0 , dt*b31 , dt*b32 )); sys( m_x_tmp.m_v , m_k3.m_v , t + dt*a3 ); // m_x_tmp = x + dt * (b41*dxdt + b42*m_k2 + b43*m_k3) stepper_base_type::m_algebra.for_each5( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , m_k3.m_v , typename operations_type::template scale_sum4< value_type , time_type , time_type , time_type >( 1.0 , dt*b41 , dt*b42 , dt*b43 )); sys( m_x_tmp.m_v, m_k4.m_v , t + dt*a4 ); stepper_base_type::m_algebra.for_each6( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , m_k3.m_v , m_k4.m_v , typename operations_type::template scale_sum5< value_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b51 , dt*b52 , dt*b53 , dt*b54 )); sys( m_x_tmp.m_v , m_k5.m_v , t + dt*a5 ); stepper_base_type::m_algebra.for_each7( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , m_k3.m_v , m_k4.m_v , m_k5.m_v , typename operations_type::template scale_sum6< value_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b61 , dt*b62 , dt*b63 , dt*b64 , dt*b65 )); sys( m_x_tmp.m_v , m_k6.m_v , t + dt ); stepper_base_type::m_algebra.for_each7( out , in , dxdt_in , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , typename operations_type::template scale_sum6< value_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt*c1 , dt*c3 , dt*c4 , dt*c5 , dt*c6 )); // the new derivative sys( out , dxdt_out , t + dt ); } template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut , class Err > void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr ) { const value_type c1 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 384 ); const value_type c3 = static_cast<value_type> ( 500 ) / static_cast<value_type>( 1113 ); const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 192 ); const value_type c5 = static_cast<value_type> ( -2187 ) / static_cast<value_type>( 6784 ); const value_type c6 = static_cast<value_type> ( 11 ) / static_cast<value_type>( 84 ); const value_type dc1 = c1 - static_cast<value_type> ( 5179 ) / static_cast<value_type>( 57600 ); const value_type dc3 = c3 - static_cast<value_type> ( 7571 ) / static_cast<value_type>( 16695 ); const value_type dc4 = c4 - static_cast<value_type> ( 393 ) / static_cast<value_type>( 640 ); const value_type dc5 = c5 - static_cast<value_type> ( -92097 ) / static_cast<value_type>( 339200 ); const value_type dc6 = c6 - static_cast<value_type> ( 187 ) / static_cast<value_type>( 2100 ); const value_type dc7 = static_cast<value_type>( -1 ) / static_cast<value_type> ( 40 ); /* ToDo: copy only if &dxdt_in == &dxdt_out ? */ if( same_instance( dxdt_in , dxdt_out ) ) { m_dxdt_tmp_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_dxdt_tmp_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ); boost::numeric::odeint::copy( dxdt_in , m_dxdt_tmp.m_v ); do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt ); //error estimate stepper_base_type::m_algebra.for_each7( xerr , m_dxdt_tmp.m_v , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , dxdt_out , typename operations_type::template scale_sum6< time_type , time_type , time_type , time_type , time_type , time_type >( dt*dc1 , dt*dc3 , dt*dc4 , dt*dc5 , dt*dc6 , dt*dc7 ) ); } else { do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt ); //error estimate stepper_base_type::m_algebra.for_each7( xerr , dxdt_in , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , dxdt_out , typename operations_type::template scale_sum6< time_type , time_type , time_type , time_type , time_type , time_type >( dt*dc1 , dt*dc3 , dt*dc4 , dt*dc5 , dt*dc6 , dt*dc7 ) ); } } /* * Calculates Dense-Output for Dopri5 * * See Hairer, Norsett, Wanner: Solving Ordinary Differential Equations, Nonstiff Problems. I, p.191/192 * * y(t+theta) = y(t) + h * sum_i^7 b_i(theta) * k_i * * A = theta^2 * ( 3 - 2 theta ) * B = theta^2 * ( theta - 1 ) * C = theta^2 * ( theta - 1 )^2 * D = theta * ( theta - 1 )^2 * * b_1( theta ) = A * b_1 - C * X1( theta ) + D * b_2( theta ) = 0 * b_3( theta ) = A * b_3 + C * X3( theta ) * b_4( theta ) = A * b_4 - C * X4( theta ) * b_5( theta ) = A * b_5 + C * X5( theta ) * b_6( theta ) = A * b_6 - C * X6( theta ) * b_7( theta ) = B + C * X7( theta ) * * An alternative Method is described in: * * www-m2.ma.tum.de/homepages/simeon/numerik3/kap3.ps */ template< class StateOut , class StateIn1 , class DerivIn1 , class StateIn2 , class DerivIn2 > void calc_state( time_type t , StateOut &x , const StateIn1 &x_old , const DerivIn1 &deriv_old , time_type t_old , const StateIn2 & /* x_new */ , const DerivIn2 &deriv_new , time_type t_new ) const { const value_type b1 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 384 ); const value_type b3 = static_cast<value_type> ( 500 ) / static_cast<value_type>( 1113 ); const value_type b4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 192 ); const value_type b5 = static_cast<value_type> ( -2187 ) / static_cast<value_type>( 6784 ); const value_type b6 = static_cast<value_type> ( 11 ) / static_cast<value_type>( 84 ); const time_type dt = ( t_new - t_old ); const value_type theta = ( t - t_old ) / dt; const value_type X1 = static_cast< value_type >( 5 ) * ( static_cast< value_type >( 2558722523LL ) - static_cast< value_type >( 31403016 ) * theta ) / static_cast< value_type >( 11282082432LL ); const value_type X3 = static_cast< value_type >( 100 ) * ( static_cast< value_type >( 882725551 ) - static_cast< value_type >( 15701508 ) * theta ) / static_cast< value_type >( 32700410799LL ); const value_type X4 = static_cast< value_type >( 25 ) * ( static_cast< value_type >( 443332067 ) - static_cast< value_type >( 31403016 ) * theta ) / static_cast< value_type >( 1880347072LL ) ; const value_type X5 = static_cast< value_type >( 32805 ) * ( static_cast< value_type >( 23143187 ) - static_cast< value_type >( 3489224 ) * theta ) / static_cast< value_type >( 199316789632LL ); const value_type X6 = static_cast< value_type >( 55 ) * ( static_cast< value_type >( 29972135 ) - static_cast< value_type >( 7076736 ) * theta ) / static_cast< value_type >( 822651844 ); const value_type X7 = static_cast< value_type >( 10 ) * ( static_cast< value_type >( 7414447 ) - static_cast< value_type >( 829305 ) * theta ) / static_cast< value_type >( 29380423 ); const value_type theta_m_1 = theta - static_cast< value_type >( 1 ); const value_type theta_sq = theta * theta; const value_type A = theta_sq * ( static_cast< value_type >( 3 ) - static_cast< value_type >( 2 ) * theta ); const value_type B = theta_sq * theta_m_1; const value_type C = theta_sq * theta_m_1 * theta_m_1; const value_type D = theta * theta_m_1 * theta_m_1; const value_type b1_theta = A * b1 - C * X1 + D; const value_type b3_theta = A * b3 + C * X3; const value_type b4_theta = A * b4 - C * X4; const value_type b5_theta = A * b5 + C * X5; const value_type b6_theta = A * b6 - C * X6; const value_type b7_theta = B + C * X7; // const state_type &k1 = *m_old_deriv; // const state_type &k3 = dopri5().m_k3; // const state_type &k4 = dopri5().m_k4; // const state_type &k5 = dopri5().m_k5; // const state_type &k6 = dopri5().m_k6; // const state_type &k7 = *m_current_deriv; stepper_base_type::m_algebra.for_each8( x , x_old , deriv_old , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , deriv_new , typename operations_type::template scale_sum7< value_type , time_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt * b1_theta , dt * b3_theta , dt * b4_theta , dt * b5_theta , dt * b6_theta , dt * b7_theta ) ); } template< class StateIn > void adjust_size( const StateIn &x ) { resize_k_x_tmp_impl( x ); resize_dxdt_tmp_impl( x ); stepper_base_type::adjust_size( x ); } private: template< class StateIn > bool resize_k_x_tmp_impl( const StateIn &x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_k2 , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_k3 , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_k4 , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_k5 , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_k6 , x , typename is_resizeable<deriv_type>::type() ); return resized; } template< class StateIn > bool resize_dxdt_tmp_impl( const StateIn &x ) { return adjust_size_by_resizeability( m_dxdt_tmp , x , typename is_resizeable<deriv_type>::type() ); } wrapped_state_type m_x_tmp; wrapped_deriv_type m_k2 , m_k3 , m_k4 , m_k5 , m_k6 ; wrapped_deriv_type m_dxdt_tmp; resizer_type m_k_x_tmp_resizer; resizer_type m_dxdt_tmp_resizer; }; /************* DOXYGEN ************/ /** * \class runge_kutta_dopri5 * \brief The Runge-Kutta Dormand-Prince 5 method. * * The Runge-Kutta Dormand-Prince 5 method is a very popular method for solving ODEs, see * <a href=""></a>. * The method is explicit and fulfills the Error Stepper concept. Step size control * is provided but continuous output is available which make this method favourable for many applications. * * This class derives from explicit_error_stepper_fsal_base and inherits its interface via CRTP (current recurring * template pattern). The method possesses the FSAL (first-same-as-last) property. See * explicit_error_stepper_fsal_base for more details. * * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn runge_kutta_dopri5::runge_kutta_dopri5( const algebra_type &algebra ) * \brief Constructs the runge_kutta_dopri5 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 runge_kutta_dopri5::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt ) * \brief This method performs one step. The derivative `dxdt_in` of `in` at the time `t` is passed to the * method. The result is updated out-of-place, hence the input is in `in` and the output in `out`. Furthermore, * the derivative is update out-of-place, hence the input is assumed to be in `dxdt_in` and the output in * `dxdt_out`. * Access to this step functionality is provided by explicit_error_stepper_fsal_base and * `do_step_impl` should not be called directly. * * \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. dxdt_in is not modified by this method * \param t The value of the time, at which the step should be performed. * \param out The result of the step is written in out. * \param dxdt_out The result of the new derivative at time t+dt. * \param dt The step size. */ /** * \fn runge_kutta_dopri5::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr ) * \brief This method performs one step. The derivative `dxdt_in` of `in` at the time `t` is passed to the * method. The result is updated out-of-place, hence the input is in `in` and the output in `out`. Furthermore, * the derivative is update out-of-place, hence the input is assumed to be in `dxdt_in` and the output in * `dxdt_out`. * Access to this step functionality is provided by explicit_error_stepper_fsal_base and * `do_step_impl` should not be called directly. * An estimation of the error is calculated. * * \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. dxdt_in is not modified by this method * \param t The value of the time, at which the step should be performed. * \param out The result of the step is written in out. * \param dxdt_out The result of the new derivative at time t+dt. * \param dt The step size. * \param xerr An estimation of the error. */ /** * \fn runge_kutta_dopri5::calc_state( time_type t , StateOut &x , const StateIn1 &x_old , const DerivIn1 &deriv_old , time_type t_old , const StateIn2 & , const DerivIn2 &deriv_new , time_type t_new ) const * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the * knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`. It also uses * internal variables to calculate the result. Hence this method must be called after two successful `do_step` * calls. */ /** * \fn runge_kutta_dopri5::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_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED PK 䄟[�3F) F) stepper/modified_midpoint.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/modified_midpoint.hpp [begin_description] Modified midpoint method for the use in Burlish-Stoer stepper. [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_MODIFIED_MIDPOINT_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_MODIFIED_MIDPOINT_HPP_INCLUDED #include <vector> #include <boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp> #include <boost/numeric/odeint/util/resizer.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/util/copy.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class modified_midpoint : public explicit_stepper_base< modified_midpoint< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 2 , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else class modified_midpoint : public explicit_stepper_base #endif { public : typedef explicit_stepper_base< modified_midpoint< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 2 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; typedef typename stepper_base_type::stepper_type stepper_type; modified_midpoint( unsigned short steps = 2 , const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra ) , m_steps( steps ) { } template< class System , class StateIn , class DerivIn , class StateOut > void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) { static const value_type val1 = static_cast< value_type >( 1 ); static const value_type val05 = static_cast< value_type >( 1 ) / static_cast< value_type >( 2 ); m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ); const time_type h = dt / static_cast<value_type>( m_steps ); const time_type h2 = static_cast<value_type>(2) * h; typename odeint::unwrap_reference< System >::type &sys = system; time_type th = t + h; // m_x1 = x + h*dxdt stepper_base_type::m_algebra.for_each3( m_x1.m_v , in , dxdt , typename operations_type::template scale_sum2< value_type , time_type >( val1 , h ) ); sys( m_x1.m_v , m_dxdt.m_v , th ); boost::numeric::odeint::copy( in , m_x0.m_v ); unsigned short i = 1; while( i != m_steps ) { // general step //tmp = m_x1; m_x1 = m_x0 + h2*m_dxdt; m_x0 = tmp stepper_base_type::m_algebra.for_each3( m_x1.m_v , m_x0.m_v , m_dxdt.m_v , typename operations_type::template scale_sum_swap2< value_type , time_type >( val1 , h2 ) ); th += h; sys( m_x1.m_v , m_dxdt.m_v , th); i++; } // last step // x = 0.5*( m_x0 + m_x1 + h*m_dxdt ) stepper_base_type::m_algebra.for_each4( out , m_x0.m_v , m_x1.m_v , m_dxdt.m_v , typename operations_type::template scale_sum3< value_type , value_type , time_type >( val05 , val05 , val05*h ) ); } void set_steps( unsigned short steps ) { m_steps = steps; } unsigned short steps( void ) const { return m_steps; } template< class StateIn > void adjust_size( const StateIn &x ) { resize_impl( x ); stepper_base_type::adjust_size( x ); } private: template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized( false ); resized |= adjust_size_by_resizeability( m_x0 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() ); return resized; } unsigned short m_steps; resizer_type m_resizer; wrapped_state_type m_x0; wrapped_state_type m_x1; wrapped_deriv_type m_dxdt; }; /* Modified midpoint which stores derivatives and state at dt/2 in some external storage for later usage in dense output calculation * This Stepper is for use in Bulirsch Stoer only. It DOES NOT meet any stepper concept. */ template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > class modified_midpoint_dense_out { public : typedef State state_type; typedef Value value_type; typedef Deriv deriv_type; typedef Time time_type; typedef Algebra algebra_type; typedef Operations operations_type; typedef Resizer resizer_type; typedef state_wrapper< state_type > wrapped_state_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef modified_midpoint_dense_out< State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_type; typedef std::vector< wrapped_deriv_type > deriv_table_type; modified_midpoint_dense_out( unsigned short steps = 2 , const algebra_type &algebra = algebra_type() ) : m_algebra( algebra ) , m_steps( steps ) { } /* * performs a modified midpoint step with m_steps intermediate points * stores approximation for x(t+dt/2) in x_mp and all evaluated function results in derivs * */ 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 , state_type &x_mp , deriv_table_type &derivs ) { static const value_type val1 = static_cast< value_type >( 1 ); static const value_type val05 = static_cast< value_type >( 1 ) / static_cast< value_type >( 2 ); m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize< StateIn > , detail::ref( *this ) , detail::_1 ) ); const time_type h = dt / static_cast<value_type>( m_steps ); const time_type h2 = static_cast<value_type>( 2 ) * h; typename odeint::unwrap_reference< System >::type &sys = system; time_type th = t + h; // m_x1 = x + h*dxdt m_algebra.for_each3( m_x1.m_v , in , dxdt , typename operations_type::template scale_sum2< value_type , time_type >( val1 , h ) ); if( m_steps == 2 ) // result of first step already gives approximation at the center of the interval boost::numeric::odeint::copy( m_x1.m_v , x_mp ); sys( m_x1.m_v , derivs[0].m_v , th ); boost::numeric::odeint::copy( in , m_x0.m_v ); unsigned short i = 1; while( i != m_steps ) { // general step //tmp = m_x1; m_x1 = m_x0 + h2*m_dxdt; m_x0 = tmp m_algebra.for_each3( m_x1.m_v , m_x0.m_v , derivs[i-1].m_v , typename operations_type::template scale_sum_swap2< value_type , time_type >( val1 , h2 ) ); if( i == m_steps/2-1 ) // save approximation at the center of the interval boost::numeric::odeint::copy( m_x1.m_v , x_mp ); th += h; sys( m_x1.m_v , derivs[i].m_v , th); i++; } // last step // x = 0.5*( m_x0 + m_x1 + h*m_dxdt ) m_algebra.for_each4( out , m_x0.m_v , m_x1.m_v , derivs[m_steps-1].m_v , typename operations_type::template scale_sum3< value_type , value_type , time_type >( val05 , val05 , val05*h ) ); } void set_steps( unsigned short steps ) { m_steps = steps; } unsigned short steps( void ) const { return m_steps; } template< class StateIn > bool resize( const StateIn &x ) { bool resized( false ); resized |= adjust_size_by_resizeability( m_x0 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() ); return resized; } template< class StateIn > void adjust_size( const StateIn &x ) { resize( x ); } private: algebra_type m_algebra; unsigned short m_steps; resizer_type m_resizer; wrapped_state_type m_x0; wrapped_state_type m_x1; }; /********** DOXYGEN ***********/ /** * \class modified_midpoint * * Implementation of the modified midpoint method with a configurable * number of intermediate steps. This class is used by the Bulirsch-Stoer * algorithm and is not meant for direct usage. */ /** * \class modified_midpoint_dense_out * * Implementation of the modified midpoint method with a configurable * number of intermediate steps. This class is used by the dense output * Bulirsch-Stoer algorithm and is not meant for direct usage. * \note This stepper is for internal use only and does not meet * any stepper concept. */ } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_MODIFIED_MIDPOINT_HPP_INCLUDED PK 䄟[�ª�(r (r 1 stepper/base/explicit_error_stepper_fsal_base.hppnu �[��� /* [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 , detail::bind( &internal_stepper_base_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ) || 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 , detail::bind( &internal_stepper_base_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ) || 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 , detail::bind( &internal_stepper_base_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ) || 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 , detail::bind( &internal_stepper_base_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ) || 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 PK 䄟[�.G�� � % stepper/base/algebra_stepper_base.hppnu �[��� /* [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 PK 䄟[�Hp�)@ )@ & stepper/base/explicit_stepper_base.hppnu �[��� /* [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 , detail::bind( &internal_stepper_base_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ); 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 , detail::bind( &internal_stepper_base_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ); 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 PK 䄟[����BM BM , stepper/base/symplectic_rkn_stepper_base.hppnu �[��� /* [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 <boost/array.hpp> #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 boost::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( detail::ref( q ) , detail::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( detail::ref( q ) , detail::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 , boost::mpl::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 , detail::bind( &internal_stepper_base_type::template resize_dqdt< coor_in_type > , detail::ref( *this ) , detail::_1 ) ); m_dpdt_resizer.adjust_size( momentum_in , detail::bind( &internal_stepper_base_type::template resize_dpdt< momentum_in_type > , detail::ref( *this ) , detail::_1 ) ); // 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 , boost::mpl::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_dqdt_resizer.adjust_size( coor_in , detail::bind( &internal_stepper_base_type::template resize_dqdt< coor_in_type > , detail::ref( *this ) , detail::_1 ) ); m_dpdt_resizer.adjust_size( momentum_in , detail::bind( &internal_stepper_base_type::template resize_dpdt< momentum_in_type > , detail::ref( *this ) , detail::_1 ) ); // 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 PK 䄟[���(Lc Lc , stepper/base/explicit_error_stepper_base.hppnu �[��� /* [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 , detail::bind( &internal_stepper_base_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ); 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 , detail::bind( &internal_stepper_base_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ); 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 , detail::bind( &internal_stepper_base_type::template resize_impl<StateInOut> , detail::ref( *this ) , detail::_1 ) ); 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 , detail::bind( &internal_stepper_base_type::template resize_impl<StateInOut> , detail::ref( *this ) , detail::_1 ) ); 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 PK 䄟[^e +! +! stepper/explicit_generic_rk.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/explicit_generic_rk.hpp [begin_description] Implementation of the generic Runge-Kutta steppers. This is the base class for many Runge-Kutta steppers. [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_EXPLICIT_GENERIC_RK_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_GENERIC_RK_HPP_INCLUDED #include <boost/array.hpp> #include <boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp> #include <boost/numeric/odeint/util/state_wrapper.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resizer.hpp> namespace boost { namespace numeric { namespace odeint { //forward declarations #ifndef DOXYGEN_SKIP template< size_t StageCount, size_t Order, class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > class explicit_generic_rk; struct stage_vector; template< class T , class Constant > struct array_wrapper { typedef const typename boost::array< T , Constant::value > type; }; template< class T , size_t i > struct stage { T c; boost::array< T , i > a; }; template< class T , class Constant > struct stage_wrapper { typedef stage< T , Constant::value > type; }; #endif template< size_t StageCount, size_t Order, class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resizer > #ifndef DOXYGEN_SKIP class explicit_generic_rk : public explicit_stepper_base< explicit_generic_rk< StageCount , Order , State , Value , Deriv , Time , Algebra , Operations , Resizer > , Order , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else class explicit_generic_rk : public explicit_stepper_base #endif { public: #ifndef DOXYGEN_SKIP typedef explicit_stepper_base< explicit_generic_rk< StageCount , Order , State , Value , Deriv ,Time , Algebra , Operations , Resizer > , Order , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; #else typedef explicit_stepper_base< ... > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; #ifndef DOXYGEN_SKIP typedef explicit_generic_rk< StageCount , Order , State , Value , Deriv ,Time , Algebra , Operations , Resizer > stepper_type; #endif typedef detail::generic_rk_algorithm< StageCount , Value , Algebra , Operations > rk_algorithm_type; typedef typename rk_algorithm_type::coef_a_type coef_a_type; typedef typename rk_algorithm_type::coef_b_type coef_b_type; typedef typename rk_algorithm_type::coef_c_type coef_c_type; #ifndef DOXYGEN_SKIP static const size_t stage_count = StageCount; #endif public: explicit_generic_rk( const coef_a_type &a , const coef_b_type &b , const coef_c_type &c , const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra ) , m_rk_algorithm( a , b , c ) { } template< class System , class StateIn , class DerivIn , class StateOut > void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) { m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ); // actual calculation done in generic_rk.hpp m_rk_algorithm.do_step( stepper_base_type::m_algebra , system , in , dxdt , t , out , dt , m_x_tmp.m_v , m_F ); } template< class StateIn > void adjust_size( const StateIn &x ) { resize_impl( x ); stepper_base_type::adjust_size( x ); } private: template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized( false ); resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() ); for( size_t i = 0 ; i < StageCount-1 ; ++i ) { resized |= adjust_size_by_resizeability( m_F[i] , x , typename is_resizeable<deriv_type>::type() ); } return resized; } rk_algorithm_type m_rk_algorithm; resizer_type m_resizer; wrapped_state_type m_x_tmp; wrapped_deriv_type m_F[StageCount-1]; }; /*********** DOXYGEN *************/ /** * \class explicit_generic_rk * \brief A generic implementation of explicit Runge-Kutta algorithms. This class is as a base class * for all explicit Runge-Kutta steppers. * * This class implements the explicit Runge-Kutta algorithms without error estimation in a generic way. * The Butcher tableau is passed to the stepper which constructs the stepper scheme with the help of a * template-metaprogramming algorithm. ToDo : Add example! * * This class derives explicit_stepper_base which provides the stepper interface. * * \tparam StageCount The number of stages of the Runge-Kutta algorithm. * \tparam Order The order of the stepper. * \tparam State The type representing the state of the ODE. * \tparam Value The floating point type which is used in the computations. * \tparam Time The type representing the independent variable - the time - of the ODE. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn explicit_generic_rk::explicit_generic_rk( const coef_a_type &a , const coef_b_type &b , const coef_c_type &c , const algebra_type &algebra ) * \brief Constructs the explicit_generic_rk class. See examples section for details on the coefficients. * \param a Triangular matrix of parameters b in the Butcher tableau. * \param b Last row of the butcher tableau. * \param c Parameters to calculate the time points in the Butcher tableau. * \param algebra A copy of algebra is made and stored inside explicit_stepper_base. */ /** * \fn explicit_generic_rk::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. * The result is updated out of place, hence the input is in `in` and the output in `out`. * Access to this step functionality is provided by explicit_stepper_base and * `do_step_impl` should not be called directly. * * \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_generic_rk::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. */ } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_GENERIC_RK_HPP_INCLUDED PK 䄟[��D D " stepper/controlled_step_result.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/controlled_step_result.hpp [begin_description] Defines the result type for all controlled stepper. [end_description] Copyright 2011-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_CONTROLLED_STEP_RESULT_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_STEP_RESULT_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { /** * \enum controlled_step_result * * \brief Enum representing the return values of the controlled steppers. */ typedef enum { success , /**< The trial step was successful, hence the state and the time have been advanced. */ fail /**< The step was not successful and might possibly be repeated with a small step size. */ } controlled_step_result; } // namespace odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_STEP_RESULT_HPP_INCLUDED PK 䄟[��pC� C� $ stepper/bulirsch_stoer_dense_out.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp [begin_description] Implementaiton of the Burlish-Stoer method with dense output [end_description] Copyright 2011-2015 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_BULIRSCH_STOER_DENSE_OUT_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_DENSE_OUT_HPP_INCLUDED #include <iostream> #include <algorithm> #include <boost/config.hpp> // for min/max guidelines #include <boost/numeric/odeint/util/bind.hpp> #include <boost/math/special_functions/binomial.hpp> #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/modified_midpoint.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.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/unit_helper.hpp> #include <boost/numeric/odeint/integrate/max_step_checker.hpp> #include <boost/type_traits.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > class bulirsch_stoer_dense_out { public: typedef State state_type; typedef Value value_type; typedef Deriv deriv_type; typedef Time time_type; typedef Algebra algebra_type; typedef Operations operations_type; typedef Resizer resizer_type; typedef dense_output_stepper_tag stepper_category; #ifndef DOXYGEN_SKIP typedef state_wrapper< state_type > wrapped_state_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef bulirsch_stoer_dense_out< State , Value , Deriv , Time , Algebra , Operations , Resizer > controlled_error_bs_type; typedef typename inverse_time< time_type >::type inv_time_type; typedef std::vector< value_type > value_vector; typedef std::vector< time_type > time_vector; typedef std::vector< inv_time_type > inv_time_vector; //should be 1/time_type for boost.units typedef std::vector< value_vector > value_matrix; typedef std::vector< size_t > int_vector; typedef std::vector< wrapped_state_type > state_vector_type; typedef std::vector< wrapped_deriv_type > deriv_vector_type; typedef std::vector< deriv_vector_type > deriv_table_type; #endif //DOXYGEN_SKIP const static size_t m_k_max = 8; bulirsch_stoer_dense_out( value_type eps_abs = 1E-6 , value_type eps_rel = 1E-6 , value_type factor_x = 1.0 , value_type factor_dxdt = 1.0 , time_type max_dt = static_cast<time_type>(0) , bool control_interpolation = false ) : m_error_checker( eps_abs , eps_rel , factor_x, factor_dxdt ) , m_max_dt(max_dt) , m_control_interpolation( control_interpolation) , m_last_step_rejected( false ) , m_first( true ) , m_current_state_x1( true ) , m_error( m_k_max ) , m_interval_sequence( m_k_max+1 ) , m_coeff( m_k_max+1 ) , m_cost( m_k_max+1 ) , m_facmin_table( m_k_max+1 ) , m_table( m_k_max ) , m_mp_states( m_k_max+1 ) , m_derivs( m_k_max+1 ) , m_diffs( 2*m_k_max+2 ) , STEPFAC1( 0.65 ) , STEPFAC2( 0.94 ) , STEPFAC3( 0.02 ) , STEPFAC4( 4.0 ) , KFAC1( 0.8 ) , KFAC2( 0.9 ) { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); for( unsigned short i = 0; i < m_k_max+1; i++ ) { /* only this specific sequence allows for dense output */ m_interval_sequence[i] = 2 + 4*i; // 2 6 10 14 ... m_derivs[i].resize( m_interval_sequence[i] ); if( i == 0 ) { m_cost[i] = m_interval_sequence[i]; } else { m_cost[i] = m_cost[i-1] + m_interval_sequence[i]; } m_facmin_table[i] = pow BOOST_PREVENT_MACRO_SUBSTITUTION( STEPFAC3 , static_cast< value_type >(1) / static_cast< value_type >( 2*i+1 ) ); m_coeff[i].resize(i); for( size_t k = 0 ; k < i ; ++k ) { const value_type r = static_cast< value_type >( m_interval_sequence[i] ) / static_cast< value_type >( m_interval_sequence[k] ); m_coeff[i][k] = 1.0 / ( r*r - static_cast< value_type >( 1.0 ) ); // coefficients for extrapolation } // crude estimate of optimal order m_current_k_opt = 4; /* no calculation because log10 might not exist for value_type! const value_type logfact( -log10( max BOOST_PREVENT_MACRO_SUBSTITUTION( eps_rel , static_cast< value_type >( 1.0E-12 ) ) ) * 0.6 + 0.5 ); m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 1 , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>( m_k_max-1 ) , static_cast<int>( logfact ) )); */ } int num = 1; for( int i = 2*(m_k_max)+1 ; i >=0 ; i-- ) { m_diffs[i].resize( num ); num += (i+1)%2; } } template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut > controlled_step_result try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , DerivOut &dxdt_new , time_type &dt ) { if( m_max_dt != static_cast<time_type>(0) && detail::less_with_sign(m_max_dt, dt, dt) ) { // given step size is bigger then max_dt // set limit and return fail dt = m_max_dt; return fail; } BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); using std::pow; static const value_type val1( 1.0 ); bool reject( true ); time_vector h_opt( m_k_max+1 ); inv_time_vector work( m_k_max+1 ); m_k_final = 0; time_type new_h = dt; //std::cout << "t=" << t <<", dt=" << dt << ", k_opt=" << m_current_k_opt << ", first: " << m_first << std::endl; for( size_t k = 0 ; k <= m_current_k_opt+1 ; k++ ) { m_midpoint.set_steps( m_interval_sequence[k] ); if( k == 0 ) { m_midpoint.do_step( system , in , dxdt , t , out , dt , m_mp_states[k].m_v , m_derivs[k]); } else { m_midpoint.do_step( system , in , dxdt , t , m_table[k-1].m_v , dt , m_mp_states[k].m_v , m_derivs[k] ); extrapolate( k , m_table , m_coeff , out ); // get error estimate m_algebra.for_each3( m_err.m_v , out , m_table[0].m_v , typename operations_type::template scale_sum2< value_type , value_type >( val1 , -val1 ) ); const value_type error = m_error_checker.error( m_algebra , in , dxdt , m_err.m_v , dt ); h_opt[k] = calc_h_opt( dt , error , k ); work[k] = static_cast<value_type>( m_cost[k] ) / h_opt[k]; m_k_final = k; if( (k == m_current_k_opt-1) || m_first ) { // convergence before k_opt ? if( error < 1.0 ) { //convergence reject = false; if( (work[k] < KFAC2*work[k-1]) || (m_current_k_opt <= 2) ) { // leave order as is (except we were in first round) m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(k)+1 ) ); new_h = h_opt[k] * static_cast<value_type>( m_cost[k+1] ) / static_cast<value_type>( m_cost[k] ); } else { m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(k) ) ); new_h = h_opt[k]; } break; } else if( should_reject( error , k ) && !m_first ) { reject = true; new_h = h_opt[k]; break; } } if( k == m_current_k_opt ) { // convergence at k_opt ? if( error < 1.0 ) { //convergence reject = false; if( (work[k-1] < KFAC2*work[k]) ) { m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(m_current_k_opt)-1 ); new_h = h_opt[m_current_k_opt]; } else if( (work[k] < KFAC2*work[k-1]) && !m_last_step_rejected ) { m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , static_cast<int>(m_current_k_opt)+1 ); new_h = h_opt[k]*static_cast<value_type>( m_cost[m_current_k_opt] ) / static_cast<value_type>( m_cost[k] ); } else new_h = h_opt[m_current_k_opt]; break; } else if( should_reject( error , k ) ) { reject = true; new_h = h_opt[m_current_k_opt]; break; } } if( k == m_current_k_opt+1 ) { // convergence at k_opt+1 ? if( error < 1.0 ) { //convergence reject = false; if( work[k-2] < KFAC2*work[k-1] ) m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(m_current_k_opt)-1 ); if( (work[k] < KFAC2*work[m_current_k_opt]) && !m_last_step_rejected ) m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , static_cast<int>(k) ); new_h = h_opt[m_current_k_opt]; } else { reject = true; new_h = h_opt[m_current_k_opt]; } break; } } } if( !reject ) { //calculate dxdt for next step and dense output typename odeint::unwrap_reference< System >::type &sys = system; sys( out , dxdt_new , t+dt ); //prepare dense output value_type error = prepare_dense_output( m_k_final , in , dxdt , out , dxdt_new , dt ); if( error > static_cast<value_type>(10) ) // we are not as accurate for interpolation as for the steps { reject = true; new_h = dt * pow BOOST_PREVENT_MACRO_SUBSTITUTION( error , static_cast<value_type>(-1)/(2*m_k_final+2) ); } else { t += dt; } } //set next stepsize if( !m_last_step_rejected || (new_h < dt) ) { // limit step size if( m_max_dt != static_cast<time_type>(0) ) { new_h = detail::min_abs(m_max_dt, new_h); } dt = new_h; } m_last_step_rejected = reject; if( reject ) return fail; else return success; } template< class StateType > void initialize( const StateType &x0 , const time_type &t0 , const time_type &dt0 ) { m_resizer.adjust_size( x0 , detail::bind( &controlled_error_bs_type::template resize_impl< StateType > , detail::ref( *this ) , detail::_1 ) ); boost::numeric::odeint::copy( x0 , get_current_state() ); m_t = t0; m_dt = dt0; reset(); } /* ======================================================= * the actual step method that should be called from outside (maybe make try_step private?) */ template< class System > std::pair< time_type , time_type > do_step( System system ) { if( m_first ) { typename odeint::unwrap_reference< System >::type &sys = system; sys( get_current_state() , get_current_deriv() , m_t ); } failed_step_checker fail_checker; // to throw a runtime_error if step size adjustment fails controlled_step_result res = fail; m_t_last = m_t; while( res == fail ) { res = try_step( system , get_current_state() , get_current_deriv() , m_t , get_old_state() , get_old_deriv() , m_dt ); m_first = false; fail_checker(); // check for overflow of failed steps } toggle_current_state(); return std::make_pair( m_t_last , m_t ); } /* performs the interpolation from a calculated step */ template< class StateOut > void calc_state( time_type t , StateOut &x ) const { do_interpolation( t , x ); } const state_type& current_state( void ) const { return get_current_state(); } time_type current_time( void ) const { return m_t; } const state_type& previous_state( void ) const { return get_old_state(); } time_type previous_time( void ) const { return m_t_last; } time_type current_time_step( void ) const { return m_dt; } /** \brief Resets the internal state of the stepper. */ void reset() { m_first = true; m_last_step_rejected = false; } template< class StateIn > void adjust_size( const StateIn &x ) { resize_impl( x ); m_midpoint.adjust_size( x ); } protected: time_type m_max_dt; private: template< class StateInOut , class StateVector > void extrapolate( size_t k , StateVector &table , const value_matrix &coeff , StateInOut &xest , size_t order_start_index = 0 ) //polynomial extrapolation, see http://www.nr.com/webnotes/nr3web21.pdf { static const value_type val1( 1.0 ); for( int j=k-1 ; j>0 ; --j ) { m_algebra.for_each3( table[j-1].m_v , table[j].m_v , table[j-1].m_v , typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k + order_start_index][j + order_start_index] , -coeff[k + order_start_index][j + order_start_index] ) ); } m_algebra.for_each3( xest , table[0].m_v , xest , typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k + order_start_index][0 + order_start_index] , -coeff[k + order_start_index][0 + order_start_index]) ); } template< class StateVector > void extrapolate_dense_out( size_t k , StateVector &table , const value_matrix &coeff , size_t order_start_index = 0 ) //polynomial extrapolation, see http://www.nr.com/webnotes/nr3web21.pdf { // result is written into table[0] static const value_type val1( 1.0 ); for( int j=k ; j>1 ; --j ) { m_algebra.for_each3( table[j-1].m_v , table[j].m_v , table[j-1].m_v , typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k + order_start_index][j + order_start_index - 1] , -coeff[k + order_start_index][j + order_start_index - 1] ) ); } m_algebra.for_each3( table[0].m_v , table[1].m_v , table[0].m_v , typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k + order_start_index][order_start_index] , -coeff[k + order_start_index][order_start_index]) ); } time_type calc_h_opt( time_type h , value_type error , size_t k ) const { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); using std::pow; value_type expo = static_cast<value_type>(1)/(m_interval_sequence[k-1]); value_type facmin = m_facmin_table[k]; value_type fac; if (error == 0.0) fac = static_cast<value_type>(1)/facmin; else { fac = STEPFAC2 / pow BOOST_PREVENT_MACRO_SUBSTITUTION( error / STEPFAC1 , expo ); fac = max BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( facmin/STEPFAC4 ) , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>(static_cast<value_type>(1)/facmin) , fac ) ); } return h*fac; } bool in_convergence_window( size_t k ) const { if( (k == m_current_k_opt-1) && !m_last_step_rejected ) return true; // decrease order only if last step was not rejected return ( (k == m_current_k_opt) || (k == m_current_k_opt+1) ); } bool should_reject( value_type error , size_t k ) const { if( k == m_current_k_opt-1 ) { const value_type d = m_interval_sequence[m_current_k_opt] * m_interval_sequence[m_current_k_opt+1] / (m_interval_sequence[0]*m_interval_sequence[0]); //step will fail, criterion 17.3.17 in NR return ( error > d*d ); } else if( k == m_current_k_opt ) { const value_type d = m_interval_sequence[m_current_k_opt+1] / m_interval_sequence[0]; return ( error > d*d ); } else return error > 1.0; } template< class StateIn1 , class DerivIn1 , class StateIn2 , class DerivIn2 > value_type prepare_dense_output( int k , const StateIn1 &x_start , const DerivIn1 &dxdt_start , const StateIn2 & /* x_end */ , const DerivIn2 & /*dxdt_end */ , time_type dt ) /* k is the order to which the result was approximated */ { /* compute the coefficients of the interpolation polynomial * we parametrize the interval t .. t+dt by theta = -1 .. 1 * we use 2k+3 values at the interval center theta=0 to obtain the interpolation coefficients * the values are x(t+dt/2) and the derivatives dx/dt , ... d^(2k+2) x / dt^(2k+2) at the midpoints * the derivatives are approximated via finite differences * all values are obtained from interpolation of the results from the increasing orders of the midpoint calls */ // calculate finite difference approximations to derivatives at the midpoint for( int j = 0 ; j<=k ; j++ ) { /* not working with boost units... */ const value_type d = m_interval_sequence[j] / ( static_cast<value_type>(2) * dt ); value_type f = 1.0; //factor 1/2 here because our interpolation interval has length 2 !!! for( int kappa = 0 ; kappa <= 2*j+1 ; ++kappa ) { calculate_finite_difference( j , kappa , f , dxdt_start ); f *= d; } if( j > 0 ) extrapolate_dense_out( j , m_mp_states , m_coeff ); } time_type d = dt/2; // extrapolate finite differences for( int kappa = 0 ; kappa<=2*k+1 ; kappa++ ) { for( int j=1 ; j<=(k-kappa/2) ; ++j ) extrapolate_dense_out( j , m_diffs[kappa] , m_coeff , kappa/2 ); // extrapolation results are now stored in m_diffs[kappa][0] // divide kappa-th derivative by kappa because we need these terms for dense output interpolation m_algebra.for_each1( m_diffs[kappa][0].m_v , typename operations_type::template scale< time_type >( static_cast<time_type>(d) ) ); d *= dt/(2*(kappa+2)); } // dense output coefficients a_0 is stored in m_mp_states[0], a_i for i = 1...2k are stored in m_diffs[i-1][0] // the error is just the highest order coefficient of the interpolation polynomial // this is because we use only the midpoint theta=0 as support for the interpolation (remember that theta = -1 .. 1) value_type error = 0.0; if( m_control_interpolation ) { boost::numeric::odeint::copy( m_diffs[2*k+1][0].m_v , m_err.m_v ); error = m_error_checker.error( m_algebra , x_start , dxdt_start , m_err.m_v , dt ); } return error; } template< class DerivIn > void calculate_finite_difference( size_t j , size_t kappa , value_type fac , const DerivIn &dxdt ) { const int m = m_interval_sequence[j]/2-1; if( kappa == 0) // no calculation required for 0th derivative of f { m_algebra.for_each2( m_diffs[0][j].m_v , m_derivs[j][m].m_v , typename operations_type::template scale_sum1< value_type >( fac ) ); } else { // calculate the index of m_diffs for this kappa-j-combination const int j_diffs = j - kappa/2; m_algebra.for_each2( m_diffs[kappa][j_diffs].m_v , m_derivs[j][m+kappa].m_v , typename operations_type::template scale_sum1< value_type >( fac ) ); value_type sign = -1.0; int c = 1; //computes the j-th order finite difference for the kappa-th derivative of f at t+dt/2 using function evaluations stored in m_derivs for( int i = m+static_cast<int>(kappa)-2 ; i >= m-static_cast<int>(kappa) ; i -= 2 ) { if( i >= 0 ) { m_algebra.for_each3( m_diffs[kappa][j_diffs].m_v , m_diffs[kappa][j_diffs].m_v , m_derivs[j][i].m_v , typename operations_type::template scale_sum2< value_type , value_type >( 1.0 , sign * fac * boost::math::binomial_coefficient< value_type >( kappa , c ) ) ); } else { m_algebra.for_each3( m_diffs[kappa][j_diffs].m_v , m_diffs[kappa][j_diffs].m_v , dxdt , typename operations_type::template scale_sum2< value_type , value_type >( 1.0 , sign * fac ) ); } sign *= -1; ++c; } } } template< class StateOut > void do_interpolation( time_type t , StateOut &out ) const { // interpolation polynomial is defined for theta = -1 ... 1 // m_k_final is the number of order-iterations done for the last step - it governs the order of the interpolation polynomial const value_type theta = 2 * get_unit_value( (t - m_t_last) / (m_t - m_t_last) ) - 1; // we use only values at interval center, that is theta=0, for interpolation // our interpolation polynomial is thus of order 2k+2, hence we have 2k+3 terms boost::numeric::odeint::copy( m_mp_states[0].m_v , out ); // add remaining terms: x += a_1 theta + a2 theta^2 + ... + a_{2k} theta^{2k} value_type theta_pow( theta ); for( size_t i=0 ; i<=2*m_k_final+1 ; ++i ) { m_algebra.for_each3( out , out , m_diffs[i][0].m_v , typename operations_type::template scale_sum2< value_type >( static_cast<value_type>(1) , theta_pow ) ); theta_pow *= theta; } } /* Resizer methods */ template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized( false ); resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_dxdt1 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_dxdt2 , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_err , x , typename is_resizeable<state_type>::type() ); for( size_t i = 0 ; i < m_k_max ; ++i ) resized |= adjust_size_by_resizeability( m_table[i] , x , typename is_resizeable<state_type>::type() ); for( size_t i = 0 ; i < m_k_max+1 ; ++i ) resized |= adjust_size_by_resizeability( m_mp_states[i] , x , typename is_resizeable<state_type>::type() ); for( size_t i = 0 ; i < m_k_max+1 ; ++i ) for( size_t j = 0 ; j < m_derivs[i].size() ; ++j ) resized |= adjust_size_by_resizeability( m_derivs[i][j] , x , typename is_resizeable<deriv_type>::type() ); for( size_t i = 0 ; i < 2*m_k_max+2 ; ++i ) for( size_t j = 0 ; j < m_diffs[i].size() ; ++j ) resized |= adjust_size_by_resizeability( m_diffs[i][j] , x , typename is_resizeable<deriv_type>::type() ); return resized; } state_type& get_current_state( void ) { return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ; } const state_type& get_current_state( void ) const { return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ; } state_type& get_old_state( void ) { return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ; } const state_type& get_old_state( void ) const { return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ; } deriv_type& get_current_deriv( void ) { return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ; } const deriv_type& get_current_deriv( void ) const { return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ; } deriv_type& get_old_deriv( void ) { return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ; } const deriv_type& get_old_deriv( void ) const { return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ; } void toggle_current_state( void ) { m_current_state_x1 = ! m_current_state_x1; } default_error_checker< value_type, algebra_type , operations_type > m_error_checker; modified_midpoint_dense_out< state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type > m_midpoint; bool m_control_interpolation; bool m_last_step_rejected; bool m_first; time_type m_t; time_type m_dt; time_type m_dt_last; time_type m_t_last; size_t m_current_k_opt; size_t m_k_final; algebra_type m_algebra; resizer_type m_resizer; wrapped_state_type m_x1 , m_x2; wrapped_deriv_type m_dxdt1 , m_dxdt2; wrapped_state_type m_err; bool m_current_state_x1; value_vector m_error; // errors of repeated midpoint steps and extrapolations int_vector m_interval_sequence; // stores the successive interval counts value_matrix m_coeff; int_vector m_cost; // costs for interval count value_vector m_facmin_table; // for precomputed facmin to save pow calls state_vector_type m_table; // sequence of states for extrapolation //for dense output: state_vector_type m_mp_states; // sequence of approximations of x at distance center deriv_table_type m_derivs; // table of function values deriv_table_type m_diffs; // table of function values //wrapped_state_type m_a1 , m_a2 , m_a3 , m_a4; value_type STEPFAC1 , STEPFAC2 , STEPFAC3 , STEPFAC4 , KFAC1 , KFAC2; }; /********** DOXYGEN **********/ /** * \class bulirsch_stoer_dense_out * \brief The Bulirsch-Stoer algorithm. * * The Bulirsch-Stoer is a controlled stepper that adjusts both step size * and order of the method. The algorithm uses the modified midpoint and * a polynomial extrapolation compute the solution. This class also provides * dense output facility. * * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn bulirsch_stoer_dense_out::bulirsch_stoer_dense_out( value_type eps_abs , value_type eps_rel , value_type factor_x , value_type factor_dxdt , bool control_interpolation ) * \brief Constructs the bulirsch_stoer class, including initialization of * the error bounds. * * \param eps_abs Absolute tolerance level. * \param eps_rel Relative tolerance level. * \param factor_x Factor for the weight of the state. * \param factor_dxdt Factor for the weight of the derivative. * \param control_interpolation Set true to additionally control the error of * the interpolation. */ /** * \fn bulirsch_stoer_dense_out::try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , DerivOut &dxdt_new , time_type &dt ) * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. Also, the internal order of the stepper is adjusted if required. * * \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. * \param dxdt The derivative of state. * \param t The value of the time. Updated if the step is successful. * \param out Used to store the result of the step. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ /** * \fn bulirsch_stoer_dense_out::initialize( const StateType &x0 , const time_type &t0 , const time_type &dt0 ) * \brief Initializes the dense output stepper. * * \param x0 The initial state. * \param t0 The initial time. * \param dt0 The initial time step. */ /** * \fn bulirsch_stoer_dense_out::do_step( System system ) * \brief Does one time step. This is the main method that should be used to * integrate an ODE with this stepper. * \note initialize has to be called before using this method to set the * initial conditions x,t and the stepsize. * \param system The system function to solve, hence the r.h.s. of the * ordinary differential equation. It must fulfill the Simple System concept. * \return Pair with start and end time of the integration step. */ /** * \fn bulirsch_stoer_dense_out::calc_state( time_type t , StateOut &x ) const * \brief Calculates the solution at an intermediate point within the last step * \param t The time at which the solution should be calculated, has to be * in the current time interval. * \param x The output variable where the result is written into. */ /** * \fn bulirsch_stoer_dense_out::current_state( void ) const * \brief Returns the current state of the solution. * \return The current state of the solution x(t). */ /** * \fn bulirsch_stoer_dense_out::current_time( void ) const * \brief Returns the current time of the solution. * \return The current time of the solution t. */ /** * \fn bulirsch_stoer_dense_out::previous_state( void ) const * \brief Returns the last state of the solution. * \return The last state of the solution x(t-dt). */ /** * \fn bulirsch_stoer_dense_out::previous_time( void ) const * \brief Returns the last time of the solution. * \return The last time of the solution t-dt. */ /** * \fn bulirsch_stoer_dense_out::current_time_step( void ) const * \brief Returns the current step size. * \return The current step size. */ /** * \fn bulirsch_stoer_dense_out::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. */ } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_HPP_INCLUDED PK 䄟[]b�Mf Mf stepper/bulirsch_stoer.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/bulirsch_stoer.hpp [begin_description] Implementation of the Burlish-Stoer method. As described in Ernst Hairer, Syvert Paul Norsett, Gerhard Wanner Solving Ordinary Differential Equations I. Nonstiff Problems. Springer Series in Comput. Mathematics, Vol. 8, Springer-Verlag 1987, Second revised edition 1993. [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_BULIRSCH_STOER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_HPP_INCLUDED #include <iostream> #include <algorithm> #include <boost/config.hpp> // for min/max guidelines #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/stepper/modified_midpoint.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.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/unit_helper.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > class bulirsch_stoer { public: typedef State state_type; typedef Value value_type; typedef Deriv deriv_type; typedef Time time_type; typedef Algebra algebra_type; typedef Operations operations_type; typedef Resizer resizer_type; #ifndef DOXYGEN_SKIP typedef state_wrapper< state_type > wrapped_state_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef controlled_stepper_tag stepper_category; typedef bulirsch_stoer< State , Value , Deriv , Time , Algebra , Operations , Resizer > controlled_error_bs_type; typedef typename inverse_time< time_type >::type inv_time_type; typedef std::vector< value_type > value_vector; typedef std::vector< time_type > time_vector; typedef std::vector< inv_time_type > inv_time_vector; //should be 1/time_type for boost.units typedef std::vector< value_vector > value_matrix; typedef std::vector< size_t > int_vector; typedef std::vector< wrapped_state_type > state_table_type; #endif //DOXYGEN_SKIP const static size_t m_k_max = 8; bulirsch_stoer( value_type eps_abs = 1E-6 , value_type eps_rel = 1E-6 , value_type factor_x = 1.0 , value_type factor_dxdt = 1.0 , time_type max_dt = static_cast<time_type>(0)) : m_error_checker( eps_abs , eps_rel , factor_x, factor_dxdt ) , m_midpoint() , m_last_step_rejected( false ) , m_first( true ) , m_max_dt(max_dt) , m_interval_sequence( m_k_max+1 ) , m_coeff( m_k_max+1 ) , m_cost( m_k_max+1 ) , m_facmin_table( m_k_max+1 ) , m_table( m_k_max ) , STEPFAC1( 0.65 ) , STEPFAC2( 0.94 ) , STEPFAC3( 0.02 ) , STEPFAC4( 4.0 ) , KFAC1( 0.8 ) , KFAC2( 0.9 ) { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); /* initialize sequence of stage numbers and work */ for( unsigned short i = 0; i < m_k_max+1; i++ ) { m_interval_sequence[i] = 2 * (i+1); if( i == 0 ) m_cost[i] = m_interval_sequence[i]; else m_cost[i] = m_cost[i-1] + m_interval_sequence[i]; m_coeff[i].resize(i); m_facmin_table[i] = pow BOOST_PREVENT_MACRO_SUBSTITUTION( STEPFAC3 , static_cast< value_type >(1) / static_cast< value_type >( 2*i+1 ) ); for( size_t k = 0 ; k < i ; ++k ) { const value_type r = static_cast< value_type >( m_interval_sequence[i] ) / static_cast< value_type >( m_interval_sequence[k] ); m_coeff[i][k] = 1.0 / ( r*r - static_cast< value_type >( 1.0 ) ); // coefficients for extrapolation } } reset(); } /* * Version 1 : try_step( sys , x , t , dt ) * * The overloads are needed to solve the forwarding problem */ template< class System , class StateInOut > controlled_step_result try_step( System system , StateInOut &x , time_type &t , time_type &dt ) { return try_step_v1( system , x , t, dt ); } /** * \brief Second version to solve the forwarding problem, can be used with Boost.Range as StateInOut. */ template< class System , class StateInOut > controlled_step_result try_step( System system , const StateInOut &x , time_type &t , time_type &dt ) { return try_step_v1( system , x , t, dt ); } /* * Version 2 : try_step( sys , x , dxdt , t , dt ) * * this version does not solve the forwarding problem, boost.range can not be used */ template< class System , class StateInOut , class DerivIn > controlled_step_result try_step( System system , StateInOut &x , const DerivIn &dxdt , time_type &t , time_type &dt ) { m_xnew_resizer.adjust_size( x , detail::bind( &controlled_error_bs_type::template resize_m_xnew< StateInOut > , detail::ref( *this ) , detail::_1 ) ); controlled_step_result res = try_step( system , x , dxdt , t , m_xnew.m_v , dt ); if( res == success ) { boost::numeric::odeint::copy( m_xnew.m_v , x ); } return res; } /* * Version 3 : try_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 > typename boost::disable_if< boost::is_same< StateIn , time_type > , controlled_step_result >::type try_step( System system , const StateIn &in , time_type &t , StateOut &out , time_type &dt ) { typename odeint::unwrap_reference< System >::type &sys = system; m_dxdt_resizer.adjust_size( in , detail::bind( &controlled_error_bs_type::template resize_m_dxdt< StateIn > , detail::ref( *this ) , detail::_1 ) ); sys( in , m_dxdt.m_v , t ); return try_step( system , in , m_dxdt.m_v , t , out , dt ); } /* * Full version : try_step( sys , in , dxdt_in , t , out , dt ) * * contains the actual implementation */ template< class System , class StateIn , class DerivIn , class StateOut > controlled_step_result try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , time_type &dt ) { if( m_max_dt != static_cast<time_type>(0) && detail::less_with_sign(m_max_dt, dt, dt) ) { // given step size is bigger then max_dt // set limit and return fail dt = m_max_dt; return fail; } BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); static const value_type val1( 1.0 ); if( m_resizer.adjust_size( in , detail::bind( &controlled_error_bs_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ) ) { reset(); // system resized -> reset } if( dt != m_dt_last ) { reset(); // step size changed from outside -> reset } bool reject( true ); time_vector h_opt( m_k_max+1 ); inv_time_vector work( m_k_max+1 ); time_type new_h = dt; /* m_current_k_opt is the estimated current optimal stage number */ for( size_t k = 0 ; k <= m_current_k_opt+1 ; k++ ) { /* the stage counts are stored in m_interval_sequence */ m_midpoint.set_steps( m_interval_sequence[k] ); if( k == 0 ) { m_midpoint.do_step( system , in , dxdt , t , out , dt ); /* the first step, nothing more to do */ } else { m_midpoint.do_step( system , in , dxdt , t , m_table[k-1].m_v , dt ); extrapolate( k , m_table , m_coeff , out ); // get error estimate m_algebra.for_each3( m_err.m_v , out , m_table[0].m_v , typename operations_type::template scale_sum2< value_type , value_type >( val1 , -val1 ) ); const value_type error = m_error_checker.error( m_algebra , in , dxdt , m_err.m_v , dt ); h_opt[k] = calc_h_opt( dt , error , k ); work[k] = static_cast<value_type>( m_cost[k] ) / h_opt[k]; if( (k == m_current_k_opt-1) || m_first ) { // convergence before k_opt ? if( error < 1.0 ) { //convergence reject = false; if( (work[k] < KFAC2*work[k-1]) || (m_current_k_opt <= 2) ) { // leave order as is (except we were in first round) m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(k)+1 ) ); new_h = h_opt[k]; new_h *= static_cast<value_type>( m_cost[k+1] ) / static_cast<value_type>( m_cost[k] ); } else { m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(k) ) ); new_h = h_opt[k]; } break; } else if( should_reject( error , k ) && !m_first ) { reject = true; new_h = h_opt[k]; break; } } if( k == m_current_k_opt ) { // convergence at k_opt ? if( error < 1.0 ) { //convergence reject = false; if( (work[k-1] < KFAC2*work[k]) ) { m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(m_current_k_opt)-1 ); new_h = h_opt[m_current_k_opt]; } else if( (work[k] < KFAC2*work[k-1]) && !m_last_step_rejected ) { m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max-1) , static_cast<int>(m_current_k_opt)+1 ); new_h = h_opt[k]; new_h *= static_cast<value_type>(m_cost[m_current_k_opt])/static_cast<value_type>(m_cost[k]); } else new_h = h_opt[m_current_k_opt]; break; } else if( should_reject( error , k ) ) { reject = true; new_h = h_opt[m_current_k_opt]; break; } } if( k == m_current_k_opt+1 ) { // convergence at k_opt+1 ? if( error < 1.0 ) { //convergence reject = false; if( work[k-2] < KFAC2*work[k-1] ) m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(m_current_k_opt)-1 ); if( (work[k] < KFAC2*work[m_current_k_opt]) && !m_last_step_rejected ) m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , static_cast<int>(k) ); new_h = h_opt[m_current_k_opt]; } else { reject = true; new_h = h_opt[m_current_k_opt]; } break; } } } if( !reject ) { t += dt; } if( !m_last_step_rejected || boost::numeric::odeint::detail::less_with_sign(new_h, dt, dt) ) { // limit step size if( m_max_dt != static_cast<time_type>(0) ) { new_h = detail::min_abs(m_max_dt, new_h); } m_dt_last = new_h; dt = new_h; } m_last_step_rejected = reject; m_first = false; if( reject ) return fail; else return success; } /** \brief Resets the internal state of the stepper */ void reset() { m_first = true; m_last_step_rejected = false; // crude estimate of optimal order m_current_k_opt = 4; /* no calculation because log10 might not exist for value_type! const value_type logfact( -log10( max BOOST_PREVENT_MACRO_SUBSTITUTION( eps_rel , static_cast< value_type >(1.0E-12) ) ) * 0.6 + 0.5 ); m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( 1 ) , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( m_k_max-1 ) , logfact )); */ } /* Resizer methods */ template< class StateIn > void adjust_size( const StateIn &x ) { resize_m_dxdt( x ); resize_m_xnew( x ); resize_impl( x ); m_midpoint.adjust_size( x ); } private: template< class StateIn > bool resize_m_dxdt( const StateIn &x ) { return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() ); } template< class StateIn > bool resize_m_xnew( const StateIn &x ) { return adjust_size_by_resizeability( m_xnew , x , typename is_resizeable<state_type>::type() ); } template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized( false ); for( size_t i = 0 ; i < m_k_max ; ++i ) resized |= adjust_size_by_resizeability( m_table[i] , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_err , x , typename is_resizeable<state_type>::type() ); return resized; } template< class System , class StateInOut > controlled_step_result try_step_v1( System system , StateInOut &x , time_type &t , time_type &dt ) { typename odeint::unwrap_reference< System >::type &sys = system; m_dxdt_resizer.adjust_size( x , detail::bind( &controlled_error_bs_type::template resize_m_dxdt< StateInOut > , detail::ref( *this ) , detail::_1 ) ); sys( x , m_dxdt.m_v ,t ); return try_step( system , x , m_dxdt.m_v , t , dt ); } template< class StateInOut > void extrapolate( size_t k , state_table_type &table , const value_matrix &coeff , StateInOut &xest ) /* polynomial extrapolation, see http://www.nr.com/webnotes/nr3web21.pdf uses the obtained intermediate results to extrapolate to dt->0 */ { static const value_type val1 = static_cast< value_type >( 1.0 ); for( int j=k-1 ; j>0 ; --j ) { m_algebra.for_each3( table[j-1].m_v , table[j].m_v , table[j-1].m_v , typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k][j] , -coeff[k][j] ) ); } m_algebra.for_each3( xest , table[0].m_v , xest , typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k][0] , -coeff[k][0]) ); } time_type calc_h_opt( time_type h , value_type error , size_t k ) const /* calculates the optimal step size for a given error and stage number */ { BOOST_USING_STD_MIN(); BOOST_USING_STD_MAX(); using std::pow; value_type expo( 1.0/(2*k+1) ); value_type facmin = m_facmin_table[k]; value_type fac; if (error == 0.0) fac=1.0/facmin; else { fac = STEPFAC2 / pow BOOST_PREVENT_MACRO_SUBSTITUTION( error / STEPFAC1 , expo ); fac = max BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>(facmin/STEPFAC4) , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>(1.0/facmin) , fac ) ); } return h*fac; } controlled_step_result set_k_opt( size_t k , const inv_time_vector &work , const time_vector &h_opt , time_type &dt ) /* calculates the optimal stage number */ { if( k == 1 ) { m_current_k_opt = 2; return success; } if( (work[k-1] < KFAC1*work[k]) || (k == m_k_max) ) { // order decrease m_current_k_opt = k-1; dt = h_opt[ m_current_k_opt ]; return success; } else if( (work[k] < KFAC2*work[k-1]) || m_last_step_rejected || (k == m_k_max-1) ) { // same order - also do this if last step got rejected m_current_k_opt = k; dt = h_opt[ m_current_k_opt ]; return success; } else { // order increase - only if last step was not rejected m_current_k_opt = k+1; dt = h_opt[ m_current_k_opt-1 ] * m_cost[ m_current_k_opt ] / m_cost[ m_current_k_opt-1 ] ; return success; } } bool in_convergence_window( size_t k ) const { if( (k == m_current_k_opt-1) && !m_last_step_rejected ) return true; // decrease stepsize only if last step was not rejected return ( (k == m_current_k_opt) || (k == m_current_k_opt+1) ); } bool should_reject( value_type error , size_t k ) const { if( k == m_current_k_opt-1 ) { const value_type d = m_interval_sequence[m_current_k_opt] * m_interval_sequence[m_current_k_opt+1] / (m_interval_sequence[0]*m_interval_sequence[0]); //step will fail, criterion 17.3.17 in NR return ( error > d*d ); } else if( k == m_current_k_opt ) { const value_type d = m_interval_sequence[m_current_k_opt] / m_interval_sequence[0]; return ( error > d*d ); } else return error > 1.0; } default_error_checker< value_type, algebra_type , operations_type > m_error_checker; modified_midpoint< state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type > m_midpoint; bool m_last_step_rejected; bool m_first; time_type m_dt_last; time_type m_t_last; time_type m_max_dt; size_t m_current_k_opt; algebra_type m_algebra; resizer_type m_dxdt_resizer; resizer_type m_xnew_resizer; resizer_type m_resizer; wrapped_state_type m_xnew; wrapped_state_type m_err; wrapped_deriv_type m_dxdt; int_vector m_interval_sequence; // stores the successive interval counts value_matrix m_coeff; int_vector m_cost; // costs for interval count value_vector m_facmin_table; // for precomputed facmin to save pow calls state_table_type m_table; // sequence of states for extrapolation value_type STEPFAC1 , STEPFAC2 , STEPFAC3 , STEPFAC4 , KFAC1 , KFAC2; }; /******** DOXYGEN ********/ /** * \class bulirsch_stoer * \brief The Bulirsch-Stoer algorithm. * * The Bulirsch-Stoer is a controlled stepper that adjusts both step size * and order of the method. The algorithm uses the modified midpoint and * a polynomial extrapolation compute the solution. * * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn bulirsch_stoer::bulirsch_stoer( value_type eps_abs , value_type eps_rel , value_type factor_x , value_type factor_dxdt ) * \brief Constructs the bulirsch_stoer class, including initialization of * the error bounds. * * \param eps_abs Absolute tolerance level. * \param eps_rel Relative tolerance level. * \param factor_x Factor for the weight of the state. * \param factor_dxdt Factor for the weight of the derivative. */ /** * \fn bulirsch_stoer::try_step( System system , StateInOut &x , time_type &t , time_type &dt ) * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. Also, the internal order of the stepper is adjusted if required. * * \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. Overwritten if * the step is successful. * \param t The value of the time. Updated if the step is successful. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ /** * \fn bulirsch_stoer::try_step( System system , StateInOut &x , const DerivIn &dxdt , time_type &t , time_type &dt ) * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. Also, the internal order of the stepper is adjusted if required. * * \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. Overwritten if * the step is successful. * \param dxdt The derivative of state. * \param t The value of the time. Updated if the step is successful. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ /** * \fn bulirsch_stoer::try_step( System system , const StateIn &in , time_type &t , StateOut &out , time_type &dt ) * \brief Tries to perform one step. * * \note This method is disabled if state_type=time_type to avoid ambiguity. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. Also, the internal order of the stepper is adjusted if required. * * \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. * \param t The value of the time. Updated if the step is successful. * \param out Used to store the result of the step. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ /** * \fn bulirsch_stoer::try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , time_type &dt ) * \brief Tries to perform one step. * * This method tries to do one step with step size dt. If the error estimate * is to large, the step is rejected and the method returns fail and the * step size dt is reduced. If the error estimate is acceptably small, the * step is performed, success is returned and dt might be increased to make * the steps as large as possible. This method also updates t if a step is * performed. Also, the internal order of the stepper is adjusted if required. * * \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. * \param dxdt The derivative of state. * \param t The value of the time. Updated if the step is successful. * \param out Used to store the result of the step. * \param dt The step size. Updated. * \return success if the step was accepted, fail otherwise. */ /** * \fn bulirsch_stoer::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. */ } } } #endif // BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_HPP_INCLUDED PK 䄟[+G��'$ '$ stepper/runge_kutta4_classic.hppnu �[��� /* [auto_generated] boost/numeric/odeint/stepper/runge_kutta4_classic.hpp [begin_description] Implementation for the classical Runge Kutta stepper. [end_description] Copyright 2010-2013 Karsten Ahnert Copyright 2010-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_RUNGE_KUTTA4_CLASSIC_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_CLASSIC_HPP_INCLUDED #include <boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/default_operations.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> #include <boost/numeric/odeint/util/state_wrapper.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resizer.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Value = double , class Deriv = State , class Time = Value , class Algebra = typename algebra_dispatcher< State >::algebra_type , class Operations = typename operations_dispatcher< State >::operations_type , class Resizer = initially_resizer > #ifndef DOXYGEN_SKIP class runge_kutta4_classic : public explicit_stepper_base< runge_kutta4_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > #else class runge_kutta4_classic : public explicit_stepper_base #endif { public : #ifndef DOXYGEN_SKIP typedef explicit_stepper_base< runge_kutta4_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type; #else typedef explicit_stepper_base< runge_kutta4_classic< ... > , ... > stepper_base_type; #endif typedef typename stepper_base_type::state_type state_type; typedef typename stepper_base_type::value_type value_type; typedef typename stepper_base_type::deriv_type deriv_type; typedef typename stepper_base_type::time_type time_type; typedef typename stepper_base_type::algebra_type algebra_type; typedef typename stepper_base_type::operations_type operations_type; typedef typename stepper_base_type::resizer_type resizer_type; #ifndef DOXYGEN_SKIP typedef typename stepper_base_type::stepper_type stepper_type; typedef typename stepper_base_type::wrapped_state_type wrapped_state_type; typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type; #endif // DOXYGEN_SKIP runge_kutta4_classic( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra ) { } template< class System , class StateIn , class DerivIn , class StateOut > void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) { // ToDo : check if size of in,dxdt,out are equal? static const value_type val1 = static_cast< value_type >( 1 ); m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ); typename odeint::unwrap_reference< System >::type &sys = system; const time_type dh = dt / static_cast< value_type >( 2 ); const time_type th = t + dh; // dt * dxdt = k1 // m_x_tmp = x + dh*dxdt stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , dxdt , typename operations_type::template scale_sum2< value_type , time_type >( val1 , dh ) ); // dt * m_dxt = k2 sys( m_x_tmp.m_v , m_dxt.m_v , th ); // m_x_tmp = x + dh*m_dxt stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , m_dxt.m_v , typename operations_type::template scale_sum2< value_type , time_type >( val1 , dh ) ); // dt * m_dxm = k3 sys( m_x_tmp.m_v , m_dxm.m_v , th ); //m_x_tmp = x + dt*m_dxm stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , m_dxm.m_v , typename operations_type::template scale_sum2< value_type , time_type >( val1 , dt ) ); // dt * m_dxh = k4 sys( m_x_tmp.m_v , m_dxh.m_v , t + dt ); //x += dt/6 * ( m_dxdt + m_dxt + val2*m_dxm ) time_type dt6 = dt / static_cast< value_type >( 6 ); time_type dt3 = dt / static_cast< value_type >( 3 ); stepper_base_type::m_algebra.for_each6( out , in , dxdt , m_dxt.m_v , m_dxm.m_v , m_dxh.m_v , typename operations_type::template scale_sum5< value_type , time_type , time_type , time_type , time_type >( 1.0 , dt6 , dt3 , dt3 , dt6 ) ); // x += dt/6 * m_dxdt + dt/3 * m_dxt ) // stepper_base_type::m_algebra.for_each4( out , in , dxdt , m_dxt.m_v , // typename operations_type::template scale_sum3< value_type , time_type , time_type >( 1.0 , dt6 , dt3 ) ); // // x += dt/3 * m_dxm + dt/6 * m_dxh ) // stepper_base_type::m_algebra.for_each4( out , out , m_dxm.m_v , m_dxh.m_v , // typename operations_type::template scale_sum3< value_type , time_type , time_type >( 1.0 , dt3 , dt6 ) ); } template< class StateType > void adjust_size( const StateType &x ) { resize_impl( x ); stepper_base_type::adjust_size( x ); } private: template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_dxm , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_dxt , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_dxh , x , typename is_resizeable<deriv_type>::type() ); return resized; } resizer_type m_resizer; wrapped_deriv_type m_dxt; wrapped_deriv_type m_dxm; wrapped_deriv_type m_dxh; wrapped_state_type m_x_tmp; }; /********* DOXYGEN *********/ /** * \class runge_kutta4_classic * \brief The classical Runge-Kutta stepper of fourth order. * * The Runge-Kutta method of fourth order is one standard method for * solving ordinary differential equations and is widely used, see also * <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods">en.wikipedia.org/wiki/Runge-Kutta_methods</a> * The method is explicit and fulfills the Stepper concept. Step size control * or continuous output are not provided. This class implements the method directly, hence the * generic Runge-Kutta algorithm is not used. * * This class derives from explicit_stepper_base and inherits its interface via * CRTP (current recurring template pattern). For more details see * explicit_stepper_base. * * \tparam State The state type. * \tparam Value The value type. * \tparam Deriv The type representing the time derivative of the state. * \tparam Time The time representing the independent variable - the time. * \tparam Algebra The algebra type. * \tparam Operations The operations type. * \tparam Resizer The resizer policy type. */ /** * \fn runge_kutta4_classic::runge_kutta4_classic( const algebra_type &algebra ) * \brief Constructs the runge_kutta4_classic class. This constructor can be used as a default * constructor if the algebra has a default constructor. * \param algebra A copy of algebra is made and stored inside explicit_stepper_base. */ /** * \fn runge_kutta4_classic::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ) * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method. * The result is updated out of place, hence the input is in `in` and the output in `out`. * Access to this step functionality is provided by explicit_stepper_base and * `do_step_impl` should not be called directly. * * \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 runge_kutta4_classic::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. */ } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_CLASSIC_HPP_INCLUDED PK 䄟[k� � version.hppnu �[��� /* [auto_generated] boost/numeric/odeint/version.hpp [begin_description] Defines the current version of odeint. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_VERSION_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_VERSION_HPP_INCLUDED #include <string> #include <sstream> #define ODEINT_MAJOR_VERSION 2 #define ODEINT_MINOR_VERSION 2 #define ODEINT_PATCH_LEVEL 0 #define ODEINT_VERSION ( ODEINT_MAJOR_VERSION * 100000 + ODEINT_MINOR_VERSION * 100 + ODEINT_PATCH_LEVEL ) namespace boost { namespace numeric { namespace odeint { namespace version { const int major = ODEINT_MAJOR_VERSION ; const int minor = ODEINT_MINOR_VERSION ; const int patch_level = ODEINT_PATCH_LEVEL ; } inline std::string get_version_string( void ) { std::ostringstream str; str << "v" << version::major << "." << version::minor; if( version::patch_level != 0 ) str << "_" << version::patch_level; return str.str(); } } } } #endif // BOOST_NUMERIC_ODEINT_VERSION_HPP_INCLUDED PK 䄟[CzkU� � iterator/adaptive_iterator.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/adaptive_iterator.hpp [begin_description] Iterator for iterating throught the solution of an ODE with adaptive step size. The dereferenced types containes also the time. [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_ITERATOR_ADAPTIVE_ITERATOR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_ITERATOR_HPP_INCLUDED #include <boost/numeric/odeint/util/stepper_traits.hpp> #include <boost/numeric/odeint/util/unit_helper.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp> namespace boost { namespace numeric { namespace odeint { /* use the adaptive_iterator_impl with the right tags */ template< class Stepper , class System , class State #ifndef DOXYGEN_SKIP , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type #endif > class adaptive_iterator : public adaptive_iterator_impl< adaptive_iterator< Stepper , System , State , StepperTag > , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag > { typedef typename traits::time_type< Stepper >::type time_type; typedef adaptive_iterator< Stepper , System , State , StepperTag > iterator_type; public: adaptive_iterator( Stepper stepper , System sys , State &s , time_type t_start , time_type t_end , time_type dt ) : adaptive_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt ) {} adaptive_iterator( Stepper stepper , System sys , State &s ) : adaptive_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s ) {} }; template< class Stepper , class System , class State > adaptive_iterator< Stepper , System , State > make_adaptive_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) { return adaptive_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ); } template< class Stepper , class System , class State > adaptive_iterator< Stepper , System , State > make_adaptive_iterator_end( Stepper stepper , System system , State &x ) { return adaptive_iterator< Stepper , System , State >( stepper , system , x ); } template< class Stepper , class System , class State > std::pair< adaptive_iterator< Stepper , System , State > , adaptive_iterator< Stepper , System , State > > make_adaptive_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) { return std::make_pair( adaptive_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ) , adaptive_iterator< Stepper , System , State >( stepper , system , x ) ); } /** * \class adaptive_iterator * * \brief ODE Iterator with adaptive step size. The value type of this iterator is the state type of the stepper. * * Implements an iterator representing the solution of an ODE from t_start * to t_end evaluated at steps with an adaptive step size dt. * After each iteration the iterator dereferences to the state x at the next * time t+dt where dt is controlled by the stepper. * This iterator can be used with ControlledSteppers and * DenseOutputSteppers and it always makes use of the all the given steppers * capabilities. A for_each over such an iterator range behaves similar to * the integrate_adaptive routine. * * adaptive_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. * \tparam State The state type of the ODE. */ /** * \fn make_adaptive_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function for adaptive_iterator. Constructs a begin iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. * \param t_start The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. * \returns The adaptive iterator. */ /** * \fn make_adaptive_iterator_end( Stepper stepper , System system , State &x ) * \brief Factory function for adaptive_iterator. Constructs a end iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. * \returns The adaptive iterator. */ /** * \fn make_adaptive_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function to construct a single pass range of adaptive iterators. A range is here a pair of adaptive_iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. * \param t_start The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. * \returns The adaptive range. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_ITERATOR_HPP_INCLUDED PK 䄟[E� � � ! iterator/n_step_time_iterator.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/n_step_time_iterator.hpp [begin_description] Iterator for iterating through the solution of an ODE with constant step size performing exactly n steps. The dereferenced type contains also the time. [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_N_STEP_TIME_ITERATOR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ITERATOR_N_STEP_TIME_ITERATOR_HPP_INCLUDED #include <boost/numeric/odeint/util/stepper_traits.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp> #include <boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp> namespace boost { namespace numeric { namespace odeint { /* use the n_step_iterator_impl with the right tags */ template< class Stepper , class System , class State #ifndef DOXYGEN_SKIP , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type #endif > class n_step_time_iterator : public n_step_iterator_impl< n_step_time_iterator< Stepper , System , State , StepperTag > , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag > { typedef typename traits::time_type< Stepper >::type time_type; typedef n_step_time_iterator< Stepper , System , State , StepperTag > iterator_type; public: n_step_time_iterator( Stepper stepper , System sys , State &s , time_type t , time_type dt , size_t num_of_steps ) : n_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s , t , dt , num_of_steps ) {} n_step_time_iterator( Stepper stepper , System sys , State &s ) : n_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s ) {} }; /* make functions */ template< class Stepper , class System , class State > n_step_time_iterator< Stepper , System, State > make_n_step_time_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps ) { return n_step_time_iterator< Stepper , System , State >( stepper , system , x , t , dt , num_of_steps ); } template< class Stepper , class System , class State > n_step_time_iterator< Stepper , System , State > make_n_step_time_iterator_end( Stepper stepper , System system , State &x ) { return n_step_time_iterator< Stepper , System , State >( stepper , system , x ); } template< class Stepper , class System , class State > std::pair< n_step_time_iterator< Stepper , System , State > , n_step_time_iterator< Stepper , System , State > > make_n_step_time_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps ) { return std::make_pair( n_step_time_iterator< Stepper , System , State >( stepper , system , x , t , dt , num_of_steps ) , n_step_time_iterator< Stepper , System , State >( stepper , system , x ) ); } /** * \class n_step_time_iterator * * \brief ODE Iterator with constant step size. The value type of this iterator is a std::pair containing state and time. * * Implements an iterator representing the solution of an ODE starting from t * with n steps and a constant step size dt. * After each iteration the iterator dereferences to a pair of state and time at the next * time t+dt. * This iterator can be used with Steppers and * DenseOutputSteppers and it always makes use of the all the given steppers * capabilities. A for_each over such an iterator range behaves similar to * the integrate_n_steps routine. * * n_step_time_iterator is a model of single-pass iterator. * * The value type of this iterator is pair of state and 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. * \tparam State The state type of the ODE. */ /** * \fn make_n_step_time_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps ) * * \brief Factory function for n_step_time_iterator. Constructs a begin iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x 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. * \returns The n-step iterator. */ /** * \fn make_n_step_time_iterator_end( Stepper stepper , System system , State &x ) * \brief Factory function for n_step_time_iterator. Constructs an end iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration. * \returns The const_step_iterator. */ /** * \fn make_n_step_time_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps ) * * \brief Factory function to construct a single pass range of n-step iterators. A range is here a pair * of n_step_time_iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator store 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. * \returns The n-step range. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_CONST_N_STEP_TIME_ITERATOR_HPP_INCLUDED PK 䄟[�eģ-' -' ( iterator/impl/adaptive_iterator_impl.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/detail/adaptive_iterator_impl.hpp [begin_description] tba. [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_ITERATOR_DETAIL_ADAPTIVE_ITERATOR_IMPL_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ADAPTIVE_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 , typename Tag , typename StepperTag > class adaptive_iterator_impl; /* * 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 adaptive step size control. Uses controlled steppers. adaptive_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 adaptive_iterator_impl< Iterator , Stepper , System , State , 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 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 an adaptive_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 The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. */ adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt ) : base_type( stepper , sys , t , dt ) , m_t_end( t_end ) , m_state( &s ) { if( detail::less_with_sign( this->m_t_end , this->m_t , this->m_dt ) ) 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. */ adaptive_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( detail::less_with_sign( this->m_t , this->m_t_end , this->m_dt) ) { if( detail::less_with_sign( this->m_t_end , static_cast<time_type>(this->m_t + this->m_dt) , this->m_dt ) ) { this->m_dt = this->m_t_end - this->m_t; } 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 , this->m_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." )); } } else { this->m_at_end = true; } } public: const state_type& get_state() const { return *this->m_state; } private: time_type m_t_end; state_type* m_state; }; /* * Specilization for dense outputer 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 adaptive step size control. Uses dense-output steppers. adaptive_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 adaptive_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 an adaptive_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 The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. */ adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt ) : base_type( stepper , sys , t , dt ) , m_t_end( t_end ) { if( detail::less_eq_with_sign( this->m_t , this->m_t_end , this->m_dt ) ) { unwrapped_stepper_type &st = this->m_stepper; st.initialize( s , this->m_t , this->m_dt ); } else { 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_impl( stepper_type stepper , system_type sys , state_type& /* s */ ) : base_type( stepper , sys ) { } protected: friend class boost::iterator_core_access; void increment() { unwrapped_stepper_type &stepper = this->m_stepper; if( detail::less_with_sign( this->m_t , this->m_t_end , stepper.current_time_step() ) ) { if( detail::less_with_sign( this->m_t_end , static_cast<time_type>(this->m_t + stepper.current_time_step()) , stepper.current_time_step() ) ) { // make stpper to end exactly at t_end stepper.initialize( stepper.current_state() , stepper.current_time() , static_cast<time_type>(this->m_t_end-this->m_t) ); } stepper.do_step( this->m_system ); this->m_t = stepper.current_time(); } else { // we have reached t_end this->m_at_end = true; } } public: const state_type& get_state() const { const unwrapped_stepper_type &stepper = this->m_stepper; return stepper.current_state(); } private: time_type m_t_end; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ADAPTIVE_ITERATOR_IMPL_HPP_DEFINED PK 䄟[���8 �8 % iterator/impl/times_iterator_impl.hppnu �[��� /* [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 PK 䄟[ѹ&sc# c# & iterator/impl/n_step_iterator_impl.hppnu �[��� /* [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 PK 䄟[�~r9�" �" * iterator/impl/const_step_iterator_impl.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/detail/const_step_iterator_impl.hpp [begin_description] tba. [end_description] Copyright 2013 Karsten Ahnert Copyright 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_CONST_STEP_ITERATOR_IMPL_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_CONST_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 const_step_iterator_impl; /* * Specilization for steppers and error steppers */ template< class Iterator , class Stepper , class System , class State , typename Tag > class const_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 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 t_end The end time, at which the iteration should stop. * \param dt The initial time step. */ const_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt ) : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_t_end( t_end ) , m_state( &s ) , m_step( 0 ) { if( detail::less_with_sign( this->m_t_end , this->m_t , this->m_dt ) ) this->m_at_end = true; } /** * \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. */ const_step_iterator_impl( stepper_type stepper , system_type sys , state_type& /* s */ ) : base_type( stepper , sys ) { } protected: friend class boost::iterator_core_access; void increment() { if( detail::less_eq_with_sign( static_cast<time_type>(this->m_t+this->m_dt) , this->m_t_end , this->m_dt ) ) { 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_step; }; /* * Specilization for dense output stepper */ /** * \brief ODE Iterator 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 steps. Uses dense-output steppers. * const_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 const_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 t_end The end time, at which the iteration should stop. * \param dt The initial time step. */ const_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt ) : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_t_end( t_end ) , m_state( &s ) , m_step( 0 ) { if( detail::less_eq_with_sign( this->m_t , this->m_t_end , this->m_dt ) ) { 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 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. */ const_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( detail::less_eq_with_sign( static_cast<time_type>(this->m_t+this->m_dt) , this->m_t_end , this->m_dt ) ) { 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_step; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_CONST_STEP_ITERATOR_IMPL_HPP_DEFINED PK 䄟[��g�d d % iterator/const_step_time_iterator.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/const_step_time_iterator.hpp [begin_description] Iterator for iterating throught the solution of an ODE with constant step size. The dereferences types containes also the time. [end_description] Copyright 2012-2013 Karsten Ahnert Copyright 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_CONST_STEP_TIME_ITERATOR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_TIME_ITERATOR_HPP_INCLUDED #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/util/stepper_traits.hpp> #include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp> #include <boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp> namespace boost { namespace numeric { namespace odeint { /* use the const_step_iterator_impl with the right tags */ template< class Stepper , class System , class State #ifndef DOXYGEN_SKIP , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type #endif > class const_step_time_iterator : public const_step_iterator_impl< const_step_time_iterator< Stepper , System , State , StepperTag > , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag > { typedef typename traits::time_type< Stepper >::type time_type; typedef const_step_time_iterator< Stepper , System , State , StepperTag > iterator_type; public: const_step_time_iterator( Stepper stepper , System sys , State &s , time_type t_start , time_type t_end , time_type dt ) : const_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt ) {} const_step_time_iterator( Stepper stepper , System sys , State &s ) : const_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s ) {} }; template< class Stepper , class System , class State > const_step_time_iterator< Stepper , System , State > make_const_step_time_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) { return const_step_time_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ); } template< class Stepper , class System , class State > const_step_time_iterator< Stepper , System , State > make_const_step_time_iterator_end( Stepper stepper , System system , State &x ) { return const_step_time_iterator< Stepper , System , State >( stepper , system , x ); } template< class Stepper , class System , class State > std::pair< const_step_time_iterator< Stepper , System , State > , const_step_time_iterator< Stepper , System , State > > make_const_step_time_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) { return std::make_pair( const_step_time_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ) , const_step_time_iterator< Stepper , System , State >( stepper , system , x ) ); } /** * \class const_step_time_iterator * * \brief ODE Iterator with constant step size. The value type of this iterator is a std::pair containing state and time. * * Implements an iterator representing the solution of an ODE from t_start * to t_end evaluated at steps with constant step size dt. * After each iteration the iterator dereferences to a pair containing * state and time at the next time point t+dt.. * This iterator can be used with Steppers and * DenseOutputSteppers and it always makes use of the all the given steppers * capabilities. A for_each over such an iterator range behaves similar to * the integrate_const routine. * * const_step_time_iterator is a model of single-pass iterator. * * The value type of this iterator is a pair with the state type and time type of the stepper. * * \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. * \tparam State The state type of the ODE. */ /** * \fn make_const_step_time_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function for const_step_time_iterator. Constructs a begin iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_time_iterator stores a reference of s and changes its value during the iteration. * \param t_start The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. * \returns The const step time iterator. */ /** * \fn make_const_step_time_iterator_end( Stepper stepper , System system , State &x ) * \brief Factory function for const_step_time_iterator. Constructs a end iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_time_iterator store a reference of s and changes its value during the iteration. * \returns The const step time iterator. */ /** * \fn make_const_step_time_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt) * * \brief Factory function to construct a single pass range of const_step_time_iterator. A range is here a pair of const_step_time_iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_time_iterator stores a reference of s and changes its value during the iteration. * \param t The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. * \returns The const step time range. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_TIME_ITERATOR_HPP_INCLUDED PK 䄟[dYj$" " iterator/const_step_iterator.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/const_step_iterator.hpp [begin_description] Iterator for iterating through the solution of an ODE with constant step size. [end_description] Copyright 2012-2013 Karsten Ahnert Copyright 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_CONST_STEP_ODE_ITERATOR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_ODE_ITERATOR_HPP_INCLUDED #include <boost/numeric/odeint/util/stepper_traits.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp> #include <boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp> namespace boost { namespace numeric { namespace odeint { /* use the const_step_iterator_impl with the right tags */ template< class Stepper , class System , class State #ifndef DOXYGEN_SKIP , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type #endif > class const_step_iterator : public const_step_iterator_impl< const_step_iterator< Stepper , System , State , StepperTag > , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag > { typedef typename traits::time_type< Stepper >::type time_type; typedef const_step_iterator< Stepper , System , State , StepperTag > iterator_type; public: const_step_iterator( Stepper stepper , System sys , State &s , time_type t_start , time_type t_end , time_type dt ) : const_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt ) {} const_step_iterator( Stepper stepper , System sys , State &s ) : const_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s ) {} }; /* make functions */ template< class Stepper , class System , class State > const_step_iterator< Stepper , System, State > make_const_step_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) { return const_step_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ); } template< class Stepper , class System , class State > const_step_iterator< Stepper , System , State > make_const_step_iterator_end( Stepper stepper , System system , State &x ) { return const_step_iterator< Stepper , System , State >( stepper , system , x ); } template< class Stepper , class System , class State > std::pair< const_step_iterator< Stepper , System , State > , const_step_iterator< Stepper , System , State > > make_const_step_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) { return std::make_pair( const_step_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ) , const_step_iterator< Stepper , System , State >( stepper , system , x ) ); } /** * \class const_step_iterator * * \brief ODE Iterator with constant step size. The value type of this iterator is the state type of the stepper. * * Implements an iterator representing the solution of an ODE from t_start * to t_end evaluated at steps with constant step size dt. * After each iteration the iterator dereferences to the state x at the next * time t+dt. * This iterator can be used with Steppers and * DenseOutputSteppers and it always makes use of the all the given steppers * capabilities. A for_each over such an iterator range behaves similar to * the integrate_const routine. * * const_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. * \tparam State The state type of the ODE. */ /** * \fn make_const_step_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function for const_step_iterator. Constructs a begin iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration. * \param t_start The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. * \returns The const step iterator. */ /** * \fn make_const_step_iterator_end( Stepper stepper , System system , State &x ) * \brief Factory function for const_step_iterator. Constructs a end iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration. * \returns The const_step_iterator. */ /** * \fn make_const_step_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function to construct a single pass range of const step iterators. A range is here a pair * of const_step_iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator store a reference of s and changes its value during the iteration. * \param t_start The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. * \returns The const step range. */ } // namespace odeint } // namespace numeric } // namespace boost //#include <boost/numeric/odeint/iterator/impl/const_step_iterator_dense_output_impl.hpp> #endif // BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_ODE_ITERATOR_HPP_INCLUDED PK 䄟[8"�fR R iterator/times_iterator.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/times_iterator.hpp [begin_description] Iterator for iterating through the solution of an ODE with oscillator calls at times from a given sequence. [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_TIMES_ITERATOR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_ITERATOR_HPP_INCLUDED #include <boost/numeric/odeint/util/stepper_traits.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp> #include <boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp> namespace boost { namespace numeric { namespace odeint { /* use the times_iterator_impl with the right tags */ template< class Stepper , class System , class State , class TimeIterator #ifndef DOXYGEN_SKIP , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type #endif > class times_iterator : public times_iterator_impl< times_iterator< Stepper , System , State , TimeIterator , StepperTag > , Stepper , System , State , TimeIterator , detail::ode_state_iterator_tag , StepperTag > { typedef typename traits::time_type< Stepper >::type time_type; typedef times_iterator< Stepper , System , State , TimeIterator , StepperTag > iterator_type; public: times_iterator( Stepper stepper , System sys , State &s , TimeIterator t_start , TimeIterator t_end , time_type dt ) : times_iterator_impl< iterator_type , Stepper , System , State , TimeIterator, detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt ) {} times_iterator( Stepper stepper , System sys , State &s ) : times_iterator_impl< iterator_type , Stepper , System , State , TimeIterator , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s ) {} }; /* make functions */ template< class Stepper , class System , class State , class TimeIterator > times_iterator< Stepper , System, State , TimeIterator > make_times_iterator_begin( Stepper stepper , System system , State &x , TimeIterator t_start , TimeIterator t_end , typename traits::time_type< Stepper >::type dt ) { return times_iterator< Stepper , System , State , TimeIterator >( stepper , system , x , t_start , t_end , dt ); } // ToDo: requires to specifically provide the TimeIterator template parameter, can this be improved? template< class TimeIterator , class Stepper , class System , class State > times_iterator< Stepper , System , State , TimeIterator > make_times_iterator_end( Stepper stepper , System system , State &x ) //TimeIterator t_end ) { return times_iterator< Stepper , System , State , TimeIterator >( stepper , system , x ); } template< class Stepper , class System , class State , class TimeIterator > std::pair< times_iterator< Stepper , System , State , TimeIterator > , times_iterator< Stepper , System , State , TimeIterator > > make_times_range( Stepper stepper , System system , State &x , TimeIterator t_start , TimeIterator t_end , typename traits::time_type< Stepper >::type dt ) { return std::make_pair( times_iterator< Stepper , System , State , TimeIterator >( stepper , system , x , t_start , t_end , dt ) , times_iterator< Stepper , System , State , TimeIterator >( stepper , system , x ) ); } /** * \class times_iterator * * \brief ODE Iterator with given evaluation points. The value type of this iterator is the state type of the stepper. * * Implements an iterator representing the solution of an ODE from *t_start * to *t_end evaluated at time points given by the sequence t_start to t_end. * t_start and t_end are iterators representing a sequence of time points * where the solution of the ODE should be evaluated. * After each iteration the iterator dereferences to the state x at the next * time *t_start++ until t_end is reached. * This iterator can be used with Steppers, ControlledSteppers and * DenseOutputSteppers and it always makes use of the all the given steppers * capabilities. A for_each over such an iterator range behaves similar to * the integrate_times routine. * * 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. * \tparam State The state type of the ODE. * \tparam TimeIterator The iterator type for the sequence of time points. */ /** * \fn make_times_iterator_begin( Stepper stepper , System system , State &x , TimeIterator t_start , TimeIterator t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function for times_iterator. Constructs a begin iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration. * \param t_start Begin iterator of the sequence of evaluation time points. * \param t_end End iterator of the sequence of evaluation time points. * \param dt The initial time step. * \returns The times iterator. */ /** * \fn make_times_iterator_end( Stepper stepper , System system , State &x ) * \brief Factory function for times_iterator. Constructs an end iterator. * * \tparam TimesIterator The iterator type of the time sequence, must be specifically provided. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration. * \returns The times iterator. * * This function needs the TimeIterator type specifically defined as a * template parameter. */ /** * \fn make_times_range( Stepper stepper , System system , State &x , TimeIterator t_start , TimeIterator t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function to construct a single pass range of times iterators. A range is here a pair * of times_iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator store a reference of s and changes its value during the iteration. * \param t_start Begin iterator of the sequence of evaluation time points. * \param t_end End iterator of the sequence of evaluation time points. * \param dt The initial time step. * \returns The times iterator range. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_ITERATOR_HPP_INCLUDED PK 䄟[�)B # iterator/adaptive_time_iterator.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/adaptive_time_iterator.hpp [begin_description] Iterator for iterating throught the solution of an ODE with adaptive step size. The dereferenced types containes also the time. [end_description] Copyright 2012-2013 Karsten Ahnert Copyright 2012-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_ADAPTIVE_TIME_ITERATOR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_TIME_ITERATOR_HPP_INCLUDED #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/util/stepper_traits.hpp> #include <boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp> namespace boost { namespace numeric { namespace odeint { /* use the adaptive_iterator_impl with the right tags */ template< class Stepper , class System , class State #ifndef DOXYGEN_SKIP , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type #endif > class adaptive_time_iterator : public adaptive_iterator_impl< adaptive_time_iterator< Stepper , System , State , StepperTag > , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag > { typedef typename traits::time_type< Stepper >::type time_type; typedef adaptive_time_iterator< Stepper , System , State , StepperTag > iterator_type; public: adaptive_time_iterator( Stepper stepper , System sys , State &s , time_type t_start , time_type t_end , time_type dt ) : adaptive_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt ) {} adaptive_time_iterator( Stepper stepper , System sys , State &s ) : adaptive_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s ) {} }; template< class Stepper , class System , class State > adaptive_time_iterator< Stepper , System , State > make_adaptive_time_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) { return adaptive_time_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ); } template< class Stepper , class System , class State > adaptive_time_iterator< Stepper , System , State > make_adaptive_time_iterator_end( Stepper stepper , System system , State &x ) { return adaptive_time_iterator< Stepper , System , State >( stepper , system , x ); } template< class Stepper , class System , class State > std::pair< adaptive_time_iterator< Stepper , System , State > , adaptive_time_iterator< Stepper , System , State > > make_adaptive_time_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) { return std::make_pair( adaptive_time_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ) , adaptive_time_iterator< Stepper , System , State >( stepper , system , x ) ); } /** * \class adaptive_time_iterator * * \brief ODE Iterator with adaptive step size. The value type of this iterator is a std::pair containing state and time. * * Implements an iterator representing the solution of an ODE from t_start * to t_end evaluated at steps with an adaptive step size dt. * After each iteration the iterator dereferences to a pair containing state * and time at the next time point t+dt where dt is controlled by the stepper. * This iterator can be used with ControlledSteppers and * DenseOutputSteppers and it always makes use of the all the given steppers * capabilities. A for_each over such an iterator range behaves similar to * the integrate_adaptive routine. * * adaptive_iterator is a model of single-pass iterator. * * The value type of this iterator is a std::pair of state and time of the stepper. * * \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. * \tparam State The state type of the ODE. */ /** * \fn make_adaptive_time_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function for adaptive_time_iterator. Constructs a begin iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. adaptive_time_iterator stores a reference of s and changes its value during the iteration. * \param t_start The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. * \returns The adaptive time iterator. */ /** * \fn make_adaptive_time_iterator_end( Stepper stepper , System system , State &x ) * \brief Factory function for adaptive_time_iterator. Constructs a end iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. adaptive_time_iterator stores a reference of s and changes its value during the iteration. * \returns The adaptive time iterator. */ /** * \fn make_adaptive_time_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t_start , typename traits::time_type< Stepper >::type t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function to construct a single pass range of adaptive time iterators. A range is here a pair of adaptive_time_iterators. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. adaptive_time_iterator stores a reference of s and changes its value during the iteration. * \param t_start The initial time. * \param t_end The end time, at which the iteration should stop. * \param dt The initial time step. * \returns The adaptive time range. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_TIME_ITERATOR_HPP_INCLUDED PK 䄟[[ [ iterator/n_step_iterator.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/n_step_iterator.hpp [begin_description] Iterator for iterating through the solution of an ODE with constant step size performing exactly n steps. [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_N_STEP_ITERATOR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ITERATOR_N_STEP_ITERATOR_HPP_INCLUDED #include <boost/numeric/odeint/util/stepper_traits.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp> #include <boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp> namespace boost { namespace numeric { namespace odeint { /* use the n_step_iterator_impl with the right tags */ template< class Stepper , class System , class State #ifndef DOXYGEN_SKIP , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type #endif > class n_step_iterator : public n_step_iterator_impl< n_step_iterator< Stepper , System , State , StepperTag > , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag > { typedef typename traits::time_type< Stepper >::type time_type; typedef n_step_iterator< Stepper , System , State , StepperTag > iterator_type; public: n_step_iterator( Stepper stepper , System sys , State &s , time_type t , time_type dt , size_t num_of_steps ) : n_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s , t , dt , num_of_steps ) {} n_step_iterator( Stepper stepper , System sys , State &s ) : n_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s ) {} }; /* make functions */ template< class Stepper , class System , class State > n_step_iterator< Stepper , System, State > make_n_step_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps ) { return n_step_iterator< Stepper , System , State >( stepper , system , x , t , dt , num_of_steps ); } template< class Stepper , class System , class State > n_step_iterator< Stepper , System , State > make_n_step_iterator_end( Stepper stepper , System system , State &x ) { return n_step_iterator< Stepper , System , State >( stepper , system , x ); } template< class Stepper , class System , class State > std::pair< n_step_iterator< Stepper , System , State > , n_step_iterator< Stepper , System , State > > make_n_step_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps ) { return std::make_pair( n_step_iterator< Stepper , System , State >( stepper , system , x , t , dt , num_of_steps ) , n_step_iterator< Stepper , System , State >( stepper , system , x ) ); } /** * \class n_step_iterator * * \brief ODE Iterator with constant step size. The value type of this iterator is the state type of the stepper. * * Implements an iterator representing the solution of an ODE starting from t * with n steps and a constant step size dt. * After each iteration the iterator dereferences to the state x at the next * time t+dt. * This iterator can be used with Steppers and * DenseOutputSteppers and it always makes use of the all the given steppers * capabilities. A for_each over such an iterator range behaves similar to * the integrate_n_steps routine. * * 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. * \tparam State The state type of the ODE. */ /** * \fn make_n_step_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps ) * * \brief Factory function for n_step_iterator. Constructs a begin iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x 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. * \returns The n-step iterator. */ /** * \fn make_n_step_iterator_end( Stepper stepper , System system , State &x ) * \brief Factory function for n_step_iterator. Constructs an end iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration. * \returns The const_step_iterator. */ /** * \fn make_n_step_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , , size_t num_of_steps ) * * \brief Factory function to construct a single pass range of n-step iterators. A range is here a pair * of n_step_iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator store 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. * \returns The n-step range. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_CONST_N_STEP_ITERATOR_HPP_INCLUDED PK 䄟[���X X % iterator/detail/ode_iterator_base.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp [begin_description] Base class for const_step_iterator and adaptive_iterator. [end_description] Copyright 2012-2013 Karsten Ahnert Copyright 2012-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_ODE_ITERATOR_BASE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ODE_ITERATOR_BASE_HPP_INCLUDED #include <boost/iterator/iterator_facade.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { struct ode_state_iterator_tag {}; struct ode_state_time_iterator_tag {}; template< class Iterator , class Stepper , class System , class State , typename Tag > class ode_iterator_base; /* Specialization for the state iterator that has only state_type as its value_type */ template< class Iterator , class Stepper , class System , class State > class ode_iterator_base< Iterator , Stepper , System , State , ode_state_iterator_tag > : public boost::iterator_facade < Iterator , typename traits::state_type< Stepper >::type const , boost::single_pass_traversal_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 unwrapped_stepper_type::time_type time_type; typedef typename unwrapped_stepper_type::value_type ode_value_type; public: ode_iterator_base( stepper_type stepper , system_type sys , time_type t , time_type dt ) : m_stepper( stepper ) , m_system( sys ) , m_t( t ) , m_dt( dt ) , m_at_end( false ) { } ode_iterator_base( stepper_type stepper , system_type sys ) : m_stepper( stepper ) , m_system( sys ) , m_t() , m_dt() , m_at_end( true ) { } // this function is only for testing bool same( const ode_iterator_base &iter ) const { return ( //( static_cast<Iterator>(*this).get_state() == // static_cast<Iterator>(iter).get_state ) && ( m_t == iter.m_t ) && ( m_dt == iter.m_dt ) && ( m_at_end == iter.m_at_end ) ); } protected: friend class boost::iterator_core_access; bool equal( ode_iterator_base const& other ) const { if( m_at_end == other.m_at_end ) { return true; } else { return false; } } const state_type& dereference() const { return static_cast<const Iterator*>(this)->get_state(); } protected: stepper_type m_stepper; system_type m_system; time_type m_t; time_type m_dt; bool m_at_end; }; /* Specialization for the state-time iterator that has pair<state_type,time_type> as its value_type */ template< class Iterator , class Stepper , class System , class State > class ode_iterator_base< Iterator , Stepper , System , State , ode_state_time_iterator_tag > : public boost::iterator_facade < Iterator , std::pair< const State , const typename traits::time_type< Stepper >::type > , boost::single_pass_traversal_tag , std::pair< const State& , const typename traits::time_type< Stepper >::type& > > { 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 unwrapped_stepper_type::time_type time_type; typedef typename unwrapped_stepper_type::value_type ode_value_type; public: ode_iterator_base( stepper_type stepper , system_type sys , time_type t , time_type dt ) : m_stepper( stepper ) , m_system( sys ) , m_t( t ) , m_dt( dt ) , m_at_end( false ) { } ode_iterator_base( stepper_type stepper , system_type sys ) : m_stepper( stepper ) , m_system( sys ) , m_at_end( true ) { } bool same( ode_iterator_base const& iter ) { return ( //( static_cast<Iterator>(*this).get_state() == // static_cast<Iterator>(iter).get_state ) && ( m_t == iter.m_t ) && ( m_dt == iter.m_dt ) && ( m_at_end == iter.m_at_end ) ); } protected: friend class boost::iterator_core_access; bool equal( ode_iterator_base const& other ) const { if( m_at_end == other.m_at_end ) { return true; } else { return false; } } std::pair< const state_type& , const time_type& > dereference() const { return std::pair< const state_type & , const time_type & >( static_cast<const Iterator*>(this)->get_state() , m_t ); } stepper_type m_stepper; system_type m_system; time_type m_t; time_type m_dt; bool m_at_end; }; } // namespace detail } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ODE_ITERATOR_BASE_HPP_INCLUDED PK 䄟[� yP P ( iterator/integrate/integrate_n_steps.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate_n_steps.hpp [begin_description] Integration of n steps with constant time size. Adaptive and dense-output methods are fully supported. [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_INTEGRATE_N_STEPS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED #include <boost/type_traits/is_same.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/integrate/null_observer.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp> namespace boost { namespace numeric { namespace odeint { /* * Integrates n steps * * the two overloads are needed in order to solve the forwarding problem */ template< class Stepper , class System , class State , class Time , class Observer> Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; return detail::integrate_n_steps( stepper , system , start_state , start_time , dt , num_of_steps , observer , stepper_category() ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time , class Observer > Time integrate_n_steps( Stepper stepper , System system , const State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; return detail::integrate_n_steps( stepper , system , start_state , start_time , dt , num_of_steps , observer , stepper_category() ); } /** * \brief The same function as above, but without observer calls. */ template< class Stepper , class System , class State , class Time > Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps ) { return integrate_n_steps( stepper , system , start_state , start_time , dt , num_of_steps , null_observer() ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time > Time integrate_n_steps( Stepper stepper , System system , const State &start_state , Time start_time , Time dt , size_t num_of_steps ) { return integrate_n_steps( stepper , system , start_state , start_time , dt , num_of_steps , null_observer() ); } /************* DOXYGEN *************/ /** * \fn Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer ) * \brief Integrates the ODE with constant step size. * * This function is similar to integrate_const. The observer is called at * equidistant time intervals t0 + n*dt. * If the Stepper is a normal stepper without step size control, dt is also * used for the numerical scheme. If a ControlledStepper is provided, the * algorithm might reduce the step size to meet the error bounds, but it is * ensured that the observer is always called at equidistant time points * t0 + n*dt. If a DenseOutputStepper is used, the step size also may vary * and the dense output is used to call the observer at equidistant time * points. The final integration time is always t0 + num_of_steps*dt. * * \param stepper The stepper to be used for numerical integration. * \param system Function/Functor defining the rhs of the ODE. * \param start_state The initial condition x0. * \param start_time The initial time t0. * \param dt The time step between observer calls, _not_ necessarily the * time step of the integration. * \param num_of_steps Number of steps to be performed * \param observer Function/Functor called at equidistant time intervals. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED PK 䄟[�1"_ _ * iterator/integrate/observer_collection.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/observer_collection.hpp [begin_description] Collection of observers, which are all called during the evolution of the ODE. [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_OBSERVER_COLLECTION_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED #include <vector> #include <boost/function.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Time > class observer_collection { public: typedef boost::function< void( const State& , const Time& ) > observer_type; typedef std::vector< observer_type > collection_type; void operator()( const State& x , Time t ) { for( size_t i=0 ; i<m_observers.size() ; ++i ) m_observers[i]( x , t ); } collection_type& observers( void ) { return m_observers; } const collection_type& observers( void ) const { return m_observers; } private: collection_type m_observers; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED PK 䄟[ .��> > & iterator/integrate/integrate_times.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate_times.hpp [begin_description] Integration of ODEs with observation at user defined points [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_INTEGRATE_TIMES_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED #include <boost/type_traits/is_same.hpp> #include <boost/range.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/integrate/null_observer.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp> namespace boost { namespace numeric { namespace odeint { /* * the two overloads are needed in order to solve the forwarding problem */ template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; return detail::integrate_times( stepper , system , start_state , times_start , times_end , dt , observer , stepper_category() ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , const State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; return detail::integrate_times( stepper , system , start_state , times_start , times_end , dt , observer , stepper_category() ); } /** * \brief The same function as above, but without observer calls. */ template< class Stepper , class System , class State , class TimeRange , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , State &start_state , const TimeRange × , Time dt , Observer observer ) { return integrate_times( stepper , system , start_state , boost::begin( times ) , boost::end( times ) , dt , observer ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class TimeRange , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , const State &start_state , const TimeRange × , Time dt , Observer observer ) { return integrate_times( stepper , system , start_state , boost::begin( times ) , boost::end( times ) , dt , observer ); } /********* DOXYGEN ***********/ /** * \fn size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer ) * \brief Integrates the ODE with observer calls at given time points. * * Integrates the ODE given by system using the given stepper. This function * does observer calls at the subsequent time points given by the range * times_start, times_end. If the stepper has not step size control, the * step size might be reduced occasionally to ensure observer calls exactly * at the time points from the given sequence. If the stepper is a * ControlledStepper, the step size is adjusted to meet the error bounds, * but also might be reduced occasionally to ensure correct observer calls. * If a DenseOutputStepper is provided, the dense output functionality is * used to call the observer at the given times. The end time of the * integration is always *(end_time-1). * * \param stepper The stepper to be used for numerical integration. * \param system Function/Functor defining the rhs of the ODE. * \param start_state The initial condition x0. * \param times_start Iterator to the start time * \param times_end Iterator to the end time * \param dt The time step between observer calls, _not_ necessarily the * time step of the integration. * \param observer Function/Functor called at equidistant time intervals. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED PK 䄟[��= = $ iterator/integrate/null_observer.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/null_observer.hpp [begin_description] null_observer [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_NULL_OBSERVER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { struct null_observer { template< class State , class Time > void operator()( const State& /* x */ , Time /* t */ ) const { } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED PK 䄟[�!�4 4 / iterator/integrate/detail/integrate_n_steps.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp [begin_description] integrate steps implementation [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/functors.hpp> #include <boost/numeric/odeint/iterator/n_step_time_iterator.hpp> #include <boost/numeric/odeint/util/unit_helper.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { // forward declaration template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time &start_time , Time end_time , Time &dt , Observer observer , controlled_stepper_tag ); /* basic version */ template< class Stepper , class System , class State , class Time , class Observer> Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer , stepper_tag ) { // ToDo: is there a better way to extract the final time? Time t = start_time; // Assignment is only here to avoid warnings. boost::for_each( make_n_step_time_range( stepper , system , start_state , start_time , dt , num_of_steps ) , obs_caller_time< Observer , Time >( t , observer ) ); return t; } /* controlled version */ template< class Stepper , class System , class State , class Time , class Observer> Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer , controlled_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; Time time = start_time; Time time_step = dt; for( size_t step = 0; step < num_of_steps ; ++step ) { obs( start_state , time ); detail::integrate_adaptive( stepper , system , start_state , time , static_cast<Time>(time+time_step) , dt , null_observer() , controlled_stepper_tag() ); // direct computation of the time avoids error propagation happening when using time += dt // we need clumsy type analysis to get boost units working here time = start_time + static_cast< typename unit_value_type<Time>::type >(step+1) * time_step; } obs( start_state , time ); return time; } /* dense output version */ template< class Stepper , class System , class State , class Time , class Observer> Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer , dense_output_stepper_tag ) { // ToDo: is there a better way to extract the final time? Time t = start_time; // Assignment is only here to avoid warnings. boost::for_each( make_n_step_time_range( stepper , system , start_state , start_time , dt , num_of_steps ) , obs_caller_time< Observer , Time >( t , observer ) ); return t; } } } } } #endif /* BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED */ PK 䄟[ Au� � & iterator/integrate/detail/functors.hppnu �[��� /* [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 PK 䄟[$���� � - iterator/integrate/detail/integrate_times.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/detail/integrate_times.hpp [begin_description] Default integrate times implementation. [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_INTEGRATE_DETAIL_INTEGRATE_TIMES_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_TIMES_HPP_INCLUDED #include <stdexcept> #include <boost/config.hpp> #include <boost/range/algorithm/for_each.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> #include <boost/numeric/odeint/iterator/times_time_iterator.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/functors.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { /* * integrate_times for all steppers */ template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer , class StepperTag > size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator start_time , TimeIterator end_time , Time dt , Observer observer , StepperTag ) { size_t obs_calls = 0; boost::for_each( make_times_time_range( stepper , system , start_state , start_time , end_time , dt ) , // should we use traits<Stepper>::state_type here instead of State? NO! obs_caller< Observer >( obs_calls , observer ) ); // step integration steps gives step+1 observer calls return obs_calls-1; } } // namespace detail } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED PK 䄟[�6�n n 0 iterator/integrate/detail/integrate_adaptive.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp [begin_description] Default Integrate adaptive implementation. [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_INTEGRATE_ADAPTIVE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED #include <stdexcept> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp> #include <boost/numeric/odeint/iterator/adaptive_time_iterator.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/functors.hpp> #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/detail/less_with_sign.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { // forward declaration template< class Stepper , class System , class State , class Time , class Observer> size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , stepper_tag ); /* * integrate_adaptive for simple stepper is basically an integrate_const + some last step */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , stepper_tag ) { size_t steps = detail::integrate_const( stepper , system , start_state , start_time , end_time , dt , observer , stepper_tag() ); typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; Time end = start_time + dt*steps; if( less_with_sign( end , end_time , dt ) ) { //make a last step to end exactly at end_time st.do_step( system , start_state , end , end_time - end ); steps++; obs( start_state , end_time ); } return steps; } /* * classical integrate adaptive */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time &start_time , Time end_time , Time &dt , Observer observer , controlled_stepper_tag ) { size_t obs_calls = 0; boost::for_each( make_adaptive_time_range( stepper , system , start_state , start_time , end_time , dt ) , obs_caller< Observer >( obs_calls , observer ) ); return obs_calls-1; } /* * integrate adaptive for dense output steppers * * step size control is used if the stepper supports it */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , dense_output_stepper_tag ) { size_t obs_calls = 0; boost::for_each( make_adaptive_time_range( stepper , system , start_state , start_time , end_time , dt ) , obs_caller< Observer >( obs_calls , observer ) ); return obs_calls-1; } } // namespace detail } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED PK 䄟[�vY�� � - iterator/integrate/detail/integrate_const.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/detail/integrate_const.hpp [begin_description] integrate const implementation [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_INTEGRATE_DETAIL_INTEGRATE_CONST_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_CONST_HPP_INCLUDED #include <boost/range/algorithm/for_each.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/util/unit_helper.hpp> #include <boost/numeric/odeint/iterator/const_step_time_iterator.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/functors.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { // forward declaration template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time &start_time , Time end_time , Time &dt , Observer observer , controlled_stepper_tag ); template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , stepper_tag ) { size_t obs_calls = 0; boost::for_each( make_const_step_time_range( stepper , system , start_state , start_time , end_time , dt ) , // should we use traits<Stepper>::state_type here instead of State? NO! obs_caller< Observer >( obs_calls , observer ) ); // step integration steps gives step+1 observer calls return obs_calls-1; } template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , controlled_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; Time time = start_time; const Time time_step = dt; int step = 0; while( less_eq_with_sign( static_cast<Time>(time+time_step) , end_time , dt ) ) { obs( start_state , time ); detail::integrate_adaptive( stepper , system , start_state , time , time+time_step , dt , null_observer() , controlled_stepper_tag() ); // direct computation of the time avoids error propagation happening when using time += dt // we need clumsy type analysis to get boost units working here ++step; time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * time_step; } obs( start_state , time ); return step; } template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , dense_output_stepper_tag ) { size_t obs_calls = 0; boost::for_each( make_const_step_time_range( stepper , system , start_state , start_time , end_time , dt ) , obs_caller< Observer >( obs_calls , observer ) ); return obs_calls-1; } } } } } #endif PK 䄟[EpS�� � ) iterator/integrate/integrate_adaptive.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate_adaptive.hpp [begin_description] Adaptive integration of ODEs. [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_INTEGRATE_ADAPTIVE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED #include <boost/type_traits/is_same.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/integrate/null_observer.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp> namespace boost { namespace numeric { namespace odeint { /* * the two overloads are needed in order to solve the forwarding problem */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; return detail::integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , observer , stepper_category() ); /* * Suggestion for a new extendable version: * * integrator_adaptive< Stepper , System, State , Time , Observer , typename Stepper::stepper_category > integrator; * return integrator.run( stepper , system , start_state , start_time , end_time , dt , observer ); */ } /** * \brief Second version to solve the forwarding problem, * can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , const State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; return detail::integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , observer , stepper_category() ); } /** * \brief integrate_adaptive without an observer. */ template< class Stepper , class System , class State , class Time > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt ) { return integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , null_observer() ); } /** * \brief Second version to solve the forwarding problem, * can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time > size_t integrate_adaptive( Stepper stepper , System system , const State &start_state , Time start_time , Time end_time , Time dt ) { return integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , null_observer() ); } /************* DOXYGEN ************/ /** * \fn integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) * \brief Integrates the ODE with adaptive step size. * * This function integrates the ODE given by system with the given stepper. * The observer is called after each step. If the stepper has no error * control, the step size remains constant and the observer is called at * equidistant time points t0+n*dt. If the stepper is a ControlledStepper, * the step size is adjusted and the observer is called in non-equidistant * intervals. * * \param stepper The stepper to be used for numerical integration. * \param system Function/Functor defining the rhs of the ODE. * \param start_state The initial condition x0. * \param start_time The initial time t0. * \param end_time The final integration time tend. * \param dt The time step between observer calls, _not_ necessarily the * time step of the integration. * \param observer Function/Functor called at equidistant time intervals. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED PK 䄟[��L&^ ^ iterator/integrate/integrate.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate.hpp [begin_description] Convenience methods which choose the stepper for the current ODE. [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_INTEGRATE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED #include <boost/utility/enable_if.hpp> #include <boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp> #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/iterator/integrate/null_observer.hpp> #include <boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp> // for has_value_type trait #include <boost/numeric/odeint/algebra/detail/extract_value_type.hpp> namespace boost { namespace numeric { namespace odeint { /* * ToDo : * * determine type of dxdt for units * */ template< class System , class State , class Time , class Observer > typename boost::enable_if< typename has_value_type<State>::type , size_t >::type integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) { typedef controlled_runge_kutta< runge_kutta_dopri5< State , typename State::value_type , State , Time > > stepper_type; return integrate_adaptive( stepper_type() , system , start_state , start_time , end_time , dt , observer ); } /* * the two overloads are needed in order to solve the forwarding problem */ template< class System , class State , class Time > size_t integrate( System system , State &start_state , Time start_time , Time end_time , Time dt ) { return integrate( system , start_state , start_time , end_time , dt , null_observer() ); } /** * \fn integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) * \brief Integrates the ODE. * * Integrates the ODE given by system from start_time to end_time starting * with start_state as initial condition and dt as initial time step. * This function uses a dense output dopri5 stepper and performs an adaptive * integration with step size control, thus dt changes during the integration. * This method uses standard error bounds of 1E-6. * After each step, the observer is called. * * \param system The system function to solve, hence the r.h.s. of the * ordinary differential equation. * \param start_state The initial state. * \param start_time Start time of the integration. * \param end_time End time of the integration. * \param dt Initial step size, will be adjusted during the integration. * \param observer Observer that will be called after each time step. * \return The number of steps performed. */ /** * \fn integrate( System system , State &start_state , Time start_time , Time end_time , Time dt ) * \brief Integrates the ODE without observer calls. * * Integrates the ODE given by system from start_time to end_time starting * with start_state as initial condition and dt as initial time step. * This function uses a dense output dopri5 stepper and performs an adaptive * integration with step size control, thus dt changes during the integration. * This method uses standard error bounds of 1E-6. * No observer is called. * * \param system The system function to solve, hence the r.h.s. of the * ordinary differential equation. * \param start_state The initial state. * \param start_time Start time of the integration. * \param end_time End time of the integration. * \param dt Initial step size, will be adjusted during the integration. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED PK 䄟[B�-> > & iterator/integrate/integrate_const.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate_const.hpp [begin_description] Constant integration of ODEs, meaning that the state of the ODE is observed on constant time intervals. The routines makes full use of adaptive and dense-output methods. [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_INTEGRATE_CONST_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED #include <boost/type_traits/is_same.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/integrate/null_observer.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp> #include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp> namespace boost { namespace numeric { namespace odeint { /* * Integrates with constant time step dt. */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; // we want to get as fast as possible to the end if( boost::is_same< null_observer , Observer >::value ) { return detail::integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , observer , stepper_category() ); } else { return detail::integrate_const( stepper , system , start_state , start_time , end_time , dt , observer , stepper_category() ); } } /** * \brief Second version to solve the forwarding problem, * can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_const( Stepper stepper , System system , const State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; // we want to get as fast as possible to the end if( boost::is_same< null_observer , Observer >::value ) { return detail::integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , observer , stepper_category() ); } else { return detail::integrate_const( stepper , system , start_state , start_time , end_time , dt , observer , stepper_category() ); } } /** * \brief integrate_const without observer calls */ template< class Stepper , class System , class State , class Time > size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt ) { return integrate_const( stepper , system , start_state , start_time , end_time , dt , null_observer() ); } /** * \brief Second version to solve the forwarding problem, * can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time > size_t integrate_const( Stepper stepper , System system , const State &start_state , Time start_time , Time end_time , Time dt ) { return integrate_const( stepper , system , start_state , start_time , end_time , dt , null_observer() ); } /********* DOXYGEN *********/ /** * \fn integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) * \brief Integrates the ODE with constant step size. * * Integrates the ODE defined by system using the given stepper. * This method ensures that the observer is called at constant intervals dt. * If the Stepper is a normal stepper without step size control, dt is also * used for the numerical scheme. If a ControlledStepper is provided, the * algorithm might reduce the step size to meet the error bounds, but it is * ensured that the observer is always called at equidistant time points * t0 + n*dt. If a DenseOutputStepper is used, the step size also may vary * and the dense output is used to call the observer at equidistant time * points. * * \param stepper The stepper to be used for numerical integration. * \param system Function/Functor defining the rhs of the ODE. * \param start_state The initial condition x0. * \param start_time The initial time t0. * \param end_time The final integration time tend. * \param dt The time step between observer calls, _not_ necessarily the * time step of the integration. * \param observer Function/Functor called at equidistant time intervals. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED PK 䄟[�6x{ iterator/times_time_iterator.hppnu �[��� /* [auto_generated] boost/numeric/odeint/iterator/times_time_iterator.hpp [begin_description] Iterator for iterating through the solution of an ODE with oscillator calls at times from a given sequence. The dereferenced type contains also the time. [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_TIMES_TIME_ITERATOR_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_TIME_ITERATOR_HPP_INCLUDED #include <boost/numeric/odeint/util/stepper_traits.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp> #include <boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp> namespace boost { namespace numeric { namespace odeint { /* use the times_iterator_impl with the right tags */ template< class Stepper , class System , class State , class TimeIterator #ifndef DOXYGEN_SKIP , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type #endif > class times_time_iterator : public times_iterator_impl< times_time_iterator< Stepper , System , State , TimeIterator , StepperTag > , Stepper , System , State , TimeIterator , detail::ode_state_time_iterator_tag , StepperTag > { typedef typename traits::time_type< Stepper >::type time_type; typedef times_time_iterator< Stepper , System , State , TimeIterator , StepperTag > iterator_type; public: times_time_iterator( Stepper stepper , System sys , State &s , TimeIterator t_start , TimeIterator t_end , time_type dt ) : times_iterator_impl< iterator_type , Stepper , System , State , TimeIterator, detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt ) {} times_time_iterator( Stepper stepper , System sys , State &s ) : times_iterator_impl< iterator_type , Stepper , System , State , TimeIterator , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s ) {} }; /* make functions */ template< class Stepper , class System , class State , class TimeIterator > times_time_iterator< Stepper , System, State , TimeIterator > make_times_time_iterator_begin( Stepper stepper , System system , State &x , TimeIterator t_start , TimeIterator t_end , typename traits::time_type< Stepper >::type dt ) { return times_time_iterator< Stepper , System , State , TimeIterator >( stepper , system , x , t_start , t_end , dt ); } // ToDo: requires to specifically provide the TimeIterator template parameter, can this be improved? template< class TimeIterator , class Stepper , class System , class State > times_time_iterator< Stepper , System , State , TimeIterator > make_times_time_iterator_end( Stepper stepper , System system , State &x ) //TimeIterator t_end ) { return times_time_iterator< Stepper , System , State , TimeIterator >( stepper , system , x ); } template< class Stepper , class System , class State , class TimeIterator > std::pair< times_time_iterator< Stepper , System , State , TimeIterator > , times_time_iterator< Stepper , System , State , TimeIterator > > make_times_time_range( Stepper stepper , System system , State &x , TimeIterator t_start , TimeIterator t_end , typename traits::time_type< Stepper >::type dt ) { return std::make_pair( times_time_iterator< Stepper , System , State , TimeIterator >( stepper , system , x , t_start , t_end , dt ) , times_time_iterator< Stepper , System , State , TimeIterator >( stepper , system , x ) ); } /** * \class times_time_iterator * * \brief ODE Iterator with given evaluation points. The value type of this iterator is a std::pair containing state and time. * * Implements an iterator representing the solution of an ODE from *t_start * to *t_end evaluated at time points given by the sequence t_start to t_end. * t_start and t_end are iterators representing a sequence of time points * where the solution of the ODE should be evaluated. * After each iteration the iterator dereferences to a pair with the state * and the time at the next evaluation point *t_start++ until t_end is reached. * This iterator can be used with Steppers, ControlledSteppers and * DenseOutputSteppers and it always makes use of the all the given steppers * capabilities. A for_each over such an iterator range behaves similar to * the integrate_times routine. * * times_time_iterator is a model of single-pass iterator. * * The value type of this iterator is a pair of state and time type. * * \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. * \tparam State The state type of the ODE. * \tparam TimeIterator The iterator type for the sequence of time points. */ /** * \fn make_times_time_iterator_begin( Stepper stepper , System system , State &x , TimeIterator t_start , TimeIterator t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function for times_time_iterator. Constructs a begin iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration. * \param t_start Begin iterator of the sequence of evaluation time points. * \param t_end End iterator of the sequence of evaluation time points. * \param dt The initial time step. * \returns The times_time iterator. */ /** * \fn make_times_time_iterator_end( Stepper stepper , System system , State &x ) * \brief Factory function for times_time_iterator. Constructs an end iterator. * * \tparam TimesIterator The iterator type of the time sequence, must be specifically provided. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration. * \returns The times_time iterator. * * This function needs the TimeIterator type specifically defined as a * template parameter. */ /** * \fn make_times_time_range( Stepper stepper , System system , State &x , TimeIterator t_start , TimeIterator t_end , typename traits::time_type< Stepper >::type dt ) * * \brief Factory function to construct a single pass range of times_time iterators. A range is here a pair * of times_iterator. * * \param stepper The stepper to use during the iteration. * \param system The system function (ODE) to solve. * \param x The initial state. const_step_iterator store a reference of s and changes its value during the iteration. * \param t_start Begin iterator of the sequence of evaluation time points. * \param t_end End iterator of the sequence of evaluation time points. * \param dt The initial time step. * \returns The times_time iterator range. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_TIME_ITERATOR_HPP_INCLUDED PK 䄟[��� � algebra/range_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/range_algebra.hpp [begin_description] Default algebra, which works with the most state types, like vector< double >, boost::array< double >, boost::range. Internally is uses boost::range to obtain the begin and end iterator of the according sequence. [end_description] Copyright 2010-2013 Karsten Ahnert Copyright 2010-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_ALGEBRA_RANGE_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_RANGE_ALGEBRA_HPP_INCLUDED #include <boost/range.hpp> #include <boost/mpl/size_t.hpp> #include <boost/numeric/odeint/algebra/detail/macros.hpp> #include <boost/numeric/odeint/algebra/detail/for_each.hpp> #include <boost/numeric/odeint/algebra/detail/norm_inf.hpp> #include <boost/numeric/odeint/algebra/norm_result_type.hpp> namespace boost { namespace numeric { namespace odeint { struct range_algebra { template< class S1 , class Op > static void for_each1( S1 &s1 , Op op ) { detail::for_each1( boost::begin( s1 ) , boost::end( s1 ) , op ); } template< class S1 , class S2 , class Op > static void for_each2( S1 &s1 , S2 &s2 , Op op ) { detail::for_each2( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , op ); } template< class S1 , class S2 , class S3 , class Op > static void for_each3( S1 &s1 , S2 &s2 , S3 &s3 , Op op ) { detail::for_each3( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class Op > static void for_each4( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) { detail::for_each4( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each5( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) { detail::for_each5( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each6( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) { detail::for_each6( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class Op > static void for_each7( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) { detail::for_each7( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class Op > static void for_each8( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) { detail::for_each8( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class Op > static void for_each9( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) { detail::for_each9( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class Op > static void for_each10( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) { detail::for_each10( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each11( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) { detail::for_each11( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each12( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) { detail::for_each12( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each13( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) { detail::for_each13( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , boost::begin( s13 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each14( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) { detail::for_each14( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , boost::begin( s13 ) , boost::begin( s14 ) , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class S15 , class Op > static void for_each15( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , S15 &s15 , Op op ) { detail::for_each15( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , boost::begin( s13 ) , boost::begin( s14 ) , boost::begin( s15 ) , op ); } template< typename S > static typename norm_result_type<S>::type norm_inf( const S &s ) { return detail::norm_inf( boost::begin( s ) , boost::end( s ) , static_cast< typename norm_result_type<S>::type >( 0 ) ); } }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_RANGE_ALGEBRA_HPP_INCLUDED PK 䄟[X�l��, �, algebra/fusion_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/fusion_algebra.hpp [begin_description] Algebra for boost::fusion sequences. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-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_ALGEBRA_FUSION_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_HPP_INCLUDED #include <algorithm> #include <boost/numeric/odeint/config.hpp> #include <boost/fusion/container/vector.hpp> #include <boost/fusion/algorithm/iteration/for_each.hpp> #include <boost/fusion/view/zip_view.hpp> #include <boost/fusion/functional/generation/make_fused.hpp> #include <boost/fusion/algorithm/iteration/accumulate.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { template< class Value > struct fusion_maximum { template< class Fac1 , class Fac2 > Value operator()( Fac1 t1 , const Fac2 t2 ) const { using std::abs; Value a1 = abs( get_unit_value( t1 ) ) , a2 = abs( get_unit_value( t2 ) ); return ( a1 < a2 ) ? a2 : a1 ; } typedef Value result_type; }; } /* specialize this if the fundamental numeric type in your fusion sequence is * anything else but double (most likely not) */ template< typename Sequence > struct fusion_traits { typedef double value_type; }; struct fusion_algebra { template< class S1 , class Op > static void for_each1( S1 &s1 , Op op ) { boost::fusion::for_each( s1 , op ); }; template< class S1 , class S2 , class Op > static void for_each2( S1 &s1 , S2 &s2 , Op op ) { typedef boost::fusion::vector< S1& , S2& > Sequences; Sequences sequences( s1 , s2 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class Op > static void for_each3( S1 &s1 , S2 &s2 , S3 &s3 , Op op ) { typedef boost::fusion::vector< S1& , S2& , S3& > Sequences; Sequences sequences( s1 , s2 , s3 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class Op > static void for_each4( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) { typedef boost::fusion::vector< S1& , S2& , S3& , S4& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each5( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) { typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each6( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) { typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class Op > static void for_each7( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) { typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class Op > static void for_each8( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) { BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 8 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" ); typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class Op > static void for_each9( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) { BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 9 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" ); typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class Op > static void for_each10( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) { BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 10 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" ); typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each11( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) { BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 11 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" ); BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 11 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" ); typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each12( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) { BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 12 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" ); BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 12 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" ); typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& , S12& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each13( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) { BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 13 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" ); BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 13 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" ); typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& , S12& , S13& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each14( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) { BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 14 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" ); BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 14 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" ); typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& , S12& , S13& , S14& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 , s14 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class S15 , class Op > static void for_each15( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , S15 &s15 , Op op ) { BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 15 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" ); BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 15 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" ); typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& , S12& , S13& , S14& , S15& > Sequences; Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 , s14 , s15 ); boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) ); } template< class S > static typename fusion_traits< S >::value_type norm_inf( const S &s ) { typedef typename fusion_traits< S >::value_type value_type; return boost::fusion::accumulate( s , static_cast<value_type>(0) , detail::fusion_maximum<value_type>() ); } }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_HPP_INCLUDED PK 䄟[�b��\ �\ algebra/default_operations.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/default_operations.hpp [begin_description] Default operations. They work with the default numerical types, like float, double, complex< double> ... [end_description] Copyright 2010-2012 Karsten Ahnert Copyright 2010-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_ALGEBRA_DEFAULT_OPERATIONS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_DEFAULT_OPERATIONS_HPP_INCLUDED #include <algorithm> #include <boost/config.hpp> #include <boost/array.hpp> #include <boost/numeric/odeint/util/unit_helper.hpp> namespace boost { namespace numeric { namespace odeint { /* * Notes: * * * the results structs are needed in order to work with fusion_algebra */ struct default_operations { template< class Fac1 = double > struct scale { const Fac1 m_alpha1; scale( Fac1 alpha1 ) : m_alpha1( alpha1 ) { } template< class T1 > void operator()( T1 &t1 ) const { t1 *= m_alpha1; } typedef void result_type; }; template< class Fac1 = double > struct scale_sum1 { const Fac1 m_alpha1; scale_sum1( Fac1 alpha1 ) : m_alpha1( alpha1 ) { } template< class T1 , class T2 > void operator()( T1 &t1 , const T2 &t2 ) const { t1 = m_alpha1 * t2; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 > struct scale_sum2 { const Fac1 m_alpha1; const Fac2 m_alpha2; scale_sum2( Fac1 alpha1 , Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { } template< class T1 , class T2 , class T3 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3) const { t1 = m_alpha1 * t2 + m_alpha2 * t3; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 > struct scale_sum3 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; scale_sum3( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) { } template< class T1 , class T2 , class T3 , class T4 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 ) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 > struct scale_sum4 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; scale_sum4( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 > struct scale_sum5 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; scale_sum5( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 > struct scale_sum6 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; scale_sum6( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ){ } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 ,const T7 &t7) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 > struct scale_sum7 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; const Fac7 m_alpha7; scale_sum7( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 ) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 > struct scale_sum8 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; const Fac7 m_alpha7; const Fac8 m_alpha8; scale_sum8( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 ) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 > struct scale_sum9 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; const Fac7 m_alpha7; const Fac8 m_alpha8; const Fac9 m_alpha9; scale_sum9( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 ) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 > struct scale_sum10 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; const Fac7 m_alpha7; const Fac8 m_alpha8; const Fac9 m_alpha9; const Fac10 m_alpha10; scale_sum10( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 , Fac10 alpha10 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 ) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 , class Fac11 = Fac10 > struct scale_sum11 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; const Fac7 m_alpha7; const Fac8 m_alpha8; const Fac9 m_alpha9; const Fac10 m_alpha10; const Fac11 m_alpha11; scale_sum11( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 , Fac10 alpha10 , Fac11 alpha11 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) , m_alpha11( alpha11 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 , const T12 &t12 ) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11 + m_alpha11 * t12; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 , class Fac11 = Fac10 , class Fac12 = Fac11 > struct scale_sum12 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; const Fac7 m_alpha7; const Fac8 m_alpha8; const Fac9 m_alpha9; const Fac10 m_alpha10; const Fac11 m_alpha11; const Fac12 m_alpha12; scale_sum12( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 , Fac10 alpha10 , Fac11 alpha11 , Fac12 alpha12 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) , m_alpha11( alpha11 ) , m_alpha12( alpha12 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 , const T12 &t12 , const T13 &t13 ) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11 + m_alpha11 * t12 + m_alpha12 * t13; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 , class Fac11 = Fac10 , class Fac12 = Fac11 , class Fac13 = Fac12 > struct scale_sum13 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; const Fac7 m_alpha7; const Fac8 m_alpha8; const Fac9 m_alpha9; const Fac10 m_alpha10; const Fac11 m_alpha11; const Fac12 m_alpha12; const Fac13 m_alpha13; scale_sum13( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 , Fac10 alpha10 , Fac11 alpha11 , Fac12 alpha12 , Fac13 alpha13 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) , m_alpha11( alpha11 ) , m_alpha12( alpha12 ) , m_alpha13( alpha13 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 , const T12 &t12 , const T13 &t13 , const T14 &t14 ) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11 + m_alpha11 * t12 + m_alpha12 * t13 + m_alpha13 * t14; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 , class Fac11 = Fac10 , class Fac12 = Fac11 , class Fac13 = Fac12 , class Fac14 = Fac13 > struct scale_sum14 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; const Fac7 m_alpha7; const Fac8 m_alpha8; const Fac9 m_alpha9; const Fac10 m_alpha10; const Fac11 m_alpha11; const Fac12 m_alpha12; const Fac13 m_alpha13; const Fac14 m_alpha14; scale_sum14( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 , Fac10 alpha10 , Fac11 alpha11 , Fac12 alpha12 , Fac13 alpha13 , Fac14 alpha14 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) , m_alpha11( alpha11 ) , m_alpha12( alpha12 ) , m_alpha13( alpha13 ) , m_alpha14( alpha14 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 , const T12 &t12 , const T13 &t13 , const T14 &t14 , const T15 &t15 ) const { t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11 + m_alpha11 * t12 + m_alpha12 * t13 + m_alpha13 * t14 + m_alpha14 * t15; } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 > struct scale_sum_swap2 { const Fac1 m_alpha1; const Fac2 m_alpha2; scale_sum_swap2( Fac1 alpha1 , Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { } template< class T1 , class T2 , class T3 > void operator()( T1 &t1 , T2 &t2 , const T3 &t3) const { const T1 tmp( t1 ); t1 = m_alpha1 * t2 + m_alpha2 * t3; t2 = tmp; } typedef void result_type; }; /* * for usage in for_each2 * * Works with boost::units by eliminating the unit */ template< class Fac1 = double > struct rel_error { const Fac1 m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt; rel_error( Fac1 eps_abs , Fac1 eps_rel , Fac1 a_x , Fac1 a_dxdt ) : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt ) { } template< class T1 , class T2 , class T3 > void operator()( T3 &t3 , const T1 &t1 , const T2 &t2 ) const { using std::abs; set_unit_value( t3 , abs( get_unit_value( t3 ) ) / ( m_eps_abs + m_eps_rel * ( m_a_x * abs( get_unit_value( t1 ) ) + m_a_dxdt * abs( get_unit_value( t2 ) ) ) ) ); } typedef void result_type; }; /* * for usage in for_each3 * * used in the controller for the rosenbrock4 method * * Works with boost::units by eliminating the unit */ template< class Fac1 = double > struct default_rel_error { const Fac1 m_eps_abs , m_eps_rel ; default_rel_error( Fac1 eps_abs , Fac1 eps_rel ) : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) { } /* * xerr = xerr / ( eps_abs + eps_rel * max( x , x_old ) ) */ template< class T1 , class T2 , class T3 > void operator()( T3 &t3 , const T1 &t1 , const T2 &t2 ) const { BOOST_USING_STD_MAX(); using std::abs; Fac1 x1 = abs( get_unit_value( t1 ) ) , x2 = abs( get_unit_value( t2 ) ); set_unit_value( t3 , abs( get_unit_value( t3 ) ) / ( m_eps_abs + m_eps_rel * max BOOST_PREVENT_MACRO_SUBSTITUTION ( x1 , x2 ) ) ); } typedef void result_type; }; /* * for usage in reduce */ template< class Value > struct maximum { template< class Fac1 , class Fac2 > Value operator()( Fac1 t1 , const Fac2 t2 ) const { using std::abs; Value a1 = abs( get_unit_value( t1 ) ) , a2 = abs( get_unit_value( t2 ) ); return ( a1 < a2 ) ? a2 : a1 ; } typedef Value result_type; }; template< class Fac1 = double > struct rel_error_max { const Fac1 m_eps_abs , m_eps_rel; rel_error_max( Fac1 eps_abs , Fac1 eps_rel ) : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) { } template< class Res , class T1 , class T2 , class T3 > Res operator()( Res r , const T1 &x_old , const T2 &x , const T3 &x_err ) { BOOST_USING_STD_MAX(); using std::abs; Res tmp = abs( get_unit_value( x_err ) ) / ( m_eps_abs + m_eps_rel * max BOOST_PREVENT_MACRO_SUBSTITUTION ( abs( x_old ) , abs( x ) ) ); return max BOOST_PREVENT_MACRO_SUBSTITUTION ( r , tmp ); } }; template< class Fac1 = double > struct rel_error_max2 { const Fac1 m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt; rel_error_max2( Fac1 eps_abs , Fac1 eps_rel , Fac1 a_x , Fac1 a_dxdt ) : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt ) { } template< class Res , class T1 , class T2 , class T3 , class T4 > Res operator()( Res r , const T1 &x_old , const T2 &/*x*/ , const T3 &dxdt_old , const T4 &x_err ) { BOOST_USING_STD_MAX(); using std::abs; Res tmp = abs( get_unit_value( x_err ) ) / ( m_eps_abs + m_eps_rel * ( m_a_x * abs( get_unit_value( x_old ) ) + m_a_dxdt * abs( get_unit_value( dxdt_old ) ) ) ); return max BOOST_PREVENT_MACRO_SUBSTITUTION ( r , tmp ); } }; template< class Fac1 = double > struct rel_error_l2 { const Fac1 m_eps_abs , m_eps_rel; rel_error_l2( Fac1 eps_abs , Fac1 eps_rel ) : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) { } template< class Res , class T1 , class T2 , class T3 > Res operator()( Res r , const T1 &x_old , const T2 &x , const T3 &x_err ) { BOOST_USING_STD_MAX(); using std::abs; Res tmp = abs( get_unit_value( x_err ) ) / ( m_eps_abs + m_eps_rel * max BOOST_PREVENT_MACRO_SUBSTITUTION ( abs( x_old ) , abs( x ) ) ); return r + tmp * tmp; } }; template< class Fac1 = double > struct rel_error_l2_2 { const Fac1 m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt; rel_error_l2_2( Fac1 eps_abs , Fac1 eps_rel , Fac1 a_x , Fac1 a_dxdt ) : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt ) { } template< class Res , class T1 , class T2 , class T3 , class T4 > Res operator()( Res r , const T1 &x_old , const T2 &/*x*/ , const T3 &dxdt_old , const T4 &x_err ) { using std::abs; Res tmp = abs( get_unit_value( x_err ) ) / ( m_eps_abs + m_eps_rel * ( m_a_x * abs( get_unit_value( x_old ) ) + m_a_dxdt * abs( get_unit_value( dxdt_old ) ) ) ); return r + tmp * tmp; } }; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_DEFAULT_OPERATIONS_HPP_INCLUDED PK 䄟[x�!�� � algebra/algebra_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/algebra_dispatcher.hpp [begin_description] Algebra dispatcher to automatically chose suitable algebra. [end_description] Copyright 2013 Karsten Ahnert Copyright 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_ALGEBRA_ALGEBRA_DISPATCHER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_ALGEBRA_DISPATCHER_HPP_INCLUDED #include <boost/numeric/odeint/config.hpp> #include <complex> #include <boost/type_traits/is_floating_point.hpp> #include <boost/numeric/ublas/vector.hpp> #include <boost/numeric/ublas/matrix.hpp> #include <boost/numeric/odeint/algebra/range_algebra.hpp> #include <boost/numeric/odeint/algebra/array_algebra.hpp> #include <boost/numeric/odeint/algebra/vector_space_algebra.hpp> #include <boost/array.hpp> namespace boost { namespace numeric { namespace odeint { template< class StateType , class Enabler = void > struct algebra_dispatcher_sfinae { // range_algebra is the standard algebra typedef range_algebra algebra_type; }; template< class StateType > struct algebra_dispatcher : algebra_dispatcher_sfinae< StateType > { }; // specialize for array template< class T , size_t N > struct algebra_dispatcher< boost::array< T , N > > { typedef array_algebra algebra_type; }; //specialize for some integral types template< typename T > struct algebra_dispatcher_sfinae< T , typename boost::enable_if< typename boost::is_floating_point< T >::type >::type > { typedef vector_space_algebra algebra_type; }; template< typename T > struct algebra_dispatcher< std::complex<T> > { typedef vector_space_algebra algebra_type; }; ///* think about that again.... // specialize for ublas vector and matrix types template< class T , class A > struct algebra_dispatcher< boost::numeric::ublas::vector< T , A > > { typedef vector_space_algebra algebra_type; }; template< class T , class L , class A > struct algebra_dispatcher< boost::numeric::ublas::matrix< T , L , A > > { typedef vector_space_algebra algebra_type; }; //*/ } } } #ifdef BOOST_NUMERIC_ODEINT_CXX11 // c++11 mode: specialization for std::array if available #include <array> namespace boost { namespace numeric { namespace odeint { // specialize for std::array template< class T , size_t N > struct algebra_dispatcher< std::array< T , N > > { typedef array_algebra algebra_type; }; } } } #endif #endif PK 䄟[Yc��� � algebra/multi_array_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/multi_array_algebra.hpp [begin_description] tba. [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_ALGEBRA_MULTI_ARRAY_ALGEBRA_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_ALGEBRA_MULTI_ARRAY_ALGEBRA_HPP_DEFINED #include <boost/multi_array.hpp> #include <boost/numeric/odeint/algebra/detail/for_each.hpp> #include <boost/numeric/odeint/algebra/detail/norm_inf.hpp> #include <boost/numeric/odeint/algebra/norm_result_type.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> namespace boost { namespace numeric { namespace odeint { // not ready struct multi_array_algebra { template< class S1 , class Op > static void for_each1( S1 &s1 , Op op ) { detail::for_each1( s1.data() , s1.data() + s1.num_elements() , op ); } template< class S1 , class S2 , class Op > static void for_each2( S1 &s1 , S2 &s2 , Op op ) { detail::for_each2( s1.data() , s1.data() + s1.num_elements() , s2.data() , op ); } template< class S1 , class S2 , class S3 , class Op > static void for_each3( S1 &s1 , S2 &s2 , S3 &s3 , Op op ) { detail::for_each3( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class Op > static void for_each4( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) { detail::for_each4( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each5( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) { detail::for_each5( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each6( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) { detail::for_each6( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class Op > static void for_each7( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) { detail::for_each7( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class Op > static void for_each8( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) { detail::for_each8( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class Op > static void for_each9( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) { detail::for_each9( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class Op > static void for_each10( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) { detail::for_each10( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each11( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) { detail::for_each11( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each12( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) { detail::for_each12( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , s12.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each13( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) { detail::for_each13( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , s12.data() , s13.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each14( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) { detail::for_each14( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , s12.data() , s13.data() , s14.data() , op ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class S15 , class Op > static void for_each15( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , S15 &s15 , Op op ) { detail::for_each15( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , s12.data() , s13.data() , s14.data() , s15.data() , op ); } template< typename S > static typename norm_result_type<S>::type norm_inf( const S &s ) { return detail::norm_inf( s.data() , s.data() + s.num_elements() , static_cast< typename norm_result_type<S>::type >( 0 ) ); } }; template< class T , size_t N > struct algebra_dispatcher< boost::multi_array< T , N > > { typedef multi_array_algebra algebra_type; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_MULTI_ARRAY_ALGEBRA_HPP_DEFINED PK 䄟[�y| 5 5 algebra/norm_result_type.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/norm_result_type.hpp [begin_description] Calculates the type of the norm_inf operation for container types [end_description] Copyright 2013 Karsten Ahnert Copyright 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_ALGEBRA_NORM_RESULT_TYPE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_NORM_RESULT_TYPE_HPP_INCLUDED #include <boost/numeric/odeint/algebra/detail/extract_value_type.hpp> namespace boost { namespace numeric { namespace odeint { template< typename S , typename Enabler = void > struct norm_result_type { typedef typename detail::extract_value_type< S >::type type; }; } } } #endif PK 䄟[=�m�n n algebra/detail/macros.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/detail/macros.hpp [begin_description] Some macros for type checking. [end_description] Copyright 2010-2012 Karsten Ahnert Copyright 2010 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_ALGEBRA_DETAIL_MACROS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_MACROS_HPP_INCLUDED //type traits aren't working with nvcc #ifndef __CUDACC__ #include <boost/type_traits.hpp> #include <boost/static_assert.hpp> #define BOOST_ODEINT_CHECK_CONTAINER_TYPE( Type1 , Type2 ) \ BOOST_STATIC_ASSERT(( boost::is_same< typename boost::remove_const< Type1 >::type , Type2 >::value )) #else //empty macro for nvcc #define BOOST_ODEINT_CHECK_CONTAINER_TYPE( Type1 , Type2 ) #endif // __CUDACC__ /* #define BOOST_ODEINT_CHECK_OPERATION_ARITY( Operation , Arity ) \ BOOST_STATIC_ASSERT(( boost::function_traits< Operation >::arity == Arity )) */ #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_MACROS_HPP_INCLUDED PK 䄟[�w��N N % algebra/detail/extract_value_type.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/detail/extract_value_type.hpp [begin_description] Extract true value type from complex types (eg. std::complex) [end_description] Copyright 2013 Karsten Ahnert Copyright 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_ALGEBRA_DETAIL_EXTRACT_VALUE_TYPE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_EXTRACT_VALUE_TYPE_HPP_INCLUDED #include <boost/utility.hpp> #include <boost/mpl/has_xxx.hpp> BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type) namespace boost { namespace numeric { namespace odeint { namespace detail { template< typename S , typename Enabler = void > struct extract_value_type {}; // as long as value_types are defined we go down the value_type chain // e.g. returning S::value_type::value_type::value_type template< typename S > struct extract_value_type<S , typename boost::disable_if< has_value_type<S> >::type > { // no value_type defined, return S typedef S type; }; template< typename S > struct extract_value_type< S , typename boost::enable_if< has_value_type<S> >::type > { // go down the value_type typedef typename extract_value_type< typename S::value_type >::type type; }; } } } } #endif PK 䄟[���O% O% algebra/detail/for_each.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/detail/for_each.hpp [begin_description] Default for_each implementations. [end_description] Copyright 2010-2012 Karsten Ahnert Copyright 2011 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_ALGEBRA_DETAIL_FOR_EACH_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_FOR_EACH_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { namespace detail { template< class Iterator1 , class Operation > inline void for_each1( Iterator1 first1 , Iterator1 last1 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ ); } template< class Iterator1 , class Iterator2 , class Operation > inline void for_each2( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Operation > inline void for_each3( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Operation > inline void for_each4( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Operation > inline void for_each5( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Operation > inline void for_each6( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Operation > inline void for_each7( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Operation > inline void for_each8( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Operation > inline void for_each9( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 , Iterator9 first9 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Operation > inline void for_each10( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 , Iterator9 first9 , Iterator10 first10 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Operation > inline void for_each11( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 , Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Iterator12 , class Operation > inline void for_each12( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 , Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Iterator12 first12 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ , *first12++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Iterator12 , class Iterator13 , class Operation > inline void for_each13( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 , Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Iterator12 first12 , Iterator13 first13 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ , *first12++ , *first13++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Iterator12 , class Iterator13 , class Iterator14 , class Operation > inline void for_each14( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 , Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Iterator12 first12 , Iterator13 first13 , Iterator14 first14 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ , *first12++ , *first13++ , *first14++ ); } template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Iterator12 , class Iterator13 , class Iterator14 , class Iterator15 , class Operation > inline void for_each15( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 , Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Iterator12 first12 , Iterator13 first13 , Iterator14 first14 , Iterator15 first15 , Operation op ) { for( ; first1 != last1 ; ) op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ , *first12++ , *first13++ , *first14++ , *first15++ ); } } // detail } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_FOR_EACH_HPP_INCLUDED PK 䄟[d{ώ� � algebra/detail/norm_inf.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/detail/norm_inf.hpp [begin_description] Default reduce implementation. [end_description] Copyright 2013 Karsten Ahnert Copyright 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_ALGEBRA_DETAIL_NORM_INF_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_NORM_INF_HPP_INCLUDED #include <cmath> namespace boost { namespace numeric { namespace odeint { namespace detail { template< typename Value , class Iterator1 > inline Value norm_inf( Iterator1 first1 , Iterator1 last1 , Value init ) { using std::max; using std::abs; for( ; first1 != last1 ; ) init = max( init , abs( *first1++ ) ); return init; } } // detail } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_NORM_INF_HPP_INCLUDED PK 䄟[�hHA^* ^* algebra/array_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/array_algebra.hpp [begin_description] Algebra for Arrays. Highly specialized for odeint. Const arguments are introduce to work with odeint. The Array algebra can be used for Array structures with two template parameters: Array<T, N> [end_description] Copyright 2011-2013 Mario Mulansky Copyright 2011-2012 Karsten Ahnert 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_ALGEBRA_ARRAY_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_ARRAY_ALGEBRA_HPP_INCLUDED #include <algorithm> #include <boost/array.hpp> #include <boost/numeric/odeint/algebra/norm_result_type.hpp> namespace boost { namespace numeric { namespace odeint { struct array_algebra { //template< typename T , size_t dim , class Op > template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each1( Array< T, dim > &s1, Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each2( Array< T, dim > &s1, const Array< T, dim > &s2, Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each3( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] ); } /* different const signature - required for the scale_sum_swap2 operation */ template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each3( Array< T , dim > &s1 , Array< T , dim > &s2 , const Array< T , dim > &s3 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each4( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each5( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each6( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each7( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , const Array< T , dim > &s7 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each8( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , const Array< T , dim > &s7 , const Array< T , dim > &s8 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each9( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , const Array< T , dim > &s7 , const Array< T , dim > &s8 , const Array< T , dim > &s9 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each10( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , const Array< T , dim > &s7 , const Array< T , dim > &s8 , const Array< T , dim > &s9 , const Array< T , dim > &s10 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each11( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , const Array< T , dim > &s7 , const Array< T , dim > &s8 , const Array< T , dim > &s9 , const Array< T , dim > &s10 , const Array< T , dim > &s11 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each12( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , const Array< T , dim > &s7 , const Array< T , dim > &s8 , const Array< T , dim > &s9 , const Array< T , dim > &s10 , const Array< T , dim > &s11 , const Array< T , dim > &s12 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] , s12[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each13( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , const Array< T , dim > &s7 , const Array< T , dim > &s8 , const Array< T , dim > &s9 , const Array< T , dim > &s10 , const Array< T , dim > &s11 , const Array< T , dim > &s12 , const Array< T , dim > &s13 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] , s12[i] , s13[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each14( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , const Array< T , dim > &s7 , const Array< T , dim > &s8 , const Array< T , dim > &s9 , const Array< T , dim > &s10 , const Array< T , dim > &s11 , const Array< T , dim > &s12 , const Array< T , dim > &s13 , const Array< T , dim > &s14 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] , s12[i] , s13[i] , s14[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim, class Op > static void for_each15( Array< T , dim > &s1 , const Array< T , dim > &s2 , const Array< T , dim > &s3 , const Array< T , dim > &s4 , const Array< T , dim > &s5 , const Array< T , dim > &s6 , const Array< T , dim > &s7 , const Array< T , dim > &s8 , const Array< T , dim > &s9 , const Array< T , dim > &s10 , const Array< T , dim > &s11 , const Array< T , dim > &s12 , const Array< T , dim > &s13 , const Array< T , dim > &s14 , const Array< T , dim > &s15 , Op op ) { for( size_t i=0 ; i<dim ; ++i ) op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] , s12[i] , s13[i] , s14[i] , s15[i] ); } template < template < typename, size_t > class Array, typename T, size_t dim> static typename norm_result_type< Array< T , dim > >::type norm_inf( const Array< T , dim > &s ) { BOOST_USING_STD_MAX(); using std::abs; typedef typename norm_result_type< Array< T , dim > >::type result_type; result_type init = static_cast< result_type >( 0 ); for( size_t i=0 ; i<dim ; ++i ) init = max BOOST_PREVENT_MACRO_SUBSTITUTION ( init , static_cast< result_type >(abs(s[i])) ); return init; } }; } } } #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_ARRAY_ALGEBRA_HPP_INCLUDED PK 䄟[��£� � % algebra/fusion_algebra_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp [begin_description] tba. [end_description] Copyright 2013 Karsten Ahnert Copyright 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_ALGEBRA_FUSION_ALGEBRA_DISPATCHER_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_DISPATCHER_HPP_DEFINED #include <boost/numeric/odeint/algebra/fusion_algebra.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/utility/enable_if.hpp> #include <boost/fusion/include/is_sequence.hpp> namespace boost { namespace numeric { namespace odeint { // specialization for fusion sequences template< class FusionSequence > struct algebra_dispatcher_sfinae< FusionSequence , typename boost::enable_if< typename boost::fusion::traits::is_sequence< FusionSequence >::type >::type > { typedef fusion_algebra algebra_type; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_DISPATCHER_HPP_DEFINED PK 䄟[%y�� � algebra/vector_space_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/vector_space_algebra.hpp [begin_description] An algebra for types which have vector space semantics, hence types on which the operators +,-,* are well defined. [end_description] Copyright 2010-2012 Karsten Ahnert Copyright 2010-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_ALGEBRA_VECTOR_SPACE_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_VECTOR_SPACE_ALGEBRA_HPP_INCLUDED #include <complex> #include <boost/type_traits/remove_reference.hpp> namespace boost { namespace numeric { namespace odeint { /* * This class template has to be overload in order to call vector_space_algebra::norm_inf */ template< class State, class Enabler = void > struct vector_space_norm_inf; /* * Example: instantiation for sole doubles and complex */ template<> struct vector_space_norm_inf< double > { typedef double result_type; double operator()( double x ) const { using std::abs; return abs(x); } }; template<> struct vector_space_norm_inf< float > { typedef float result_type; result_type operator()( float x ) const { using std::abs; return abs(x); } }; template< typename T > struct vector_space_norm_inf< std::complex<T> > { typedef T result_type; result_type operator()( std::complex<T> x ) const { using std::abs; return abs( x ); } }; struct vector_space_algebra { template< class S1 , class Op > static void for_each1( S1 &s1 , Op op ) { // ToDo : build checks, that the +-*/ operators are well defined op( s1 ); } template< class S1 , class S2 , class Op > static void for_each2( S1 &s1 , S2 &s2 , Op op ) { op( s1 , s2 ); } template< class S1 , class S2 , class S3 , class Op > static void for_each3( S1 &s1 , S2 &s2 , S3 &s3 , Op op ) { op( s1 , s2 , s3 ); } template< class S1 , class S2 , class S3 , class S4 , class Op > static void for_each4( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) { op( s1 , s2 , s3 , s4 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each5( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) { op( s1 , s2 , s3 , s4 , s5 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each6( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class Op > static void for_each7( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 , s7 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class Op > static void for_each8( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class Op > static void for_each9( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class Op > static void for_each10( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each11( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each12( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each13( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each14( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 , s14 ); } template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class S15 , class Op > static void for_each15( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , S15 &s15 , Op op ) { op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 , s14 , s15 ); } template< class S > static typename boost::numeric::odeint::vector_space_norm_inf< S >::result_type norm_inf( const S &s ) { boost::numeric::odeint::vector_space_norm_inf< S > n; return n( s ); } }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_ALGEBRA_VECTOR_SPACE_ALGEBRA_HPP_INCLUDED PK 䄟[�_ � � ! algebra/operations_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/algebra/operations_dispatcher.hpp [begin_description] Operations dispatcher to automatically chose suitable operations. [end_description] Copyright 2013 Karsten Ahnert Copyright 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_ALGEBRA_OPERATIONS_DISPATCHER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_ALGEBRA_OPERATIONS_DISPATCHER_HPP_INCLUDED #include <boost/numeric/odeint/algebra/default_operations.hpp> namespace boost { namespace numeric { namespace odeint { template< class StateType , class Enabler = void > struct operations_dispatcher_sfinae { typedef default_operations operations_type; }; template< class StateType > struct operations_dispatcher : operations_dispatcher_sfinae< StateType > {}; // no further specializations required } } } #endif PK 䄟[/g��C C integrate/integrate_n_steps.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate_n_steps.hpp [begin_description] Integration of n steps with constant time size. Adaptive and dense-output methods are fully supported. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-2015 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_INTEGRATE_N_STEPS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED #include <boost/type_traits/is_same.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/integrate/null_observer.hpp> #include <boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp> #include <boost/numeric/odeint/integrate/check_adapter.hpp> namespace boost { namespace numeric { namespace odeint { /* * Integrates n steps * * the two overloads are needed in order to solve the forwarding problem */ template< class Stepper , class System , class State , class Time , class Observer , class StepOverflowChecker > Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer , StepOverflowChecker checker ) { // unwrap references typedef typename odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename odeint::unwrap_reference< Observer >::type observer_type; typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type; typedef typename stepper_type::stepper_category stepper_category; return detail::integrate_n_steps( checked_stepper<stepper_type, checker_type>(stepper, checker), system , start_state , start_time , dt , num_of_steps , checked_observer<observer_type, checker_type>(observer, checker), stepper_category() ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time , class Observer , class StepOverflowChecker > Time integrate_n_steps( Stepper stepper , System system , const State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer , StepOverflowChecker checker ) { typedef typename odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename odeint::unwrap_reference< Observer >::type observer_type; typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type; typedef typename stepper_type::stepper_category stepper_category; return detail::integrate_n_steps( checked_stepper<stepper_type, checker_type>(stepper, checker), system , start_state , start_time , dt , num_of_steps , checked_observer<observer_type, checker_type>(observer, checker), stepper_category() ); } /** * \brief The same function as above, but without checker. */ template< class Stepper , class System , class State , class Time , class Observer > Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer ) { typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category; return detail::integrate_n_steps( stepper , system , start_state , start_time , dt , num_of_steps , observer , stepper_category() ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time , class Observer > Time integrate_n_steps( Stepper stepper , System system , const State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer ) { typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category; return detail::integrate_n_steps( stepper , system , start_state , start_time , dt , num_of_steps , observer , stepper_category() ); } /** * \brief The same function as above, but without observer calls. */ template< class Stepper , class System , class State , class Time > Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps ) { return integrate_n_steps(stepper, system, start_state, start_time, dt, num_of_steps, null_observer()); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time > Time integrate_n_steps( Stepper stepper , System system , const State &start_state , Time start_time , Time dt , size_t num_of_steps ) { return integrate_n_steps(stepper, system, start_state, start_time, dt, num_of_steps, null_observer()); } /************* DOXYGEN *************/ /** * \fn Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer ) * \brief Integrates the ODE with constant step size. * * This function is similar to integrate_const. The observer is called at * equidistant time intervals t0 + n*dt. * If the Stepper is a normal stepper without step size control, dt is also * used for the numerical scheme. If a ControlledStepper is provided, the * algorithm might reduce the step size to meet the error bounds, but it is * ensured that the observer is always called at equidistant time points * t0 + n*dt. If a DenseOutputStepper is used, the step size also may vary * and the dense output is used to call the observer at equidistant time * points. The final integration time is always t0 + num_of_steps*dt. * If a max_step_checker is provided as StepOverflowChecker, a * no_progress_errror is thrown if too many steps (default: 500) are * performed without progress, i.e. in between observer calls. If no * checker is provided, no such overflow check is performed. * * \param stepper The stepper to be used for numerical integration. * \param system Function/Functor defining the rhs of the ODE. * \param start_state The initial condition x0. * \param start_time The initial time t0. * \param dt The time step between observer calls, _not_ necessarily the * time step of the integration. * \param num_of_steps Number of steps to be performed * \param observer Function/Functor called at equidistant time intervals. * \param checker [optional] Functor to check for step count overflows, if no * checker is provided, no exception is thrown. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED PK 䄟[�a-_ _ ! integrate/observer_collection.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/observer_collection.hpp [begin_description] Collection of observers, which are all called during the evolution of the ODE. [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED #include <vector> #include <boost/function.hpp> namespace boost { namespace numeric { namespace odeint { template< class State , class Time > class observer_collection { public: typedef boost::function< void( const State& , const Time& ) > observer_type; typedef std::vector< observer_type > collection_type; void operator()( const State& x , Time t ) { for( size_t i=0 ; i<m_observers.size() ; ++i ) m_observers[i]( x , t ); } collection_type& observers( void ) { return m_observers; } const collection_type& observers( void ) const { return m_observers; } private: collection_type m_observers; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED PK 䄟[��p�� � integrate/check_adapter.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/check_adapter.hpp [begin_description] Adapters to add checking facility to stepper and observer [end_description] Copyright 2015 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_CHECK_ADAPTER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_CHECK_ADAPTER_HPP_INCLUDED #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> namespace boost { namespace numeric { namespace odeint { template<class Stepper, class Checker, class StepperCategory = typename base_tag<typename Stepper::stepper_category>::type> class checked_stepper; /** * \brief Adapter to combine basic stepper and checker. */ template<class Stepper, class Checker> class checked_stepper<Stepper, Checker, stepper_tag> { public: typedef Stepper stepper_type; typedef Checker checker_type; // forward stepper typedefs typedef typename stepper_type::state_type state_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::time_type time_type; private: stepper_type &m_stepper; checker_type &m_checker; public: /** * \brief Construct the checked_stepper. */ checked_stepper(stepper_type &stepper, checker_type &checker) : m_stepper(stepper), m_checker(checker) { } /** * \brief forward of the do_step method */ template<class System, class StateInOut> void do_step(System system, StateInOut &state, const time_type t, const time_type dt) { // do the step m_stepper.do_step(system, state, t, dt); // call the checker m_checker(); } }; /** * \brief Adapter to combine controlled stepper and checker. */ template<class ControlledStepper, class Checker> class checked_stepper<ControlledStepper, Checker, controlled_stepper_tag> { public: typedef ControlledStepper stepper_type; typedef Checker checker_type; // forward stepper typedefs typedef typename stepper_type::state_type state_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::time_type time_type; private: stepper_type &m_stepper; checker_type &m_checker; public: /** * \brief Construct the checked_stepper. */ checked_stepper(stepper_type &stepper, checker_type &checker) : m_stepper(stepper), m_checker(checker) { } /** * \brief forward of the do_step method */ template< class System , class StateInOut > controlled_step_result try_step( System system , StateInOut &state , time_type &t , time_type &dt ) { // do the step if( m_stepper.try_step(system, state, t, dt) == success ) { // call the checker if step was successful m_checker(); return success; } else { // step failed -> return fail return fail; } } }; /** * \brief Adapter to combine dense out stepper and checker. */ template<class DenseOutStepper, class Checker> class checked_stepper<DenseOutStepper, Checker, dense_output_stepper_tag> { public: typedef DenseOutStepper stepper_type; typedef Checker checker_type; // forward stepper typedefs typedef typename stepper_type::state_type state_type; typedef typename stepper_type::value_type value_type; typedef typename stepper_type::deriv_type deriv_type; typedef typename stepper_type::time_type time_type; private: stepper_type &m_stepper; checker_type &m_checker; public: /** * \brief Construct the checked_stepper. */ checked_stepper(stepper_type &stepper, checker_type &checker) : m_stepper(stepper), m_checker(checker) { } template< class System > std::pair< time_type , time_type > do_step( System system ) { m_checker(); return m_stepper.do_step(system); } /* provide the remaining dense out stepper interface */ template< class StateType > void initialize( const StateType &x0 , time_type t0 , time_type dt0 ) { m_stepper.initialize(x0, t0, dt0); } template< class StateOut > void calc_state( time_type t , StateOut &x ) const { m_stepper.calc_state(t, x); } template< class StateOut > void calc_state( time_type t , const StateOut &x ) const { m_stepper.calc_state(t, x); } const state_type& current_state( void ) const { return m_stepper.current_state(); } time_type current_time( void ) const { return m_stepper.current_time(); } const state_type& previous_state( void ) const { return m_stepper.previous_state(); } time_type previous_time( void ) const { return m_stepper.previous_time(); } time_type current_time_step( void ) const { return m_stepper.current_time_step(); } }; /** * \brief Adapter to combine observer and checker. */ template<class Observer, class Checker> class checked_observer { public: typedef Observer observer_type; typedef Checker checker_type; private: observer_type &m_observer; checker_type &m_checker; public: checked_observer(observer_type &observer, checker_type &checker) : m_observer(observer), m_checker(checker) {} template< class State , class Time > void operator()(const State& state, Time t) const { // call the observer m_observer(state, t); // reset the checker m_checker.reset(); } }; } // namespace odeint } // namespace numeric } // namespace boost #endifPK 䄟[� \u# u# integrate/integrate_times.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate_times.hpp [begin_description] Integration of ODEs with observation at user defined points [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-2015 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_INTEGRATE_TIMES_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED #include <boost/type_traits/is_same.hpp> #include <boost/range.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/integrate/null_observer.hpp> #include <boost/numeric/odeint/integrate/check_adapter.hpp> #include <boost/numeric/odeint/integrate/detail/integrate_times.hpp> namespace boost { namespace numeric { namespace odeint { /* * \brief Integrates while calling the observer at the time points given by sequence [times_start, time_end) * the two overloads are needed in order to solve the forwarding problem */ template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer , class StepOverflowChecker > size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer , StepOverflowChecker checker ) { // unwrap references typedef typename odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename odeint::unwrap_reference< Observer >::type observer_type; typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type; typedef typename stepper_type::stepper_category stepper_category; // pass on checked stepper and observer // checked_stepper/observer use references internally, so passing by value is fine return detail::integrate_times( checked_stepper<stepper_type, checker_type>(stepper, checker) , system , start_state , times_start , times_end , dt , checked_observer<observer_type, checker_type>(observer, checker), stepper_category() ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer , class StepOverflowChecker > size_t integrate_times( Stepper stepper , System system , const State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer , StepOverflowChecker checker ) { typedef typename odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename odeint::unwrap_reference< Observer >::type observer_type; typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type; typedef typename stepper_type::stepper_category stepper_category; stepper_type &st = stepper; observer_type &obs = observer; checker_type &chk = checker; return detail::integrate_times( checked_stepper<stepper_type, checker_type>(stepper, checker) , system , start_state , times_start , times_end , dt , checked_observer<observer_type, checker_type>(observer, checker), stepper_category() ); } /** * \brief The same function as above, but with the observation times given as range. */ template< class Stepper , class System , class State , class TimeRange , class Time , class Observer , class StepOverflowChecker > size_t integrate_times( Stepper stepper , System system , State &start_state , const TimeRange × , Time dt , Observer observer , StepOverflowChecker checker ) { return integrate_times( stepper , system , start_state , boost::begin( times ) , boost::end( times ) , dt , observer , checker ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class TimeRange , class Time , class Observer , class StepOverflowChecker > size_t integrate_times( Stepper stepper , System system , const State &start_state , const TimeRange × , Time dt , Observer observer , StepOverflowChecker checker ) { return integrate_times( stepper , system , start_state , boost::begin( times ) , boost::end( times ) , dt , observer , checker ); } /* * The same functions as above, but without a StepOverflowChecker */ template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; // simply don't use checked_* adapters return detail::integrate_times( stepper , system , start_state , times_start , times_end , dt , observer , stepper_category() ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , const State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; return detail::integrate_times( stepper , system , start_state , times_start , times_end , dt , observer , stepper_category() ); } /** * \brief The same function as above, but with the observation times given as range. */ template< class Stepper , class System , class State , class TimeRange , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , State &start_state , const TimeRange × , Time dt , Observer observer ) { return integrate_times( stepper , system , start_state , boost::begin( times ) , boost::end( times ) , dt , observer ); } /** * \brief Solves the forwarding problem, can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class TimeRange , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , const State &start_state , const TimeRange × , Time dt , Observer observer ) { return integrate_times( stepper , system , start_state , boost::begin( times ) , boost::end( times ) , dt , observer); } /********* DOXYGEN ***********/ /** * \fn size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer ) * \brief Integrates the ODE with observer calls at given time points. * * Integrates the ODE given by system using the given stepper. This function * does observer calls at the subsequent time points given by the range * times_start, times_end. If the stepper has not step size control, the * step size might be reduced occasionally to ensure observer calls exactly * at the time points from the given sequence. If the stepper is a * ControlledStepper, the step size is adjusted to meet the error bounds, * but also might be reduced occasionally to ensure correct observer calls. * If a DenseOutputStepper is provided, the dense output functionality is * used to call the observer at the given times. The end time of the * integration is always *(end_time-1). * If a max_step_checker is provided as StepOverflowChecker, a * no_progress_error is thrown if too many steps (default: 500) are * performed without progress, i.e. in between observer calls. If no * checker is provided, no such overflow check is performed. * * \param stepper The stepper to be used for numerical integration. * \param system Function/Functor defining the rhs of the ODE. * \param start_state The initial condition x0. * \param times_start Iterator to the start time * \param times_end Iterator to the end time * \param dt The time step between observer calls, _not_ necessarily the * time step of the integration. * \param observer Function/Functor called at equidistant time intervals. * \param checker [optional] Functor to check for step count overflows, if no * checker is provided, no exception is thrown. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED PK 䄟[rJ��= = integrate/null_observer.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/null_observer.hpp [begin_description] null_observer [end_description] Copyright 2011-2012 Karsten Ahnert Copyright 2011-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_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { struct null_observer { template< class State , class Time > void operator()( const State& /* x */ , Time /* t */ ) const { } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED PK 䄟[2�Qz� � & integrate/detail/integrate_n_steps.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp [begin_description] integrate steps implementation [end_description] Copyright 2012-2015 Mario Mulansky Copyright 2012 Christoph Koke Copyright 2012 Karsten Ahnert 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_INTEGRATE_N_STEPS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp> #include <boost/numeric/odeint/util/unit_helper.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { // forward declaration template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive_checked( Stepper stepper , System system , State &start_state , Time &start_time , Time end_time , Time &dt , Observer observer, controlled_stepper_tag ); /* basic version */ template< class Stepper , class System , class State , class Time , class Observer> Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer , stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; Time time = start_time; for( size_t step = 0; step < num_of_steps ; ++step ) { obs( start_state , time ); st.do_step( system , start_state , time , dt ); // direct computation of the time avoids error propagation happening when using time += dt // we need clumsy type analysis to get boost units working here time = start_time + static_cast< typename unit_value_type<Time>::type >( step+1 ) * dt; } obs( start_state , time ); return time; } /* controlled version */ template< class Stepper , class System , class State , class Time , class Observer > Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer , controlled_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; Time time = start_time; Time time_step = dt; for( size_t step = 0; step < num_of_steps ; ++step ) { obs( start_state , time ); // integrate_adaptive_checked uses the given checker to throw if an overflow occurs detail::integrate_adaptive(stepper, system, start_state, time, static_cast<Time>(time + time_step), dt, null_observer(), controlled_stepper_tag()); // direct computation of the time avoids error propagation happening when using time += dt // we need clumsy type analysis to get boost units working here time = start_time + static_cast< typename unit_value_type<Time>::type >(step+1) * time_step; } obs( start_state , time ); return time; } /* dense output version */ template< class Stepper , class System , class State , class Time , class Observer > Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer , dense_output_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; Time time = start_time; const Time end_time = start_time + static_cast< typename unit_value_type<Time>::type >(num_of_steps) * dt; st.initialize( start_state , time , dt ); size_t step = 0; while( step < num_of_steps ) { while( less_with_sign( time , st.current_time() , st.current_time_step() ) ) { st.calc_state( time , start_state ); obs( start_state , time ); ++step; // direct computation of the time avoids error propagation happening when using time += dt // we need clumsy type analysis to get boost units working here time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * dt; } // we have not reached the end, do another real step if( less_with_sign( static_cast<Time>(st.current_time()+st.current_time_step()) , end_time , st.current_time_step() ) ) { st.do_step( system ); } else if( less_with_sign( st.current_time() , end_time , st.current_time_step() ) ) { // do the last step ending exactly on the end point st.initialize( st.current_state() , st.current_time() , static_cast<Time>(end_time - st.current_time()) ); st.do_step( system ); } } // make sure we really end exactly where we should end while( st.current_time() < end_time ) { if( less_with_sign( end_time , static_cast<Time>(st.current_time()+st.current_time_step()) , st.current_time_step() ) ) st.initialize( st.current_state() , st.current_time() , static_cast<Time>(end_time - st.current_time()) ); st.do_step( system ); } // observation at final point obs( st.current_state() , end_time ); return time; } } } } } #endif /* BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED */ PK 䄟[ Au� � integrate/detail/functors.hppnu �[��� /* [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 PK 䄟[? I�# # $ integrate/detail/integrate_times.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/detail/integrate_times.hpp [begin_description] Default integrate times implementation. [end_description] Copyright 2011-2015 Mario Mulansky Copyright 2012 Karsten Ahnert 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_INTEGRATE_DETAIL_INTEGRATE_TIMES_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_TIMES_HPP_INCLUDED #include <stdexcept> #include <boost/config.hpp> #include <boost/throw_exception.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> #include <boost/numeric/odeint/integrate/max_step_checker.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { /* * integrate_times for simple stepper */ template<class Stepper, class System, class State, class TimeIterator, class Time, class Observer> size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator start_time , TimeIterator end_time , Time dt , Observer observer , stepper_tag ) { typedef typename odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename odeint::unwrap_reference< Observer >::type observer_type; stepper_type &st = stepper; observer_type &obs = observer; typedef typename unit_value_type<Time>::type time_type; size_t steps = 0; Time current_dt = dt; while( true ) { Time current_time = *start_time++; obs( start_state , current_time ); if( start_time == end_time ) break; while( less_with_sign( current_time , static_cast<time_type>(*start_time) , current_dt ) ) { current_dt = min_abs( dt , *start_time - current_time ); st.do_step( system , start_state , current_time , current_dt ); current_time += current_dt; steps++; } } return steps; } /* * integrate_times for controlled stepper */ template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator start_time , TimeIterator end_time , Time dt , Observer observer , controlled_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; typedef typename unit_value_type<Time>::type time_type; failed_step_checker fail_checker; // to throw a runtime_error if step size adjustment fails size_t steps = 0; while( true ) { Time current_time = *start_time++; obs( start_state , current_time ); if( start_time == end_time ) break; while( less_with_sign( current_time , static_cast<time_type>(*start_time) , dt ) ) { // adjust stepsize to end up exactly at the observation point Time current_dt = min_abs( dt , *start_time - current_time ); if( st.try_step( system , start_state , current_time , current_dt ) == success ) { ++steps; // successful step -> reset the fail counter, see #173 fail_checker.reset(); // continue with the original step size if dt was reduced due to observation dt = max_abs( dt , current_dt ); } else { fail_checker(); // check for possible overflow of failed steps in step size adjustment dt = current_dt; } } } return steps; } /* * integrate_times for dense output stepper */ template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer > size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator start_time , TimeIterator end_time , Time dt , Observer observer , dense_output_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; typedef typename unit_value_type<Time>::type time_type; if( start_time == end_time ) return 0; TimeIterator last_time_iterator = end_time; --last_time_iterator; Time last_time_point = static_cast<time_type>(*last_time_iterator); st.initialize( start_state , *start_time , dt ); obs( start_state , *start_time++ ); size_t count = 0; while( start_time != end_time ) { while( ( start_time != end_time ) && less_eq_with_sign( static_cast<time_type>(*start_time) , st.current_time() , st.current_time_step() ) ) { st.calc_state( *start_time , start_state ); obs( start_state , *start_time ); start_time++; } // we have not reached the end, do another real step if( less_eq_with_sign( st.current_time() + st.current_time_step() , last_time_point , st.current_time_step() ) ) { st.do_step( system ); ++count; } else if( start_time != end_time ) { // do the last step ending exactly on the end point st.initialize( st.current_state() , st.current_time() , last_time_point - st.current_time() ); st.do_step( system ); ++count; } } return count; } } // namespace detail } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED PK 䄟[���V� � ' integrate/detail/integrate_adaptive.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp [begin_description] Default Integrate adaptive implementation. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-2015 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_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED #include <stdexcept> #include <boost/throw_exception.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> #include <boost/numeric/odeint/integrate/max_step_checker.hpp> #include <boost/numeric/odeint/integrate/detail/integrate_const.hpp> #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/detail/less_with_sign.hpp> #include <iostream> namespace boost { namespace numeric { namespace odeint { namespace detail { // forward declaration template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , stepper_tag ); /* * integrate_adaptive for simple stepper is basically an integrate_const + some last step */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , stepper_tag ) { size_t steps = detail::integrate_const( stepper , system , start_state , start_time , end_time , dt , observer , stepper_tag() ); typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; Time end = start_time + dt*steps; if( less_with_sign( end , end_time , dt ) ) { //make a last step to end exactly at end_time st.do_step( system , start_state , end , end_time - end ); steps++; obs( start_state , end_time ); } return steps; } /* * integrate adaptive for controlled stepper */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time &start_time , Time end_time , Time &dt , Observer observer , controlled_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; failed_step_checker fail_checker; // to throw a runtime_error if step size adjustment fails size_t count = 0; while( less_with_sign( start_time , end_time , dt ) ) { obs( start_state , start_time ); if( less_with_sign( end_time , static_cast<Time>(start_time + dt) , dt ) ) { dt = end_time - start_time; } controlled_step_result res; do { res = st.try_step( system , start_state , start_time , dt ); fail_checker(); // check number of failed steps } while( res == fail ); fail_checker.reset(); // if we reach here, the step was successful -> reset fail checker ++count; } obs( start_state , start_time ); return count; } /* * integrate adaptive for dense output steppers * * step size control is used if the stepper supports it */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , dense_output_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; size_t count = 0; st.initialize( start_state , start_time , dt ); while( less_with_sign( st.current_time() , end_time , st.current_time_step() ) ) { while( less_eq_with_sign( static_cast<Time>(st.current_time() + st.current_time_step()) , end_time , st.current_time_step() ) ) { //make sure we don't go beyond the end_time obs( st.current_state() , st.current_time() ); st.do_step( system ); ++count; } // calculate time step to arrive exactly at end time st.initialize( st.current_state() , st.current_time() , static_cast<Time>(end_time - st.current_time()) ); } obs( st.current_state() , st.current_time() ); // overwrite start_state with the final point boost::numeric::odeint::copy( st.current_state() , start_state ); return count; } } // namespace detail } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED PK 䄟[2�� � $ integrate/detail/integrate_const.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/detail/integrate_const.hpp [begin_description] integrate const implementation [end_description] Copyright 2012-2015 Mario Mulansky Copyright 2012 Christoph Koke Copyright 2012 Karsten Ahnert 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_INTEGRATE_CONST_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_CONST_HPP_INCLUDED #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/util/unit_helper.hpp> #include <boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp> #include <boost/numeric/odeint/util/detail/less_with_sign.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { // forward declaration template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time &start_time , Time end_time , Time &dt , Observer observer , controlled_stepper_tag ); template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; Time time = start_time; int step = 0; // cast time+dt explicitely in case of expression templates (e.g. multiprecision) while( less_eq_with_sign( static_cast<Time>(time+dt) , end_time , dt ) ) { obs( start_state , time ); st.do_step( system , start_state , time , dt ); // direct computation of the time avoids error propagation happening when using time += dt // we need clumsy type analysis to get boost units working here ++step; time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * dt; } obs( start_state , time ); return step; } template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , controlled_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; Time time = start_time; const Time time_step = dt; int real_steps = 0; int step = 0; while( less_eq_with_sign( static_cast<Time>(time+time_step) , end_time , dt ) ) { obs( start_state , time ); // integrate_adaptive_checked uses the given checker to throw if an overflow occurs real_steps += detail::integrate_adaptive(stepper, system, start_state, time, static_cast<Time>(time + time_step), dt, null_observer(), controlled_stepper_tag()); // direct computation of the time avoids error propagation happening when using time += dt // we need clumsy type analysis to get boost units working here step++; time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * time_step; } obs( start_state , time ); return real_steps; } template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer , dense_output_stepper_tag ) { typename odeint::unwrap_reference< Observer >::type &obs = observer; typename odeint::unwrap_reference< Stepper >::type &st = stepper; Time time = start_time; st.initialize( start_state , time , dt ); obs( start_state , time ); time += dt; int obs_step( 1 ); int real_step( 0 ); while( less_eq_with_sign( static_cast<Time>(time+dt) , end_time , dt ) ) { while( less_eq_with_sign( time , st.current_time() , dt ) ) { st.calc_state( time , start_state ); obs( start_state , time ); ++obs_step; // direct computation of the time avoids error propagation happening when using time += dt // we need clumsy type analysis to get boost units working here time = start_time + static_cast< typename unit_value_type<Time>::type >(obs_step) * dt; } // we have not reached the end, do another real step if( less_with_sign( static_cast<Time>(st.current_time()+st.current_time_step()) , end_time , st.current_time_step() ) ) { while( less_eq_with_sign( st.current_time() , time , dt ) ) { st.do_step( system ); ++real_step; } } else if( less_with_sign( st.current_time() , end_time , st.current_time_step() ) ) { // do the last step ending exactly on the end point st.initialize( st.current_state() , st.current_time() , end_time - st.current_time() ); st.do_step( system ); ++real_step; } } // last observation, if we are still in observation interval // might happen due to finite precision problems when computing the the time if( less_eq_with_sign( time , end_time , dt ) ) { st.calc_state( time , start_state ); obs( start_state , time ); } return real_step; } } } } } #endif PK 䄟[�/ � � integrate/integrate_adaptive.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate_adaptive.hpp [begin_description] Adaptive integration of ODEs. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-2015 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_INTEGRATE_ADAPTIVE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED #include <boost/type_traits/is_same.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/integrate/null_observer.hpp> #include <boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp> namespace boost { namespace numeric { namespace odeint { /* * the two overloads are needed in order to solve the forwarding problem */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; return detail::integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , observer , stepper_category() ); /* * Suggestion for a new extendable version: * * integrator_adaptive< Stepper , System, State , Time , Observer , typename Stepper::stepper_category > integrator; * return integrator.run( stepper , system , start_state , start_time , end_time , dt , observer ); */ } /** * \brief Second version to solve the forwarding problem, * can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time , class Observer > size_t integrate_adaptive( Stepper stepper , System system , const State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) { typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category; return detail::integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , observer , stepper_category() ); } /** * \brief integrate_adaptive without an observer. */ template< class Stepper , class System , class State , class Time > size_t integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt ) { return integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , null_observer() ); } /** * \brief Second version to solve the forwarding problem, * can be called with Boost.Range as start_state. */ template< class Stepper , class System , class State , class Time > size_t integrate_adaptive( Stepper stepper , System system , const State &start_state , Time start_time , Time end_time , Time dt ) { return integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , null_observer() ); } /************* DOXYGEN ************/ /** * \fn integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) * \brief Integrates the ODE with adaptive step size. * * This function integrates the ODE given by system with the given stepper. * The observer is called after each step. If the stepper has no error * control, the step size remains constant and the observer is called at * equidistant time points t0+n*dt. If the stepper is a ControlledStepper, * the step size is adjusted and the observer is called in non-equidistant * intervals. * * \param stepper The stepper to be used for numerical integration. * \param system Function/Functor defining the rhs of the ODE. * \param start_state The initial condition x0. * \param start_time The initial time t0. * \param end_time The final integration time tend. * \param dt The time step between observer calls, _not_ necessarily the * time step of the integration. * \param observer Function/Functor called at equidistant time intervals. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED PK 䄟[��`�% % integrate/max_step_checker.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/max_step_checker.hpp [begin_description] Throws exception if too many steps are performed. [end_description] Copyright 2015 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_MAX_STEP_CHECKER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_MAX_STEP_CHECKER_HPP_INCLUDED #include <stdexcept> #include <cstdio> #include <boost/throw_exception.hpp> #include <boost/numeric/odeint/util/odeint_error.hpp> namespace boost { namespace numeric { namespace odeint { /** * \brief A class for performing overflow checks on the step count in integrate functions. * * Provide an instance of this class to integrate functions if you want to throw a runtime error if * too many steps are performed without progress during the integrate routine. */ class max_step_checker { public: protected: const int m_max_steps; int m_steps; public: /** * \brief Construct the max_step_checker. * max_steps is the maximal number of iterations allowed before runtime_error is thrown. */ max_step_checker(const int max_steps = 500) : m_max_steps(max_steps) { reset(); } /** * \brief Resets the max_step_checker by setting the internal counter to 0. */ void reset() { m_steps = 0; } /** * \brief Increases the counter and performs the iteration check */ void operator()(void) { if( m_steps++ >= m_max_steps ) { char error_msg[200]; std::sprintf(error_msg, "Max number of iterations exceeded (%d).", m_max_steps); BOOST_THROW_EXCEPTION( no_progress_error(error_msg) ); } } }; /** * \brief A class for performing overflow checks on the failed step count in step size adjustments. * * Used internally within the dense output stepper and integrate routines. */ class failed_step_checker : public max_step_checker { public: /** * \brief Construct the failed_step_checker. * max_steps is the maximal number of iterations allowed before runtime_error is thrown. */ failed_step_checker(const int max_steps = 500) : max_step_checker(max_steps) {} /** * \brief Increases the counter and performs the iteration check */ void operator()(void) { if( m_steps++ >= m_max_steps ) { char error_msg[200]; std::sprintf(error_msg, "Max number of iterations exceeded (%d). A new step size was not found.", m_max_steps); BOOST_THROW_EXCEPTION( step_adjustment_error(error_msg) ); } } }; } // namespace odeint } // namespace numeric } // namespace boost #endif PK 䄟[3?�' integrate/integrate.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate.hpp [begin_description] Convenience methods which choose the stepper for the current ODE. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-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_INTEGRATE_INTEGRATE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED #include <boost/utility/enable_if.hpp> #include <boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp> #include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp> #include <boost/numeric/odeint/integrate/null_observer.hpp> #include <boost/numeric/odeint/integrate/integrate_adaptive.hpp> // for has_value_type trait #include <boost/numeric/odeint/algebra/detail/extract_value_type.hpp> namespace boost { namespace numeric { namespace odeint { /* * ToDo : * * determine type of dxdt for units * */ template< class System , class State , class Time , class Observer > typename boost::enable_if< typename has_value_type<State>::type , size_t >::type integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) { typedef controlled_runge_kutta< runge_kutta_dopri5< State , typename State::value_type , State , Time > > stepper_type; return integrate_adaptive( stepper_type() , system , start_state , start_time , end_time , dt , observer ); } template< class Value , class System , class State , class Time , class Observer > size_t integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) { typedef controlled_runge_kutta< runge_kutta_dopri5< State , Value , State , Time > > stepper_type; return integrate_adaptive( stepper_type() , system , start_state , start_time , end_time , dt , observer ); } /* * the two overloads are needed in order to solve the forwarding problem */ template< class System , class State , class Time > size_t integrate( System system , State &start_state , Time start_time , Time end_time , Time dt ) { return integrate( system , start_state , start_time , end_time , dt , null_observer() ); } template< class Value , class System , class State , class Time > size_t integrate( System system , State &start_state , Time start_time , Time end_time , Time dt ) { return integrate< Value >( system , start_state , start_time , end_time , dt , null_observer() ); } /** * \fn integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer ) * \brief Integrates the ODE. * * Integrates the ODE given by system from start_time to end_time starting * with start_state as initial condition and dt as initial time step. * This function uses a dense output dopri5 stepper and performs an adaptive * integration with step size control, thus dt changes during the integration. * This method uses standard error bounds of 1E-6. * After each step, the observer is called. * * \attention A second version of this function template exists which explicitly * expects the value type as template parameter, i.e. integrate< double >( sys , x , t0 , t1 , dt , obs ); * * \param system The system function to solve, hence the r.h.s. of the * ordinary differential equation. * \param start_state The initial state. * \param start_time Start time of the integration. * \param end_time End time of the integration. * \param dt Initial step size, will be adjusted during the integration. * \param observer Observer that will be called after each time step. * \return The number of steps performed. */ /** * \fn integrate( System system , State &start_state , Time start_time , Time end_time , Time dt ) * \brief Integrates the ODE without observer calls. * * Integrates the ODE given by system from start_time to end_time starting * with start_state as initial condition and dt as initial time step. * This function uses a dense output dopri5 stepper and performs an adaptive * integration with step size control, thus dt changes during the integration. * This method uses standard error bounds of 1E-6. * No observer is called. * * \attention A second version of this function template exists which explicitly * expects the value type as template parameter, i.e. integrate< double >( sys , x , t0 , t1 , dt ); * * \param system The system function to solve, hence the r.h.s. of the * ordinary differential equation. * \param start_state The initial state. * \param start_time Start time of the integration. * \param end_time End time of the integration. * \param dt Initial step size, will be adjusted during the integration. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED PK 䄟[s��� � integrate/integrate_const.hppnu �[��� /* [auto_generated] boost/numeric/odeint/integrate/integrate_const.hpp [begin_description] Constant integration of ODEs, meaning that the state of the ODE is observed on constant time intervals. The routines makes full use of adaptive and dense-output methods. [end_description] Copyright 2011-2013 Karsten Ahnert Copyright 2011-2015 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_INTEGRATE_CONST_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED #include <boost/type_traits/is_same.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/integrate/null_observer.hpp> #include <boost/numeric/odeint/integrate/check_adapter.hpp> #include <boost/numeric/odeint/integrate/detail/integrate_const.hpp> #include <boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp> namespace boost { namespace numeric { namespace odeint { /* * Integrates with constant time step dt. */ template<class Stepper, class System, class State, class Time, class Observer, class StepOverflowChecker> size_t integrate_const( Stepper stepper, System system, State &start_state, Time start_time, Time end_time, Time dt, Observer observer, StepOverflowChecker checker ) { typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category; // we want to get as fast as possible to the end // no overflow checks needed if (boost::is_same<null_observer, Observer>::value) { return detail::integrate_adaptive( stepper, system, start_state, start_time, end_time, dt, observer, stepper_category()); } else { // unwrap references typedef typename odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename odeint::unwrap_reference< Observer >::type observer_type; typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type; return detail::integrate_const(checked_stepper<stepper_type, checker_type>(stepper, checker), system, start_state, start_time, end_time, dt, checked_observer<observer_type, checker_type>(observer, checker), stepper_category()); } } /** * \brief Second version to solve the forwarding problem, * can be called with Boost.Range as start_state. */ template<class Stepper, class System, class State, class Time, class Observer, class StepOverflowChecker > size_t integrate_const( Stepper stepper, System system, const State &start_state, Time start_time, Time end_time, Time dt, Observer observer, StepOverflowChecker checker ) { typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category; // we want to get as fast as possible to the end if (boost::is_same<null_observer, Observer>::value) { return detail::integrate_adaptive( stepper, system, start_state, start_time, end_time, dt, observer, stepper_category()); } else { typedef typename odeint::unwrap_reference< Stepper >::type stepper_type; typedef typename odeint::unwrap_reference< Observer >::type observer_type; typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type; return detail::integrate_const(checked_stepper<stepper_type, checker_type>(stepper, checker), system, start_state, start_time, end_time, dt, checked_observer<observer_type, checker_type>(observer, checker), stepper_category()); } } /** * \brief integrate_const without step overflow checker */ template<class Stepper, class System, class State, class Time, class Observer> size_t integrate_const( Stepper stepper, System system, State &start_state, Time start_time, Time end_time, Time dt, Observer observer) { typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category; return detail::integrate_const(stepper, system, start_state, start_time, end_time, dt, observer, stepper_category()); } /** * \brief Second version to solve the forwarding problem, * can be called with Boost.Range as start_state. */ template<class Stepper, class System, class State, class Time, class Observer> size_t integrate_const( Stepper stepper, System system, const State &start_state, Time start_time, Time end_time, Time dt, Observer observer ) { typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category; return detail::integrate_const(stepper, system, start_state, start_time, end_time, dt, observer, stepper_category()); } /** * \brief integrate_const without observer calls */ template<class Stepper, class System, class State, class Time> size_t integrate_const( Stepper stepper, System system, State &start_state, Time start_time, Time end_time, Time dt ) { return integrate_const(stepper, system, start_state, start_time, end_time, dt, null_observer()); } /** * \brief Second version to solve the forwarding problem, * can be called with Boost.Range as start_state. */ template<class Stepper, class System, class State, class Time> size_t integrate_const( Stepper stepper, System system, const State &start_state, Time start_time, Time end_time, Time dt ) { return integrate_const(stepper, system, start_state, start_time, end_time, dt, null_observer()); } /********* DOXYGEN *********/ /** * \fn integrate_const( Stepper stepper , System system , State &start_state , Time start_time , * Time end_time , Time dt , Observer observer , StepOverflowChecker checker ) * \brief Integrates the ODE with constant step size. * * Integrates the ODE defined by system using the given stepper. * This method ensures that the observer is called at constant intervals dt. * If the Stepper is a normal stepper without step size control, dt is also * used for the numerical scheme. If a ControlledStepper is provided, the * algorithm might reduce the step size to meet the error bounds, but it is * ensured that the observer is always called at equidistant time points * t0 + n*dt. If a DenseOutputStepper is used, the step size also may vary * and the dense output is used to call the observer at equidistant time * points. * If a max_step_checker is provided as StepOverflowChecker, a * no_progress_error is thrown if too many steps (default: 500) are performed * without progress, i.e. in between observer calls. If no checker is provided, * no such overflow check is performed. * * \param stepper The stepper to be used for numerical integration. * \param system Function/Functor defining the rhs of the ODE. * \param start_state The initial condition x0. * \param start_time The initial time t0. * \param end_time The final integration time tend. * \param dt The time step between observer calls, _not_ necessarily the * time step of the integration. * \param observer [optional] Function/Functor called at equidistant time intervals. * \param checker [optional] Functor to check for step count overflows, if no * checker is provided, no exception is thrown. * \return The number of steps performed. */ } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED PK 䄟[�/�� � + external/eigen/eigen_algebra_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp [begin_description] tba. [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_EXTERNAL_EIGEN_EIGEN_ALGEBRA_DISPATCHER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_ALGEBRA_DISPATCHER_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { template< class Derived > struct algebra_dispatcher_sfinae< Derived , typename boost::enable_if< typename boost::is_base_of< Eigen::MatrixBase< Derived > , Derived >::type >::type > { typedef vector_space_algebra algebra_type; }; template < class Derived > struct algebra_dispatcher_sfinae< Derived , typename boost::enable_if< typename boost::is_base_of< Eigen::ArrayBase< Derived > , Derived >::type >::type > { typedef vector_space_algebra algebra_type; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_ALGEBRA_DISPATCHER_HPP_INCLUDED PK 䄟[��IK� � external/eigen/eigen.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/eigen/eigen.hpp [begin_description] tba. [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_EXTERNAL_EIGEN_EIGEN_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_HPP_INCLUDED #include <boost/numeric/odeint/external/eigen/eigen_algebra.hpp> #include <boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp> #include <boost/numeric/odeint/external/eigen/eigen_resize.hpp> #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_HPP_INCLUDED PK 䄟[�G#5/ / external/eigen/eigen_resize.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/eigen/eigen_resize.hpp [begin_description] tba. [end_description] Copyright 2013 Ankur Sinha Copyright 2013 Karsten Ahnert 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_EXTERNAL_EIGEN_EIGEN_RESIZE_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_RESIZE_HPP_DEFINED #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/util/same_size.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_base_of.hpp> #include <Eigen/Dense> namespace boost { namespace numeric { namespace odeint { template< class Derived > struct is_resizeable_sfinae< Derived , typename boost::enable_if< typename boost::is_base_of< Eigen::MatrixBase< Derived > , Derived >::type >::type > { typedef boost::true_type type; const static bool value = type::value; }; template < class Derived > struct is_resizeable_sfinae< Derived , typename boost::enable_if< typename boost::is_base_of< Eigen::ArrayBase< Derived > , Derived >::type >::type > { typedef boost::true_type type; const static bool value = type::value; }; template< class Derived > struct same_size_impl_sfinae< Derived , Derived , typename boost::enable_if< typename boost::is_base_of< Eigen::MatrixBase< Derived > , Derived >::type >::type > { static bool same_size( const Eigen::MatrixBase< Derived > &m1 , const Eigen::MatrixBase< Derived > &m2 ) { return ( ( m1.innerSize () == m2.innerSize () ) && ( m1.outerSize() == m2.outerSize() ) ); } }; template< class Derived > struct same_size_impl_sfinae< Derived , Derived , typename boost::enable_if< typename boost::is_base_of< Eigen::ArrayBase< Derived > , Derived >::type >::type > { static bool same_size( const Eigen::ArrayBase< Derived > &v1 , const Eigen::ArrayBase< Derived > &v2 ) { return ( ( v1.innerSize () == v2.innerSize () ) && ( v1.outerSize() == v2.outerSize() ) ); } }; template< class Derived > struct resize_impl_sfinae< Derived , Derived , typename boost::enable_if< typename boost::is_base_of< Eigen::MatrixBase< Derived > , Derived >::type >::type > { static void resize( Eigen::MatrixBase< Derived > &m1 , const Eigen::MatrixBase< Derived > &m2 ) { m1.derived().resizeLike(m2); } }; template< class Derived > struct resize_impl_sfinae< Derived , Derived , typename boost::enable_if< typename boost::is_base_of< Eigen::ArrayBase< Derived > , Derived >::type >::type > { static void resize( Eigen::ArrayBase< Derived > &v1 , const Eigen::ArrayBase< Derived > &v2 ) { v1.derived().resizeLike(v2); } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_RESIZE_HPP_DEFINED PK 䄟[��B$� � external/eigen/eigen_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/eigen/eigen_algebra.hpp [begin_description] tba. [end_description] Copyright 2013 Christian Shelton Copyright 2013 Karsten Ahnert 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_EXTERNAL_EIGEN_EIGEN_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_ALGEBRA_HPP_INCLUDED #include <Eigen/Dense> #include <boost/numeric/odeint/algebra/vector_space_algebra.hpp> // Necessary routines for Eigen matrices to work with vector_space_algebra // from odeint // (that is, it lets odeint treat the eigen matrices correctly, knowing // how to add, multiply, compute the norm, etc) namespace Eigen { template<typename D> inline const typename Eigen::CwiseBinaryOp< internal::scalar_sum_op<typename internal::traits<D>::Scalar>, typename DenseBase<D>::ConstantReturnType, const D> operator+(const typename Eigen::MatrixBase<D> &m, const typename Eigen::internal::traits<D>::Scalar &s) { return CwiseBinaryOp< internal::scalar_sum_op<typename internal::traits<D>::Scalar>, typename DenseBase<D>::ConstantReturnType, const D>(DenseBase<D>::Constant(m.rows(), m.cols(), s), m.derived()); } template<typename D> inline const typename Eigen::CwiseBinaryOp< internal::scalar_sum_op<typename internal::traits<D>::Scalar>, typename DenseBase<D>::ConstantReturnType, const D> operator+(const typename Eigen::internal::traits<D>::Scalar &s, const typename Eigen::MatrixBase<D> &m) { return CwiseBinaryOp< internal::scalar_sum_op<typename internal::traits<D>::Scalar>, typename DenseBase<D>::ConstantReturnType, const D>(DenseBase<D>::Constant(m.rows(), m.cols(), s), m.derived()); } template<typename D1,typename D2> inline const typename Eigen::CwiseBinaryOp< typename Eigen::internal::scalar_quotient_op< typename Eigen::internal::traits<D1>::Scalar>, const D1, const D2> operator/(const Eigen::MatrixBase<D1> &x1, const Eigen::MatrixBase<D2> &x2) { return x1.cwiseQuotient(x2); } template< typename D > inline const typename Eigen::CwiseUnaryOp< typename Eigen::internal::scalar_abs_op< typename Eigen::internal::traits< D >::Scalar > , const D > abs( const Eigen::MatrixBase< D > &m ) { return m.cwiseAbs(); } } // end Eigen namespace namespace boost { namespace numeric { namespace odeint { template<typename B,int S1,int S2,int O, int M1, int M2> struct vector_space_norm_inf< Eigen::Matrix<B,S1,S2,O,M1,M2> > { typedef B result_type; result_type operator()( const Eigen::Matrix<B,S1,S2,O,M1,M2> &m ) const { return m.template lpNorm<Eigen::Infinity>(); } }; } } } // end boost::numeric::odeint namespace #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_ALGEBRA_HPP_INCLUDED PK 䄟[�H��� � 2 external/compute/compute_operations_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp [begin_description] operations_dispatcher specialization for Boost.Compute [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_EXTERNAL_COMPUTE_COMPUTE_OPERATIONS_DISPATCHER_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_OPERATIONS_DISPATCHER_HPP_DEFINED #include <boost/compute/container/vector.hpp> #include <boost/numeric/odeint/external/compute/compute_operations.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> namespace boost { namespace numeric { namespace odeint { // specialization for Boost.Compute vector template< class T , class A > struct operations_dispatcher< boost::compute::vector< T , A > > { typedef compute_operations operations_type; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_OPERATIONS_DISPATCHER_HPP_DEFINED PK 䄟[37�� � / external/compute/compute_algebra_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp [begin_description] algebra_dispatcher specialization for Boost.Compute [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_EXTERNAL_COMPUTE_COMPUTE_ALGEBRA_DISPATCHER_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_ALGEBRA_DISPATCHER_HPP_DEFINED #include <boost/compute/container/vector.hpp> #include <boost/numeric/odeint/external/compute/compute_algebra.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> namespace boost { namespace numeric { namespace odeint { // specialization for Boost.Compute vector template< class T , class A > struct algebra_dispatcher< boost::compute::vector< T , A > > { typedef compute_algebra algebra_type; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_ALGEBRA_DISPATCHER_HPP_DEFINED PK 䄟[ ��-" -" ' external/compute/compute_operations.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/compute/compute_operations.hpp [begin_description] Operations of Boost.Compute zipped iterators. Is the counterpart of the compute_algebra. [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_EXTERNAL_COMPUTE_COMPUTE_OPERATIONS_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_OPERATIONS_HPP_DEFINED #include <boost/preprocessor/repetition.hpp> #include <boost/compute.hpp> namespace boost { namespace numeric { namespace odeint { struct compute_operations { #define BOOST_ODEINT_COMPUTE_TEMPL_FAC(z, n, unused) \ , class Fac ## n = BOOST_PP_CAT(Fac, BOOST_PP_DEC(n)) #define BOOST_ODEINT_COMPUTE_MEMB_FAC(z, n, unused) \ const Fac ## n m_alpha ## n; #define BOOST_ODEINT_COMPUTE_PRM_FAC(z, n, unused) \ BOOST_PP_COMMA_IF(n) const Fac ## n alpha ## n #define BOOST_ODEINT_COMPUTE_INIT_FAC(z, n, unused) \ BOOST_PP_COMMA_IF(n) m_alpha ## n (alpha ## n) #define BOOST_ODEINT_COMPUTE_PRM_STATE(z, n, unused) \ BOOST_PP_COMMA_IF(n) StateType ## n &s ## n #define BOOST_ODEINT_COMPUTE_BEGIN_STATE(z, n, unused) \ BOOST_PP_COMMA_IF( BOOST_PP_DEC(n) ) s ## n.begin() #define BOOST_ODEINT_COMPUTE_END_STATE(z, n, unused) \ BOOST_PP_COMMA_IF( BOOST_PP_DEC(n) ) s ## n.end() #define BOOST_ODEINT_COMPUTE_LAMBDA(z, n, unused) \ BOOST_PP_EXPR_IF(n, +) m_alpha ## n * bc::lambda::get< n >(bc::_1) #define BOOST_ODEINT_COMPUTE_OPERATIONS(z, n, unused) \ template< \ class Fac0 = double \ BOOST_PP_REPEAT_FROM_TO(1, n, BOOST_ODEINT_COMPUTE_TEMPL_FAC, ~) \ > \ struct scale_sum ## n { \ BOOST_PP_REPEAT(n, BOOST_ODEINT_COMPUTE_MEMB_FAC, ~) \ scale_sum ## n( \ BOOST_PP_REPEAT(n, BOOST_ODEINT_COMPUTE_PRM_FAC, ~) \ ) \ : BOOST_PP_REPEAT(n, BOOST_ODEINT_COMPUTE_INIT_FAC, ~) \ { } \ template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), class StateType) > \ void operator()( \ BOOST_PP_REPEAT( \ BOOST_PP_INC(n), \ BOOST_ODEINT_COMPUTE_PRM_STATE, ~) \ ) const \ { \ namespace bc = boost::compute; \ bc::transform( \ bc::make_zip_iterator( \ boost::make_tuple( \ BOOST_PP_REPEAT_FROM_TO( \ 1, BOOST_PP_INC(n), \ BOOST_ODEINT_COMPUTE_BEGIN_STATE, ~) \ ) \ ), \ bc::make_zip_iterator( \ boost::make_tuple( \ BOOST_PP_REPEAT_FROM_TO( \ 1, BOOST_PP_INC(n), \ BOOST_ODEINT_COMPUTE_END_STATE, ~) \ ) \ ), \ s0.begin(), \ BOOST_PP_REPEAT(n, BOOST_ODEINT_COMPUTE_LAMBDA, ~) \ ); \ } \ }; BOOST_PP_REPEAT_FROM_TO(2, 8, BOOST_ODEINT_COMPUTE_OPERATIONS, ~) #undef BOOST_ODEINT_COMPUTE_TEMPL_FAC #undef BOOST_ODEINT_COMPUTE_MEMB_FAC #undef BOOST_ODEINT_COMPUTE_PRM_FAC #undef BOOST_ODEINT_COMPUTE_INIT_FAC #undef BOOST_ODEINT_COMPUTE_PRM_STATE #undef BOOST_ODEINT_COMPUTE_BEGIN_STATE #undef BOOST_ODEINT_COMPUTE_END_STATE #undef BOOST_ODEINT_COMPUTE_LAMBDA #undef BOOST_ODEINT_COMPUTE_OPERATIONS template<class Fac1 = double, class Fac2 = Fac1> struct scale_sum_swap2 { const Fac1 m_alpha1; const Fac2 m_alpha2; scale_sum_swap2(const Fac1 alpha1, const Fac2 alpha2) : m_alpha1(alpha1), m_alpha2(alpha2) { } template<class State0, class State1, class State2> void operator()(State0 &s0, State1 &s1, State2 &s2) const { namespace bc = boost::compute; bc::command_queue &queue = bc::system::default_queue(); const bc::context &context = queue.get_context(); const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( kernel void scale_sum_swap2( F1 a1, F2 a2, global T0 *x0, global T1 *x1, global T2 *x2, ) { uint i = get_global_id(0); T0 tmp = x0[i]; x0[i] = a1 * x1[i] + a2 * x2[i]; x1[i] = tmp; } ); std::stringstream options; options << " -DT0=" << bc::type_name<typename State0::value_type>() << " -DT1=" << bc::type_name<typename State1::value_type>() << " -DT2=" << bc::type_name<typename State2::value_type>() << " -DF1=" << bc::type_name<Fac1>() << " -DF2=" << bc::type_name<Fac2>(); bc::program program = bc::program::build_with_source(source, context, options.str()); bc::kernel kernel(program, "scale_sum_swap2"); kernel.set_arg(0, m_alpha1); kernel.set_arg(1, m_alpha2); kernel.set_arg(2, s0.get_buffer()); kernel.set_arg(3, s1.get_buffer()); kernel.set_arg(4, s2.get_buffer()); queue.enqueue_1d_range_kernel(kernel, 0, s0.size()); } }; template<class Fac1 = double> struct rel_error { const Fac1 m_eps_abs, m_eps_rel, m_a_x, m_a_dxdt; rel_error(const Fac1 eps_abs, const Fac1 eps_rel, const Fac1 a_x, const Fac1 a_dxdt) : m_eps_abs(eps_abs), m_eps_rel(eps_rel), m_a_x(a_x), m_a_dxdt(a_dxdt) { } template <class State0, class State1, class State2> void operator()(State0 &s0, State1 &s1, State2 &s2) const { namespace bc = boost::compute; using bc::_1; using bc::lambda::get; bc::for_each( bc::make_zip_iterator( boost::make_tuple( s0.begin(), s1.begin(), s2.begin() ) ), bc::make_zip_iterator( boost::make_tuple( s0.end(), s1.end(), s2.end() ) ), get<0>(_1) = abs( get<0>(_1) ) / (m_eps_abs + m_eps_rel * (m_a_x * abs(get<1>(_1) + m_a_dxdt * abs(get<2>(_1))))) ); } }; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_OPERATIONS_HPP_DEFINED PK 䄟[w(Z�� � external/compute/compute.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/compute/compute.hpp [begin_description] includes all headers required for using odeint with Boost.Compute [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_EXTERNAL_COMPUTE_COMPUTE_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_HPP_DEFINED #include <boost/numeric/odeint/external/compute/compute_algebra.hpp> #include <boost/numeric/odeint/external/compute/compute_operations.hpp> #include <boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp> #include <boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp> #include <boost/numeric/odeint/external/compute/compute_resize.hpp> #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_HPP_DEFINED PK 䄟[ ��R� � $ external/compute/compute_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/compute/compute_algebra.hpp [begin_description] An algebra for Boost.Compute vectors. [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_EXTERNAL_COMPUTE_COMPUTE_ALGEBRA_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_ALGEBRA_HPP_DEFINED #include <boost/preprocessor/repetition.hpp> #include <boost/compute.hpp> namespace boost { namespace numeric { namespace odeint { struct compute_algebra { #define BOOST_ODEINT_COMPUTE_STATE_PARAM(z, n, unused) \ StateType ## n &s ## n, #define BOOST_ODEINT_COMPUTE_ALGEBRA(z, n, unused) \ template< BOOST_PP_ENUM_PARAMS(n, class StateType), class Operation > \ static void for_each ## n( \ BOOST_PP_REPEAT(n, BOOST_ODEINT_COMPUTE_STATE_PARAM, ~) \ Operation op \ ) \ { \ op( BOOST_PP_ENUM_PARAMS(n, s) ); \ } BOOST_PP_REPEAT_FROM_TO(3, 9, BOOST_ODEINT_COMPUTE_ALGEBRA, ~) #undef BOOST_ODEINT_COMPUTE_ALGEBRA #undef BOOST_ODEINT_COMPUTE_STATE_PARAM template < class S > static typename S::value_type norm_inf( const S &s ) { typedef typename S::value_type value_type; BOOST_COMPUTE_FUNCTION(value_type, max_abs, (value_type, value_type), { return max(_1, fabs(_2)); }); return boost::compute::accumulate(s.begin(), s.end(), value_type(), max_abs); } }; } // odeint } // numeric } // boost #endif PK 䄟[�_;� � # external/compute/compute_resize.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/compute/compute_resize.hpp [begin_description] Enable resizing for Boost.Compute vector [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_EXTERNAL_COMPUTE_COMPUTE_RESIZE_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_RESIZE_HPP_DEFINED #include <boost/compute/container/vector.hpp> #include <boost/numeric/odeint/util/copy.hpp> namespace boost { namespace numeric { namespace odeint { template< class T, class A > struct is_resizeable< boost::compute::vector< T , A > > { struct type : public boost::true_type { }; const static bool value = type::value; }; template< class T, class A > struct same_size_impl< boost::compute::vector< T, A > , boost::compute::vector< T, A > > { static bool same_size( const boost::compute::vector< T, A > &x , const boost::compute::vector< T, A > &y ) { return x.size() == y.size(); } }; template< class T, class A > struct resize_impl< boost::compute::vector< T, A > , boost::compute::vector< T, A > > { static void resize( boost::compute::vector< T, A > &x , const boost::compute::vector< T, A > &y ) { x.resize( y.size() ); } }; template< class Container1, class T, class A > struct copy_impl< Container1 , boost::compute::vector< T, A > > { static void copy( const Container1 &from , boost::compute::vector< T, A > &to ) { boost::compute::copy( boost::begin( from ) , boost::end( from ) , boost::begin( to ) ); } }; template< class T, class A, class Container2 > struct copy_impl< boost::compute::vector< T, A > , Container2 > { static void copy( const boost::compute::vector< T, A > &from , Container2 &to ) { boost::compute::copy( boost::begin( from ) , boost::end( from ) , boost::begin( to ) ); } }; template< class T, class A > struct copy_impl< boost::compute::vector< T, A > , boost::compute::vector< T, A > > { static void copy( const boost::compute::vector< T, A > &from , boost::compute::vector< T, A > &to ) { boost::compute::copy( boost::begin( from ) , boost::end( from ) , boost::begin( to ) ); } }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_RESIZE_HPP_DEFINED PK 䄟[�ro�� � " external/thrust/thrust_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/thrust/thrust_algebra.hpp [begin_description] An algebra for thrusts device_vectors. [end_description] Copyright 2010-2013 Mario Mulansky Copyright 2010-2011 Karsten Ahnert Copyright 2013 Kyle Lutz 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_EXTERNAL_THRUST_THRUST_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_HPP_INCLUDED #include <thrust/device_vector.h> #include <thrust/for_each.h> #include <thrust/iterator/zip_iterator.h> #include <boost/range.hpp> namespace boost { namespace numeric { namespace odeint { namespace detail { // to use in thrust::reduce template< class Value > struct maximum { template< class Fac1 , class Fac2 > __host__ __device__ Value operator()( const Fac1 t1 , const Fac2 t2 ) const { return ( abs( t1 ) < abs( t2 ) ) ? t2 : t1 ; } typedef Value result_type; }; } /** ToDO extend until for_each14 for rk78 */ /* * The const versions are needed for boost.range to work, i.e. * it allows you to do * for_each1( make_pair( vec1.begin() , vec1.begin() + 10 ) , op ); */ struct thrust_algebra { template< class StateType , class Operation > static void for_each1( StateType &s , Operation op ) { thrust::for_each( boost::begin(s) , boost::end(s) , op ); } template< class StateType1 , class StateType2 , class Operation > static void for_each2( StateType1 &s1 , StateType2 &s2 , Operation op ) { thrust::for_each( thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) , boost::begin(s2) ) ) , thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) , boost::end(s2) ) ) , op); } template< class StateType1 , class StateType2 , class StateType3 , class Operation > static void for_each3( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , Operation op ) { thrust::for_each( thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) , boost::begin(s2) , boost::begin(s3) ) ) , thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) , boost::end(s2) , boost::end(s3) ) ) , op); } template< class StateType1 , class StateType2 , class StateType3 , class StateType4 , class Operation > static void for_each4( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 , Operation op ) { thrust::for_each( thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) , boost::begin(s2) , boost::begin(s3) , boost::begin(s4) ) ) , thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) , boost::end(s2) , boost::end(s3) , boost::end(s4) ) ) , op); } template< class StateType1 , class StateType2 , class StateType3 , class StateType4 , class StateType5 ,class Operation > static void for_each5( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 , StateType5 &s5 , Operation op ) { thrust::for_each( thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) , boost::begin(s2) , boost::begin(s3) , boost::begin(s4) , boost::begin(s5) ) ) , thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) , boost::end(s2) , boost::end(s3) , boost::end(s4) , boost::end(s5) ) ) , op); } template< class StateType1 , class StateType2 , class StateType3 , class StateType4 , class StateType5 , class StateType6 , class Operation > static void for_each6( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 , StateType5 &s5 , StateType6 &s6 , Operation op ) { thrust::for_each( thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) , boost::begin(s2) , boost::begin(s3) , boost::begin(s4) , boost::begin(s5) , boost::begin(s6) ) ) , thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) , boost::end(s2) , boost::end(s3) , boost::end(s4) , boost::end(s5) , boost::end(s6) ) ) , op); } template< class StateType1 , class StateType2 , class StateType3 , class StateType4 , class StateType5 , class StateType6 , class StateType7 , class Operation > static void for_each7( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 , StateType5 &s5 , StateType6 &s6 , StateType7 &s7 , Operation op ) { thrust::for_each( thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) , boost::begin(s2) , boost::begin(s3) , boost::begin(s4) , boost::begin(s5) , boost::begin(s6) , boost::begin(s7) ) ) , thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) , boost::end(s2) , boost::end(s3) , boost::end(s4) , boost::end(s5) , boost::end(s6) , boost::end(s7) ) ) , op); } template< class StateType1 , class StateType2 , class StateType3 , class StateType4 , class StateType5 , class StateType6 , class StateType7 , class StateType8 , class Operation > static void for_each8( StateType1 &s1 , StateType2 &s2 , StateType3 &s3 , StateType4 &s4 , StateType5 &s5 , StateType6 &s6 , StateType7 &s7 , StateType8 &s8 , Operation op ) { thrust::for_each( thrust::make_zip_iterator( thrust::make_tuple( boost::begin(s1) , boost::begin(s2) , boost::begin(s3) , boost::begin(s4) , boost::begin(s5) , boost::begin(s6) , boost::begin(s7) , boost::begin(s8) ) ) , thrust::make_zip_iterator( thrust::make_tuple( boost::end(s1) , boost::end(s2) , boost::end(s3) , boost::end(s4) , boost::end(s5) , boost::end(s6) , boost::end(s7) , boost::end(s8) ) ) , op); } template< class S > static typename S::value_type norm_inf( const S &s ) { typedef typename S::value_type value_type; return thrust::reduce( boost::begin( s ) , boost::end( s ) , static_cast<value_type>(0) , detail::maximum<value_type>() ); } }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_HPP_INCLUDED PK 䄟[��[� � external/thrust/thrust.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/thrust/thrust.hpp [begin_description] includes all headers required for using odeint with thrust [end_description] Copyright 2013 Karsten Ahnert Copyright 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_EXTERNAL_THRUST_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_HPP_DEFINED #include <boost/numeric/odeint/external/thrust/thrust_algebra.hpp> #include <boost/numeric/odeint/external/thrust/thrust_operations.hpp> #include <boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp> #include <boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp> #include <boost/numeric/odeint/external/thrust/thrust_resize.hpp> #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_HPP_DEFINED PK 䄟[ ( % external/thrust/thrust_operations.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/thrust/thrust_operations.hpp [begin_description] Operations of thrust zipped iterators. Is the counterpart of the thrust_algebra. [end_description] Copyright 2010-2013 Mario Mulansky Copyright 2010-2012 Karsten Ahnert 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_EXTERNAL_THRUST_THRUST_OPERATIONS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_HPP_INCLUDED namespace boost { namespace numeric { namespace odeint { #include <thrust/tuple.h> #include <thrust/iterator/zip_iterator.h> /**ToDo extend to scale_sum13 for rk78 */ struct thrust_operations { template< class Fac1 = double , class Fac2 = Fac1 > struct scale_sum2 { const Fac1 m_alpha1; const Fac2 m_alpha2; scale_sum2( const Fac1 alpha1 , const Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { } template< class Tuple > __host__ __device__ void operator()( Tuple t ) const { thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) + m_alpha2 * thrust::get<2>(t); } }; template< class Fac1 = double , class Fac2 = Fac1 > struct scale_sum_swap2 { const Fac1 m_alpha1; const Fac2 m_alpha2; scale_sum_swap2( const Fac1 alpha1 , const Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { } template< class Tuple > __host__ __device__ void operator()( Tuple t ) const { typename thrust::tuple_element<0,Tuple>::type tmp = thrust::get<0>(t); thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) + m_alpha2 * thrust::get<2>(t); thrust::get<1>(t) = tmp; } }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 > struct scale_sum3 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; scale_sum3( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) { } template< class Tuple > __host__ __device__ void operator()( Tuple t ) const { thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) + m_alpha2 * thrust::get<2>(t) + m_alpha3 * thrust::get<3>(t); } }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 > struct scale_sum4 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; scale_sum4( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ){ } template< class Tuple > __host__ __device__ void operator()( Tuple t ) const { thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) + m_alpha2 * thrust::get<2>(t) + m_alpha3 * thrust::get<3>(t) + m_alpha4 * thrust::get<4>(t); } }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 > struct scale_sum5 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; scale_sum5( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 , const Fac5 alpha5 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { } template< class Tuple > __host__ __device__ void operator()( Tuple t ) const { thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) + m_alpha2 * thrust::get<2>(t) + m_alpha3 * thrust::get<3>(t) + m_alpha4 * thrust::get<4>(t) + m_alpha5 * thrust::get<5>(t); } }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 > struct scale_sum6 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; scale_sum6( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 , const Fac5 alpha5 , const Fac6 alpha6 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) { } template< class Tuple > __host__ __device__ void operator()( Tuple t ) const { thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) + m_alpha2 * thrust::get<2>(t) + m_alpha3 * thrust::get<3>(t) + m_alpha4 * thrust::get<4>(t) + m_alpha5 * thrust::get<5>(t) + m_alpha6 * thrust::get<6>(t); } }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 > struct scale_sum7 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; const Fac6 m_alpha6; const Fac7 m_alpha7; scale_sum7( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 , const Fac5 alpha5 , const Fac6 alpha6 , const Fac7 alpha7 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) { } template< class Tuple > __host__ __device__ void operator()( Tuple t ) const { thrust::get<0>(t) = m_alpha1 * thrust::get<1>(t) + m_alpha2 * thrust::get<2>(t) + m_alpha3 * thrust::get<3>(t) + m_alpha4 * thrust::get<4>(t) + m_alpha5 * thrust::get<5>(t) + m_alpha6 * thrust::get<6>(t) + m_alpha7 * thrust::get<7>(t) ; } }; template< class Fac1 = double > struct rel_error { const Fac1 m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt; rel_error( const Fac1 eps_abs , const Fac1 eps_rel , const Fac1 a_x , const Fac1 a_dxdt ) : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt ) { } template< class Tuple > __host__ __device__ void operator()( Tuple t ) const { using std::abs; thrust::get< 0 >( t ) = abs( thrust::get< 0 >( t ) ) / ( m_eps_abs + m_eps_rel * ( m_a_x * abs( thrust::get< 1 >( t ) + m_a_dxdt * abs( thrust::get< 2 >( t ) ) ) ) ); } typedef void result_type; }; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_HPP_INCLUDED PK 䄟[�F#:) ) - external/thrust/thrust_algebra_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp [begin_description] algebra_dispatcher specialization for thrust [end_description] Copyright 2013 Karsten Ahnert Copyright 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_EXTERNAL_THRUST_THRUST_ALGEBRA_DISPATCHER_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_DISPATCHER_HPP_DEFINED #include <thrust/host_vector.h> #include <thrust/device_vector.h> #include <boost/numeric/odeint/external/thrust/thrust_algebra.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> // specializations for the standard thrust containers namespace boost { namespace numeric { namespace odeint { // specialization for thrust host_vector template< class T , class A > struct algebra_dispatcher< thrust::host_vector< T , A > > { typedef thrust_algebra algebra_type; }; // specialization for thrust device_vector template< class T , class A > struct algebra_dispatcher< thrust::device_vector< T , A > > { typedef thrust_algebra algebra_type; }; } // namespace odeint } // namespace numeric } // namespace boost // add support for thrust backend vectors, if available #include <thrust/version.h> #if THRUST_VERSION >= 100600 // specialization for thrust cpp vector #include <thrust/system/cpp/vector.h> namespace boost { namespace numeric { namespace odeint { template< class T , class A > struct algebra_dispatcher< thrust::cpp::vector< T , A > > { typedef thrust_algebra algebra_type; }; } } } // specialization for thrust omp vector #ifdef _OPENMP #include <thrust/system/omp/vector.h> namespace boost { namespace numeric { namespace odeint { template< class T , class A > struct algebra_dispatcher< thrust::omp::vector< T , A > > { typedef thrust_algebra algebra_type; }; } } } #endif // _OPENMP // specialization for thrust tbb vector #ifdef TBB_VERSION_MAJOR #include <thrust/system/tbb/vector.h> namespace boost { namespace numeric { namespace odeint { template< class T , class A > struct algebra_dispatcher< thrust::tbb::vector< T , A > > { typedef thrust_algebra algebra_type; }; } } } #endif // TBB_VERSION_MAJOR // specialization for thrust cuda vector #ifdef __CUDACC__ #include <thrust/system/cuda/vector.h> namespace boost { namespace numeric { namespace odeint { template< class T , class A > struct algebra_dispatcher< thrust::cuda::vector< T , A > > { typedef thrust_algebra algebra_type; }; } } } #endif // __CUDACC__ #endif // THRUST_VERSION >= 100600 #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_DISPATCHER_HPP_DEFINED PK 䄟[W�!�v v 0 external/thrust/thrust_operations_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp [begin_description] operations_dispatcher specialization for thrust [end_description] Copyright 2013-2014 Karsten Ahnert Copyright 2013-2014 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_EXTERNAL_THRUST_THRUST_OPERATIONS_DISPATCHER_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_DISPATCHER_HPP_DEFINED #include <thrust/host_vector.h> #include <thrust/device_vector.h> #include <boost/numeric/odeint/external/thrust/thrust_operations.hpp> #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp> // support for the standard thrust containers namespace boost { namespace numeric { namespace odeint { // specialization for thrust host_vector template< class T , class A > struct operations_dispatcher< thrust::host_vector< T , A > > { typedef thrust_operations operations_type; }; // specialization for thrust device_vector template< class T , class A > struct operations_dispatcher< thrust::device_vector< T , A > > { typedef thrust_operations operations_type; }; } // namespace odeint } // namespace numeric } // namespace boost // add support for thrust backend vectors, if available #include <thrust/version.h> #if THRUST_VERSION >= 100600 // specialization for thrust cpp vector #include <thrust/system/cpp/vector.h> namespace boost { namespace numeric { namespace odeint { template< class T , class A > struct operations_dispatcher< thrust::cpp::vector< T , A > > { typedef thrust_operations operations_type; }; } } } // specialization for thrust omp vector #ifdef _OPENMP #include <thrust/system/omp/vector.h> namespace boost { namespace numeric { namespace odeint { template< class T , class A > struct operations_dispatcher< thrust::omp::vector< T , A > > { typedef thrust_operations operations_type; }; } } } #endif // _OPENMP // specialization for thrust tbb vector #ifdef TBB_VERSION_MAJOR #include <thrust/system/tbb/vector.h> namespace boost { namespace numeric { namespace odeint { template< class T , class A > struct operations_dispatcher< thrust::tbb::vector< T , A > > { typedef thrust_operations operations_type; }; } } } #endif // TBB_VERSION_MAJOR // specialization for thrust cuda vector #ifdef __CUDACC__ #include <thrust/system/cuda/vector.h> namespace boost { namespace numeric { namespace odeint { template< class T , class A > struct operations_dispatcher< thrust::cuda::vector< T , A > > { typedef thrust_operations operations_type; }; } } } #endif // __CUDACC__ #endif // THRUST_VERSION >= 100600 #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_DISPATCHER_HPP_DEFINED PK 䄟[���E&! &! ! external/thrust/thrust_resize.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/thrust/thrust_resize.hpp [begin_description] Enable resizing for thrusts device and host_vector. [end_description] Copyright 2010-2014 Mario Mulansky Copyright 2010-2011 Karsten Ahnert 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_EXTERNAL_THRUST_THRUST_RESIZE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_RESIZE_HPP_INCLUDED #include <boost/range.hpp> #include <thrust/device_vector.h> #include <thrust/host_vector.h> #include <thrust/distance.h> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/util/same_size.hpp> #include <boost/numeric/odeint/util/copy.hpp> namespace boost { namespace numeric { namespace odeint { // some macros that define the necessary utilities #define ODEINT_THRUST_VECTOR_IS_RESIZEABLE( THRUST_VECTOR ) \ template< class T , class A > \ struct is_resizeable< THRUST_VECTOR<T,A> > \ { \ struct type : public boost::true_type { }; \ const static bool value = type::value; \ }; \ #define ODEINT_TRHUST_VECTOR_RESIZE_IMPL( THRUST_VECTOR ) \ template< class T, class A > \ struct resize_impl< THRUST_VECTOR<T,A> , THRUST_VECTOR<T,A> > \ { \ static void resize( THRUST_VECTOR<T,A> &x , \ const THRUST_VECTOR<T,A> &y ) \ { \ x.resize( y.size() ); \ } \ }; \ template< class T, class A, typename Range > \ struct resize_impl< THRUST_VECTOR<T,A> , Range > \ { \ static void resize( THRUST_VECTOR<T,A> &x , \ const Range &y ) \ { \ x.resize( thrust::distance(boost::begin(y), \ boost::end(y))); \ } \ }; \ #define ODEINT_THRUST_SAME_SIZE_IMPL( THRUST_VECTOR ) \ template< class T , class A > \ struct same_size_impl< THRUST_VECTOR<T,A> , THRUST_VECTOR<T,A> > \ { \ static bool same_size( const THRUST_VECTOR<T,A> &x , \ const THRUST_VECTOR<T,A> &y ) \ { \ return x.size() == y.size(); \ } \ }; \ template< class T , class A, typename Range > \ struct same_size_impl< THRUST_VECTOR<T,A> , Range > \ { \ static bool same_size( const THRUST_VECTOR<T,A> &x , \ const Range &y ) \ { \ return x.size() == thrust::distance(boost::begin(y), \ boost::end(y)); \ } \ }; \ #define ODEINT_THRUST_COPY_IMPL( THRUST_VECTOR ) \ template< class Container1 , class T , class A > \ struct copy_impl< Container1 , THRUST_VECTOR<T,A> > \ { \ static void copy( const Container1 &from , THRUST_VECTOR<T,A> &to ) \ { \ thrust::copy( boost::begin( from ) , boost::end( from ) , \ boost::begin( to ) ); \ } \ }; \ \ template< class T , class A , class Container2 > \ struct copy_impl< THRUST_VECTOR<T,A> , Container2 > \ { \ static void copy( const THRUST_VECTOR<T,A> &from , Container2 &to ) \ { \ thrust::copy( boost::begin( from ) , boost::end( from ) , \ boost::begin( to ) ); \ } \ }; \ \ template< class T , class A > \ struct copy_impl< THRUST_VECTOR<T,A> , THRUST_VECTOR<T,A> > \ { \ static void copy( const THRUST_VECTOR<T,A> &from , \ THRUST_VECTOR<T,A> &to ) \ { \ thrust::copy( boost::begin( from ) , boost::end( from ) , \ boost::begin( to ) ); \ } \ }; \ // add support for the standard thrust containers ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::device_vector ) ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::device_vector ) ODEINT_THRUST_SAME_SIZE_IMPL( thrust::device_vector ) ODEINT_THRUST_COPY_IMPL( thrust::device_vector ) ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::host_vector ) ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::host_vector ) ODEINT_THRUST_SAME_SIZE_IMPL( thrust::host_vector ) ODEINT_THRUST_COPY_IMPL( thrust::host_vector ) } // odeint } // numeric } // boost // add support for thrust backend vectors, if available #include <thrust/version.h> #if THRUST_VERSION >= 100600 #include <thrust/system/cpp/vector.h> namespace boost { namespace numeric { namespace odeint { ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::cpp::vector ) ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::cpp::vector ) ODEINT_THRUST_SAME_SIZE_IMPL( thrust::cpp::vector ) ODEINT_THRUST_COPY_IMPL( thrust::cpp::vector ) } } } #ifdef _OPENMP #include <thrust/system/omp/vector.h> namespace boost { namespace numeric { namespace odeint { ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::omp::vector ) ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::omp::vector ) ODEINT_THRUST_SAME_SIZE_IMPL( thrust::omp::vector ) ODEINT_THRUST_COPY_IMPL( thrust::omp::vector ) } } } #endif // _OPENMP #ifdef TBB_VERSION_MAJOR #include <thrust/system/tbb/vector.h> namespace boost { namespace numeric { namespace odeint { ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::tbb::vector ) ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::tbb::vector ) ODEINT_THRUST_SAME_SIZE_IMPL( thrust::tbb::vector ) ODEINT_THRUST_COPY_IMPL( thrust::tbb::vector ) } } } #endif // TBB_VERSION_MAJOR #ifdef __CUDACC__ #include <thrust/system/cuda/vector.h> namespace boost { namespace numeric { namespace odeint { ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::cuda::vector ) ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::cuda::vector ) ODEINT_THRUST_SAME_SIZE_IMPL( thrust::cuda::vector ) ODEINT_THRUST_COPY_IMPL( thrust::cuda::vector ) } } } #endif // __CUDACC__ #endif // THRUST_VERSION >= 100600 #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_RESIZE_HPP_INCLUDED PK 䄟[�3�+� � external/mpi/mpi_state.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/mpi/mpi_state.hpp [begin_description] A generic split state, storing partial data on each node. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_EXTERNAL_MPI_MPI_STATE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_MPI_MPI_STATE_HPP_INCLUDED #include <vector> #include <algorithm> #include <boost/mpi.hpp> #include <boost/numeric/odeint/util/copy.hpp> #include <boost/numeric/odeint/util/split.hpp> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/util/same_size.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp> namespace boost { namespace numeric { namespace odeint { /** \brief A container which has its contents distributed among the nodes. */ template< class InnerState > struct mpi_state { typedef InnerState value_type; // the node's local data. InnerState m_data; boost::mpi::communicator world; mpi_state() {} mpi_state(boost::mpi::communicator comm) : world(comm) {} inline InnerState &operator()() { return m_data; } inline const InnerState &operator()() const { return m_data; } }; template< class InnerState > struct is_resizeable< mpi_state< InnerState > > : is_resizeable< InnerState > { }; template< class InnerState1 , class InnerState2 > struct same_size_impl< mpi_state< InnerState1 > , mpi_state< InnerState2 > > { static bool same_size( const mpi_state< InnerState1 > &x , const mpi_state< InnerState2 > &y ) { const bool local = boost::numeric::odeint::same_size(x(), y()); return boost::mpi::all_reduce(x.world, local, mpi::bitwise_and<bool>()); } }; template< class InnerState1 , class InnerState2 > struct resize_impl< mpi_state< InnerState1 > , mpi_state< InnerState2 > > { static void resize( mpi_state< InnerState1 > &x , const mpi_state< InnerState2 > &y ) { // resize local parts on each node. boost::numeric::odeint::resize(x(), y()); } }; /** \brief Copy data between mpi_states of same size. */ template< class InnerState1 , class InnerState2 > struct copy_impl< mpi_state< InnerState1 > , mpi_state< InnerState2 > > { static void copy( const mpi_state< InnerState1 > &from , mpi_state< InnerState2 > &to ) { // copy local parts on each node. boost::numeric::odeint::copy(from(), to()); } }; /** \brief Use `mpi_algebra` for `mpi_state`. */ template< class InnerState > struct algebra_dispatcher< mpi_state< InnerState > > { typedef mpi_nested_algebra< typename algebra_dispatcher< InnerState >::algebra_type > algebra_type; }; } } } #endif PK 䄟[�\�"} } external/mpi/mpi.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/mpi/mpi.hpp [begin_description] Wrappers for MPI. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_EXTERNAL_MPI_MPI_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_MPI_MPI_HPP_INCLUDED #include <boost/numeric/odeint/external/mpi/mpi_vector_state.hpp> #include <boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp> #endif PK 䄟[�?�\ \ # external/mpi/mpi_nested_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp [begin_description] Nested parallelized algebra for MPI. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_EXTERNAL_MPI_MPI_NESTED_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_MPI_MPI_NESTED_ALGEBRA_HPP_INCLUDED #include <boost/numeric/odeint/algebra/norm_result_type.hpp> #include <boost/numeric/odeint/util/n_ary_helper.hpp> namespace boost { namespace numeric { namespace odeint { /** \brief MPI-parallelized algebra, wrapping another algebra. */ template< class InnerAlgebra > struct mpi_nested_algebra { // execute the InnerAlgebra on each node's local data. #define BOOST_ODEINT_GEN_BODY(n) \ InnerAlgebra::for_each##n( \ BOOST_PP_ENUM_BINARY_PARAMS(n, s, () BOOST_PP_INTERCEPT) , \ op \ ); BOOST_ODEINT_GEN_FOR_EACH(BOOST_ODEINT_GEN_BODY) #undef BOOST_ODEINT_GEN_BODY template< class NestedState > static typename norm_result_type< typename NestedState::value_type >::type norm_inf( const NestedState &s ) { typedef typename norm_result_type< typename NestedState::value_type >::type result_type; // local maximum result_type value = InnerAlgebra::norm_inf( s() ); // global maximum return boost::mpi::all_reduce(s.world, value, boost::mpi::maximum<result_type>()); } }; } } } #endif PK 䄟[B� � � ! external/mpi/mpi_vector_state.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/mpi/mpi_vector_state.hpp [begin_description] Copying a container from/to an mpi_state splits/joins it. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_EXTERNAL_MPI_MPI_VECTOR_STATE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_MPI_MPI_VECTOR_STATE_HPP_INCLUDED #include <vector> #include <algorithm> #include <boost/mpi.hpp> #include <boost/numeric/odeint/util/copy.hpp> #include <boost/numeric/odeint/util/split_adaptor.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <boost/numeric/odeint/external/mpi/mpi_state.hpp> namespace boost { namespace numeric { namespace odeint { /** \brief Split data from some container on node 0 to the slaves. * Source must be a model of Random Access Range. */ template< class Source , class InnerState > struct split_impl< Source, mpi_state< InnerState >, typename boost::enable_if< boost::has_range_const_iterator<Source> >::type > { typedef typename boost::range_iterator<const Source>::type iterator; static void split( const Source &from, mpi_state< InnerState > &to ) { std::vector< InnerState > pieces; if(to.world.rank() == 0) { const size_t num = static_cast<size_t>(to.world.size()); pieces.resize(num); for(size_t i = 0 ; i < num ; i++) { iterator_range<iterator> part = detail::make_split_range(from, i, num); boost::numeric::odeint::resize(pieces[i], part); boost::numeric::odeint::copy(part, pieces[i]); } } // send to nodes boost::mpi::scatter(to.world, pieces, to(), 0); } }; /** \brief Merge data from an mpi_state to some container on node 0. * Target must be a model Single Pass Range. */ template< class Target, class InnerState > struct unsplit_impl< mpi_state< InnerState >, Target, typename boost::enable_if< boost::has_range_iterator<Target> >::type > { typedef typename boost::range_iterator<Target>::type iterator; static void unsplit( const mpi_state< InnerState > &from , Target &to ) { std::vector< InnerState > pieces; // send data to root boost::mpi::gather(from.world, from(), pieces, 0); if(from.world.rank() == 0) { // check target size size_t total_size = 0; for(size_t i = 0 ; i < pieces.size() ; i++) total_size += boost::size(pieces[i]); BOOST_ASSERT( total_size <= boost::size(to) ); // copy parts iterator out = boost::begin(to); for(size_t i = 0 ; i < pieces.size() ; i++) out = boost::copy(pieces[i], out); } } }; } } } #endif PK 䄟[h� B^ ^ ) external/viennacl/viennacl_operations.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/viennacl_operations.hpp [begin_description] ViennaCL operations. [end_description] Copyright 2012 Denis Demidov Copyright 2012 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_EXTERNAL_VIENNACL_VIENNACL_OPERATIONS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_OPERATIONS_HPP_INCLUDED #include <viennacl/vector.hpp> #ifdef VIENNACL_WITH_OPENCL # include <viennacl/generator/custom_operation.hpp> #endif namespace boost { namespace numeric { namespace odeint { #ifdef VIENNACL_WITH_OPENCL struct viennacl_operations { template< class Fac1 = double , class Fac2 = Fac1 > struct scale_sum2 { const Fac1 m_alpha1; const Fac2 m_alpha2; scale_sum2( Fac1 alpha1 , Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { } template< class T1 , class T2 , class T3 > void operator()( viennacl::vector<T1> &v1 , const viennacl::vector<T2> &v2 , const viennacl::vector<T3> &v3 ) const { using namespace viennacl; static generator::symbolic_vector <0, T1> sym_v1; static generator::symbolic_vector <1, T2> sym_v2; static generator::symbolic_vector <2, T3> sym_v3; static generator::cpu_symbolic_scalar<3, Fac1> sym_a1; static generator::cpu_symbolic_scalar<4, Fac2> sym_a2; static generator::custom_operation op( sym_v1 = sym_a1 * sym_v2 + sym_a2 * sym_v3, "scale_sum2" ); ocl::enqueue( op(v1, v2, v3, m_alpha1, m_alpha2) ); } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 > struct scale_sum3 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; scale_sum3( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) { } template< class T1 , class T2 , class T3 , class T4 > void operator()( viennacl::vector<T1> &v1 , const viennacl::vector<T2> &v2 , const viennacl::vector<T3> &v3 , const viennacl::vector<T4> &v4 ) const { using namespace viennacl; static generator::symbolic_vector <0, T1> sym_v1; static generator::symbolic_vector <1, T2> sym_v2; static generator::symbolic_vector <2, T3> sym_v3; static generator::symbolic_vector <3, T4> sym_v4; static generator::cpu_symbolic_scalar<4, Fac1> sym_a1; static generator::cpu_symbolic_scalar<5, Fac2> sym_a2; static generator::cpu_symbolic_scalar<6, Fac3> sym_a3; static generator::custom_operation op( sym_v1 = sym_a1 * sym_v2 + sym_a2 * sym_v3 + sym_a3 * sym_v4, "scale_sum3" ); ocl::enqueue( op(v1, v2, v3, v4, m_alpha1, m_alpha2, m_alpha3) ); } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 > struct scale_sum4 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; scale_sum4( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 > void operator()( viennacl::vector<T1> &v1 , const viennacl::vector<T2> &v2 , const viennacl::vector<T3> &v3 , const viennacl::vector<T4> &v4 , const viennacl::vector<T5> &v5 ) const { using namespace viennacl; static generator::symbolic_vector <0, T1> sym_v1; static generator::symbolic_vector <1, T2> sym_v2; static generator::symbolic_vector <2, T3> sym_v3; static generator::symbolic_vector <3, T4> sym_v4; static generator::symbolic_vector <4, T5> sym_v5; static generator::cpu_symbolic_scalar<5, Fac1> sym_a1; static generator::cpu_symbolic_scalar<6, Fac2> sym_a2; static generator::cpu_symbolic_scalar<7, Fac3> sym_a3; static generator::cpu_symbolic_scalar<8, Fac4> sym_a4; static generator::custom_operation op( sym_v1 = sym_a1 * sym_v2 + sym_a2 * sym_v3 + sym_a3 * sym_v4 + sym_a4 * sym_v5, "scale_sum4" ); ocl::enqueue( op(v1, v2, v3, v4, v5, m_alpha1, m_alpha2, m_alpha3, m_alpha4) ); } typedef void result_type; }; template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 > struct scale_sum5 { const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; scale_sum5( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > void operator()( viennacl::vector<T1> &v1 , const viennacl::vector<T2> &v2 , const viennacl::vector<T3> &v3 , const viennacl::vector<T4> &v4 , const viennacl::vector<T5> &v5 , const viennacl::vector<T6> &v6 ) const { using namespace viennacl; static generator::symbolic_vector < 0, T1> sym_v1; static generator::symbolic_vector < 1, T2> sym_v2; static generator::symbolic_vector < 2, T3> sym_v3; static generator::symbolic_vector < 3, T4> sym_v4; static generator::symbolic_vector < 4, T5> sym_v5; static generator::symbolic_vector < 5, T6> sym_v6; static generator::cpu_symbolic_scalar< 6, Fac1> sym_a1; static generator::cpu_symbolic_scalar< 7, Fac2> sym_a2; static generator::cpu_symbolic_scalar< 8, Fac3> sym_a3; static generator::cpu_symbolic_scalar< 9, Fac4> sym_a4; static generator::cpu_symbolic_scalar<10, Fac5> sym_a5; static generator::custom_operation op( sym_v1 = sym_a1 * sym_v2 + sym_a2 * sym_v3 + sym_a3 * sym_v4 + sym_a4 * sym_v5 + sym_a5 * sym_v6, "scale_sum5" ); ocl::enqueue( op(v1, v2, v3, v4, v5, v6, m_alpha1, m_alpha2, m_alpha3, m_alpha4, m_alpha5) ); } typedef void result_type; }; }; #else struct viennacl_operations : public default_operations {}; #endif } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_OPERATIONS_HPP_INCLUDED PK 䄟[� Y2 2 % external/viennacl/viennacl_resize.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/viennacl/viennacl_resize.hpp [begin_description] Enable resizing for viennacl vector. [end_description] Copyright 2012 Denis Demidov Copyright 2012 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_EXTERNAL_VIENNACL_VIENNACL_RESIZE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_RESIZE_HPP_INCLUDED #include <viennacl/vector.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/util/same_size.hpp> namespace boost { namespace numeric { namespace odeint { /* * specializations for viennacl::vector< T > */ template< typename T > struct is_resizeable< viennacl::vector< T > > : boost::true_type { }; template< typename T > struct resize_impl< viennacl::vector< T > , viennacl::vector< T > > { static void resize( viennacl::vector< T > &x1 , const viennacl::vector< T > &x2 ) { x1.resize( x2.size() , false ); } }; template< typename T > struct same_size_impl< viennacl::vector< T > , viennacl::vector< T > > { static bool same_size( const viennacl::vector< T > &x1 , const viennacl::vector< T > &x2 ) { return x1.size() == x2.size(); } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_RESIZE_HPP_INCLUDED PK 䄟[#��I �I ) external/openmp/openmp_nested_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp [begin_description] Nested parallelized algebra for OpenMP. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_EXTERNAL_OPENMP_OPENMP_NESTED_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_NESTED_ALGEBRA_HPP_INCLUDED #include <boost/assert.hpp> #include <boost/range.hpp> #include <boost/numeric/odeint/algebra/norm_result_type.hpp> #include <boost/numeric/odeint/util/n_ary_helper.hpp> namespace boost { namespace numeric { namespace odeint { /** \brief OpenMP-parallelized algebra, wrapping another, non-parallelized algebra. * * NestedState must be a model of Random Access Range, where the elements are sub-states * which will be processed in parallel. */ template< class InnerAlgebra > struct openmp_nested_algebra { #if __cplusplus >= 201103L // C++11 supports _Pragma #define BOOST_ODEINT_GEN_LOCAL(z, n, unused) \ BOOST_ASSERT_MSG( len == boost::size(s ## n), "All nested state ranges must have the same size." ); \ typename boost::range_iterator<S ## n>::type beg ## n = boost::begin(s ## n); #define BOOST_ODEINT_GEN_BODY(n) \ const size_t len = boost::size(s0); \ BOOST_PP_REPEAT(n, BOOST_ODEINT_GEN_LOCAL, ~) \ _Pragma("omp parallel for schedule(runtime)") \ for( size_t i = 0 ; i < len ; i++ ) \ InnerAlgebra::for_each##n( \ BOOST_PP_ENUM_BINARY_PARAMS(n, beg, [i] BOOST_PP_INTERCEPT) , \ op \ ); BOOST_ODEINT_GEN_FOR_EACH(BOOST_ODEINT_GEN_BODY) #undef BOOST_ODEINT_GEN_BODY #undef BOOST_ODEINT_GEN_LOCAL #else template< class S0 , class Op > static void for_each1 ( S0 &s0 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each1( beg0 [i] , op ); } template< class S0 , class S1 , class Op > static void for_each2 ( S0 &s0 , S1 &s1 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each2( beg0 [i] , beg1 [i] , op ); } template< class S0 , class S1 , class S2 , class Op > static void for_each3 ( S0 &s0 , S1 &s1 , S2 &s2 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each3( beg0 [i] , beg1 [i] , beg2 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class Op > static void for_each4 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each4( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class Op > static void for_each5 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each5( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each6 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each6( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each7 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each7( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class Op > static void for_each8 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each8( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class Op > static void for_each9 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each9( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class Op > static void for_each10 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each10( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class Op > static void for_each11 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each11( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each12 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); typename boost::range_iterator<S11>::type beg11 = boost::begin(s11); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each12( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each13 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); typename boost::range_iterator<S11>::type beg11 = boost::begin(s11); typename boost::range_iterator<S12>::type beg12 = boost::begin(s12); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each13( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each14 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); typename boost::range_iterator<S11>::type beg11 = boost::begin(s11); typename boost::range_iterator<S12>::type beg12 = boost::begin(s12); typename boost::range_iterator<S13>::type beg13 = boost::begin(s13); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each14( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] , op ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each15 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); typename boost::range_iterator<S11>::type beg11 = boost::begin(s11); typename boost::range_iterator<S12>::type beg12 = boost::begin(s12); typename boost::range_iterator<S13>::type beg13 = boost::begin(s13); typename boost::range_iterator<S14>::type beg14 = boost::begin(s14); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each15( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] , beg14 [i] , op ); } #endif template< class NestedState > static typename norm_result_type< typename NestedState::value_type >::type norm_inf( const NestedState &s ) { typedef typename boost::range_iterator<const NestedState>::type iterator; typedef typename std::iterator_traits<iterator>::value_type value_type; typedef typename norm_result_type<value_type>::type result_type; result_type init = static_cast< result_type >( 0 ); const size_t len = boost::size(s); iterator beg = boost::begin(s); # pragma omp parallel for reduction(max: init) schedule(dynamic) for( size_t i = 0 ; i < len ; i++ ) init = (std::max)( init , InnerAlgebra::norm_inf( beg[i] ) ); return init; } }; } } } #endif PK 䄟[P;#N� � external/openmp/openmp.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/openmp/openmp.hpp [begin_description] Wrappers for OpenMP. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_EXTERNAL_OPENMP_OPENMP_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_HPP_INCLUDED // level 1: parallel iteration over random access container #include <boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp> // level 2: split range state #include <boost/numeric/odeint/external/openmp/openmp_state.hpp> // level 3: process a random access container of sub-states in parallel #include <boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp> #endif PK 䄟[�>��T T external/openmp/openmp_state.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/openmp/openmp_state.hpp [begin_description] Wrappers for OpenMP. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_EXTERNAL_OPENMP_OPENMP_STATE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_STATE_HPP_INCLUDED #include <omp.h> #include <vector> #include <algorithm> #include <boost/range/adaptor/sliced.hpp> #include <boost/numeric/odeint/util/copy.hpp> #include <boost/numeric/odeint/util/split.hpp> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp> namespace boost { namespace numeric { namespace odeint { /** \brief A container that is split into distinct parts, for threading. * Just a wrapper for vector<vector<T>>, use `copy` for splitting/joining. */ template< class T > struct openmp_state : public std::vector< std::vector< T > > { openmp_state() {} openmp_state(size_t n, const std::vector<T>& val = std::vector<T>()) : std::vector< std::vector< T > >(n, val) {} template<class InputIterator> openmp_state(InputIterator first, InputIterator last) : std::vector< std::vector< T > >(first, last) {} openmp_state(const std::vector< std::vector< T > > &orig) : std::vector< std::vector< T > >(orig) {} }; template< class T > struct is_resizeable< openmp_state< T > > : boost::true_type { }; template< class T > struct same_size_impl< openmp_state< T > , openmp_state< T > > { static bool same_size( const openmp_state< T > &x , const openmp_state< T > &y ) { if( x.size() != y.size() ) return false; for( size_t i = 0 ; i != x.size() ; i++ ) if( x[i].size() != y[i].size() ) return false; return true; } }; template< class T > struct resize_impl< openmp_state< T > , openmp_state< T > > { static void resize( openmp_state< T > &x , const openmp_state< T > &y ) { x.resize( y.size() ); # pragma omp parallel for schedule(dynamic) for(size_t i = 0 ; i < x.size() ; i++) x[i].resize( y[i].size() ); } }; /** \brief Copy data between openmp_states of same size. */ template< class T > struct copy_impl< openmp_state< T >, openmp_state< T > > { static void copy( const openmp_state< T > &from, openmp_state< T > &to ) { # pragma omp parallel for schedule(dynamic) for(size_t i = 0 ; i < from.size() ; i++) std::copy( from[i].begin() , from[i].end() , to.begin() ); } }; /** \brief Copy data from some container to an openmp_state and resize it. * Target container size will determine number of blocks to split into. * If it is empty, it will be resized to the maximum number of OpenMP threads. * SourceContainer must support `s::value_type`, `s::const_iterator`, `s.begin()`, `s.end()` and `s.size()`, * with Random Access Iterators; i.e. it must be a Random Access Container. */ template< class SourceContainer > struct split_impl< SourceContainer, openmp_state< typename SourceContainer::value_type > > { static void split( const SourceContainer &from, openmp_state< typename SourceContainer::value_type > &to ) { if(to.size() == 0) to.resize( omp_get_max_threads() ); const size_t part = from.size() / to.size(); # pragma omp parallel for schedule(dynamic) for(size_t i = 0 ; i < to.size() ; i++) { typedef typename SourceContainer::const_iterator it_t; const it_t begin = from.begin() + i * part; it_t end = begin + part; // for cases where from.size() % to.size() > 0 if(i + 1 == to.size() || end > from.end()) end = from.end(); to[i].resize(end - begin); std::copy(begin, end, to[i].begin()); } } }; /** \brief Copy data from an openmp_state to some container and resize it. * TargetContainer must support `s::value_type`, `s::iterator`, `s.begin()` and `s.resize(n)`, * i.e. it must be a `std::vector`. */ template< class TargetContainer > struct unsplit_impl< openmp_state< typename TargetContainer::value_type >, TargetContainer > { static void unsplit( const openmp_state< typename TargetContainer::value_type > &from , TargetContainer &to ) { // resize target size_t total_size = 0; for(size_t i = 0 ; i < from.size() ; i++) total_size += from[i].size(); to.resize( total_size ); // copy parts typename TargetContainer::iterator out = to.begin(); for(size_t i = 0 ; i < from.size() ; i++) out = std::copy(from[i].begin(), from[i].end(), out); } }; /** \brief OpenMP-parallelized algebra. * For use with openmp_state. */ typedef openmp_nested_algebra< range_algebra > openmp_algebra; /** \brief Use `openmp_algebra` for `openmp_state`. */ template< class T > struct algebra_dispatcher< openmp_state< T > > { typedef openmp_algebra algebra_type; }; } } } #endif PK 䄟[ ��F �F ( external/openmp/openmp_range_algebra.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp [begin_description] Range algebra for OpenMP. [end_description] Copyright 2013 Karsten Ahnert Copyright 2013 Mario Mulansky Copyright 2013 Pascal Germroth 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_EXTERNAL_OPENMP_OPENMP_RANGE_ALGEBRA_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_RANGE_ALGEBRA_HPP_INCLUDED #include <boost/assert.hpp> #include <boost/range.hpp> #include <boost/numeric/odeint/algebra/norm_result_type.hpp> #include <boost/numeric/odeint/util/n_ary_helper.hpp> namespace boost { namespace numeric { namespace odeint { /** \brief OpenMP-parallelized range algebra. * * State must be a model of Random Access Range. */ struct openmp_range_algebra { #if __cplusplus >= 201103L // C++11 supports _Pragma #define BOOST_ODEINT_GEN_LOCAL(z, n, unused) \ BOOST_ASSERT_MSG( len == boost::size(s ## n), "All state ranges must have the same size." ); \ typename boost::range_iterator<S ## n>::type beg ## n = boost::begin(s ## n); #define BOOST_ODEINT_GEN_BODY(n) \ const size_t len = boost::size(s0); \ BOOST_PP_REPEAT(n, BOOST_ODEINT_GEN_LOCAL, ~) \ _Pragma("omp parallel for schedule(runtime)") \ for( size_t i = 0 ; i < len ; i++ ) \ op( BOOST_PP_ENUM_BINARY_PARAMS(n, beg, [i] BOOST_PP_INTERCEPT) ); BOOST_ODEINT_GEN_FOR_EACH(BOOST_ODEINT_GEN_BODY) #undef BOOST_ODEINT_GEN_BODY #undef BOOST_ODEINT_GEN_LOCAL #else template< class S0 , class Op > static void for_each1 ( S0 &s0 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] ); } template< class S0 , class S1 , class Op > static void for_each2 ( S0 &s0 , S1 &s1 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] ); } template< class S0 , class S1 , class S2 , class Op > static void for_each3 ( S0 &s0 , S1 &s1 , S2 &s2 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class Op > static void for_each4 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class Op > static void for_each5 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each6 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each7 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class Op > static void for_each8 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class Op > static void for_each9 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class Op > static void for_each10 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class Op > static void for_each11 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each12 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); typename boost::range_iterator<S11>::type beg11 = boost::begin(s11); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each13 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); typename boost::range_iterator<S11>::type beg11 = boost::begin(s11); typename boost::range_iterator<S12>::type beg12 = boost::begin(s12); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each14 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); typename boost::range_iterator<S11>::type beg11 = boost::begin(s11); typename boost::range_iterator<S12>::type beg12 = boost::begin(s12); typename boost::range_iterator<S13>::type beg13 = boost::begin(s13); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] ); } template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each15 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) { const size_t len = boost::size(s0); typename boost::range_iterator<S0>::type beg0 = boost::begin(s0); typename boost::range_iterator<S1>::type beg1 = boost::begin(s1); typename boost::range_iterator<S2>::type beg2 = boost::begin(s2); typename boost::range_iterator<S3>::type beg3 = boost::begin(s3); typename boost::range_iterator<S4>::type beg4 = boost::begin(s4); typename boost::range_iterator<S5>::type beg5 = boost::begin(s5); typename boost::range_iterator<S6>::type beg6 = boost::begin(s6); typename boost::range_iterator<S7>::type beg7 = boost::begin(s7); typename boost::range_iterator<S8>::type beg8 = boost::begin(s8); typename boost::range_iterator<S9>::type beg9 = boost::begin(s9); typename boost::range_iterator<S10>::type beg10 = boost::begin(s10); typename boost::range_iterator<S11>::type beg11 = boost::begin(s11); typename boost::range_iterator<S12>::type beg12 = boost::begin(s12); typename boost::range_iterator<S13>::type beg13 = boost::begin(s13); typename boost::range_iterator<S14>::type beg14 = boost::begin(s14); #pragma omp parallel for schedule(runtime) for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] , beg14 [i] ); } #endif template< class S > static typename norm_result_type< S >::type norm_inf( const S &s ) { using std::max; using std::abs; typedef typename norm_result_type< S >::type result_type; result_type init = static_cast< result_type >( 0 ); const size_t len = boost::size(s); typename boost::range_iterator<const S>::type beg = boost::begin(s); # pragma omp parallel for reduction(max: init) schedule(dynamic) for( size_t i = 0 ; i < len ; ++i ) init = max( init , abs( beg[i] ) ); return init; } }; } } } #endif PK 䄟[|���K K external/mkl/mkl_operations.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/mkl/mkl_operations.hpp [begin_description] Wrapper classes for intel math kernel library types. Get a free, non-commercial download of MKL at http://software.intel.com/en-us/articles/non-commercial-software-download/ [end_description] Copyright 2010-2011 Mario Mulansky Copyright 2011-2013 Karsten Ahnert 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_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED #include <iostream> #include <mkl_cblas.h> #include <boost/numeric/odeint/algebra/default_operations.hpp> /* exemplary example for writing bindings to the Intel MKL library * see test/mkl for how to use mkl with odeint * this is a quick and dirty implementation showing the general possibility. * It works only with containers based on double and sequential memory allocation. */ namespace boost { namespace numeric { namespace odeint { /* only defined for doubles */ struct mkl_operations { //template< class Fac1 , class Fac2 > struct scale_sum2; template< class F1 = double , class F2 = F1 > struct scale_sum2 { typedef double Fac1; typedef double Fac2; const Fac1 m_alpha1; const Fac2 m_alpha2; scale_sum2( const Fac1 alpha1 , const Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { } template< class T1 , class T2 , class T3 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3) const { // t1 = m_alpha1 * t2 + m_alpha2 * t3; // we get Containers that have size() and [i]-access const int n = t1.size(); //boost::numeric::odeint::copy( t1 , t3 ); if( &(t2[0]) != &(t1[0]) ) { cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 ); } cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 ); cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 ); //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one ); } }; template< class F1 = double , class F2 = F1 , class F3 = F2 > struct scale_sum3 { typedef double Fac1; typedef double Fac2; typedef double Fac3; const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; scale_sum3( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) { } template< class T1 , class T2 , class T3 , class T4 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 ) const { // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4; // we get Containers that have size() and [i]-access const int n = t1.size(); //boost::numeric::odeint::copy( t1 , t3 ); if( &(t2[0]) != &(t1[0]) ) { cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 ); } cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 ); cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 ); //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one ); cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 ); } }; template< class F1 = double , class F2 = F1 , class F3 = F2 , class F4 = F3 > struct scale_sum4 { typedef double Fac1; typedef double Fac2; typedef double Fac3; typedef double Fac4; const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; scale_sum4( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 ) const { // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5; // we get Containers that have size() and [i]-access const int n = t1.size(); //boost::numeric::odeint::copy( t1 , t3 ); if( &(t2[0]) != &(t1[0]) ) { cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 ); } cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 ); cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 ); //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one ); cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 ); cblas_daxpy( n , m_alpha4 , &(t5[0]) , 1 , &(t1[0]) , 1 ); } }; template< class F1 = double , class F2 = F1 , class F3 = F2 , class F4 = F3 , class F5 = F4 > struct scale_sum5 { typedef double Fac1; typedef double Fac2; typedef double Fac3; typedef double Fac4; typedef double Fac5; const Fac1 m_alpha1; const Fac2 m_alpha2; const Fac3 m_alpha3; const Fac4 m_alpha4; const Fac5 m_alpha5; scale_sum5( const Fac1 alpha1 , const Fac2 alpha2 , const Fac3 alpha3 , const Fac4 alpha4 , const Fac5 alpha5 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { } template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 ) const { // t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6; // we get Containers that have size() and [i]-access const int n = t1.size(); //boost::numeric::odeint::copy( t1 , t3 ); if( &(t2[0]) != &(t1[0]) ) { cblas_dcopy( n , &(t2[0]) , 1 , &(t1[0]) , 1 ); } cblas_dscal( n , m_alpha1 , &(t1[0]) , 1 ); cblas_daxpy( n , m_alpha2 , &(t3[0]) , 1 , &(t1[0]) , 1 ); //daxpby( &n , &m_alpha2 , &(t3[0]) , &one , &m_alpha1 , &(t1[0]) , &one ); cblas_daxpy( n , m_alpha3 , &(t4[0]) , 1 , &(t1[0]) , 1 ); cblas_daxpy( n , m_alpha4 , &(t5[0]) , 1 , &(t1[0]) , 1 ); cblas_daxpy( n , m_alpha5 , &(t6[0]) , 1 , &(t1[0]) , 1 ); } }; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_MKL_MKL_OPERATIONS_HPP_INCLUDED PK 䄟[`�\ f f external/nt2/nt2_resize.hppnu �[��� //============================================================================== // Copyright 2014 LRI UMR 8623 CNRS/Univ Paris Sud XI // Copyright 2014 NumScale SAS // // Distributed under the Boost Software License, Version 1.0. // See accompanying file LICENSE.txt or copy at // http://www.boost.org/LICENSE_1_0.txt //============================================================================== #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_RESIZE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_RESIZE_HPP_INCLUDED #include <nt2/core/container/table/table.hpp> #include <boost/numeric/odeint/util/same_size.hpp> namespace boost { namespace numeric { namespace odeint { template<typename T, typename S> struct is_resizeable< nt2::container::table<T,S> > { typedef boost::true_type type; static const bool value = type::value; }; template<typename T, typename S> struct same_size_impl< nt2::container::table<T,S> , nt2::container::table<T,S> > { static bool same_size ( const nt2::container::table<T,S> &v1 , const nt2::container::table<T,S> &v2 ) { return v1.extent() == v2.extent(); } }; template<typename T, typename S> struct resize_impl< nt2::container::table<T,S> , nt2::container::table<T,S> > { static void resize ( nt2::container::table<T,S> &v1 , const nt2::container::table<T,S> &v2 ) { v1.resize( v2.extent() ); } }; } } } #endif PK 䄟[�el3~ ~ external/nt2/nt2_copy.hppnu �[��� //============================================================================== // Copyright 2014 LASMEA UMR 6602 CNRS/Univ. Clermont II // Copyright 2014 LRI UMR 8623 CNRS/Univ Paris Sud XI // Copyright 2014 MetaScale SAS // // Distributed under the Boost Software License, Version 1.0. // See accompanying file LICENSE.txt or copy at // http://www.boost.org/LICENSE_1_0.txt //============================================================================== #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_COPY_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_COPY_HPP_INCLUDED #include <nt2/core/container/table/table.hpp> #include <boost/numeric/odeint/util/copy.hpp> namespace boost { namespace numeric { namespace odeint { template<typename T, typename S> struct copy_impl< nt2::container::table<T,S> , nt2::container::table<T,S> > { static void copy ( const nt2::container::table<T,S> &v1 , nt2::container::table<T,S> &v2 ) { v2 = v1; } }; } } } #endif PK 䄟[\��\ ' external/nt2/nt2_algebra_dispatcher.hppnu �[��� //============================================================================== // Copyright 2014 LRI UMR 8623 CNRS/Univ Paris Sud XI // Copyright 2014 NumScale SAS // // Distributed under the Boost Software License, Version 1.0. // See accompanying file LICENSE.txt or copy at // http://www.boost.org/LICENSE_1_0.txt //============================================================================== #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_ALGEBRA_DISPATCHER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_ALGEBRA_DISPATCHER_HPP_INCLUDED #include <nt2/core/container/table/table.hpp> #include <boost/numeric/odeint/algebra/vector_space_algebra.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> namespace boost { namespace numeric { namespace odeint { template<typename T, typename S> struct algebra_dispatcher<nt2::container::table<T,S> > { typedef vector_space_algebra algebra_type; }; } } } #endif PK 䄟[���| | external/nt2/nt2_norm_inf.hppnu �[��� //============================================================================== // Copyright 2014 LRI UMR 8623 CNRS/Univ Paris Sud XI // Copyright 2014 NumScale SAS // // Distributed under the Boost Software License, Version 1.0. // See accompanying file LICENSE.txt or copy at // http://www.boost.org/LICENSE_1_0.txt //============================================================================== #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_NORM_INF_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_NORM_INF_HPP_INCLUDED #include <nt2/core/container/table/table.hpp> #include <nt2/include/functions/globalmax.hpp> #include <nt2/include/functions/abs.hpp> #include <boost/numeric/odeint/algebra/vector_space_algebra.hpp> namespace boost { namespace numeric { namespace odeint { template<typename T, typename S> struct vector_space_norm_inf<nt2::container::table<T,S> > { typedef T result_type; result_type operator()(const nt2::container::table<T,S> &v1) const { return nt2::globalmax(nt2::abs(v1)); } }; } } } #endif PK 䄟[p��^� � external/vexcl/vexcl_copy.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/vexcl/vexcl_copy.hpp [begin_description] copy_impl specializations for vexcl [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_EXTERNAL_VEXCL_VEXCL_COPY_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_COPY_HPP_INCLUDED #include <vexcl/vector.hpp> #include <vexcl/multivector.hpp> #include <boost/numeric/odeint/util/copy.hpp> namespace boost { namespace numeric { namespace odeint { template< typename T1, typename T2 > struct copy_impl< vex::vector<T1>, vex::vector<T2> > { static void copy( const vex::vector<T1> &from , vex::vector<T2> &to ) { to = from; } }; template< typename T1, typename T2, size_t N > struct copy_impl< vex::multivector<T1, N>, vex::multivector<T2, N> > { static void copy( const vex::multivector<T1, N> &from , vex::multivector<T2, N> &to ) { to = from; } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_COPY_HPP_INCLUDED PK 䄟[� ��� � ! external/vexcl/vexcl_norm_inf.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp [begin_description] vector_space_norm_inf specialization for vexcl [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_EXTERNAL_VEXCL_VEXCL_NORM_INF_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_NORM_INF_HPP_DEFINED #include <map> #include <algorithm> #include <vexcl/vector.hpp> #include <vexcl/multivector.hpp> #include <vexcl/reductor.hpp> #include <boost/numeric/odeint/algebra/vector_space_algebra.hpp> namespace boost { namespace numeric { namespace odeint { // specialization for vexcl vector template <typename T> struct vector_space_norm_inf< vex::vector<T> > { typedef T result_type; T operator()( const vex::vector<T> &x ) const { const auto &max = vex::get_reductor<T, vex::MAX>(x.queue_list()); return max( fabs(x) ); } }; // specialization for vexcl multivector template <typename T, size_t N> struct vector_space_norm_inf< vex::multivector<T, N> > { typedef T result_type; T operator()( const vex::multivector<T, N> &x ) const { const auto &max = vex::get_reductor<T, vex::MAX>(x.queue_list()); // Reducing a multivector results in std::array<T, N>: auto m = max( fabs(x) ); // We will need to reduce it even further: return *std::max_element(m.begin(), m.end()); } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_NORM_INF_HPP_DEFINED PK 䄟[=>�' ' external/vexcl/vexcl_abs.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/vexcl/vexcl_abs.hpp [begin_description] abs() specialization for vexcl [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_EXTERNAL_VEXCL_VEXCL_ABS_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_ABS_HPP_DEFINED #include <vexcl/vector.hpp> #include <vexcl/multivector.hpp> #include <vexcl/operations.hpp> namespace vex { template <typename T, size_t N> typename std::enable_if< std::is_integral<T>::value, typename boost::proto::result_of::make_expr< boost::proto::tag::function, abs_func, const vex::multivector<T, N>& >::type const >::type abs(const multivector<T, N> &arg) { return boost::proto::make_expr<boost::proto::tag::function>( abs_func(), boost::ref(arg) ); } template <typename T, size_t N> typename std::enable_if< !std::is_integral<T>::value, typename boost::proto::result_of::make_expr< boost::proto::tag::function, fabs_func, const vex::multivector<T, N>& >::type const >::type abs(const multivector<T, N> &arg) { return boost::proto::make_expr<boost::proto::tag::function>( fabs_func(), boost::ref(arg) ); } } // namespace vex #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_ABS_HPP_DEFINED PK 䄟[���� + external/vexcl/vexcl_algebra_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp [begin_description] algebra_dispatcher specialization for vexcl [end_description] Copyright 2013 Karsten Ahnert Copyright 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_EXTERNAL_VEXCL_VEXCL_ALGEBRA_DISPATCHER_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_ALGEBRA_DISPATCHER_HPP_DEFINED #include <vexcl/vector.hpp> #include <vexcl/multivector.hpp> #include <boost/numeric/odeint/algebra/vector_space_algebra.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> namespace boost { namespace numeric { namespace odeint { // specialization for vexcl vector template< typename T > struct algebra_dispatcher< vex::vector< T > > { typedef vector_space_algebra algebra_type; }; // specialization for vexcl multivector template< typename T , size_t N > struct algebra_dispatcher< vex::multivector< T , N > > { typedef vector_space_algebra algebra_type; }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_ALGEBRA_DISPATCHER_HPP_DEFINED PK 䄟[�=з & external/vexcl/vexcl_same_instance.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp [begin_description] Check if two VexCL containers are the same instance. [end_description] Copyright 2009-2011 Karsten Ahnert Copyright 2009-2011 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_EXTERNAL_VEXCL_VEXCL_SAME_INSTANCE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_SAME_INSTANCE_HPP_INCLUDED #include <vexcl/vector.hpp> #include <vexcl/multivector.hpp> #include <boost/numeric/odeint/util/same_instance.hpp> namespace boost { namespace numeric { namespace odeint { template <typename T> struct same_instance_impl< vex::vector<T> , vex::vector<T> > { static bool same_instance( const vex::vector<T> &x1 , const vex::vector<T> &x2 ) { return static_cast<const vex::vector<T>*>(&x1) == static_cast<const vex::vector<T>*>(&x2); } }; template <typename T, size_t N> struct same_instance_impl< vex::multivector<T, N> , vex::multivector<T, N> > { static bool same_instance( const vex::multivector<T, N> &x1 , const vex::multivector<T, N> &x2 ) { return static_cast<const vex::multivector<T, N>*>(&x1) == static_cast<const vex::multivector<T, N>*>(&x2); } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_SAME_INSTANCE_HPP_INCLUDED PK 䄟[�E� � � external/vexcl/vexcl_resize.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/vexcl/vexcl_resize.hpp [begin_description] Enable resizing for vexcl vector and multivector. [end_description] Copyright 2012 Karsten Ahnert Copyright 2012 Mario Mulansky Copyright 2012 Denis Demidov 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_EXTERNAL_VEXCL_VEXCL_RESIZE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_RESIZE_HPP_INCLUDED #include <vexcl/vector.hpp> #include <vexcl/multivector.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/util/same_size.hpp> namespace boost { namespace numeric { namespace odeint { /* * specializations for vex::vector< T > */ template< typename T > struct is_resizeable< vex::vector< T > > : boost::true_type { }; template< typename T > struct resize_impl< vex::vector< T > , vex::vector< T > > { static void resize( vex::vector< T > &x1 , const vex::vector< T > &x2 ) { x1.resize( x2.queue_list() , x2.size() ); } }; template< typename T > struct same_size_impl< vex::vector< T > , vex::vector< T > > { static bool same_size( const vex::vector< T > &x1 , const vex::vector< T > &x2 ) { return x1.size() == x2.size(); } }; /* * specializations for vex::multivector< T > */ template< typename T , size_t N > struct is_resizeable< vex::multivector< T , N > > : boost::true_type { }; template< typename T , size_t N > struct resize_impl< vex::multivector< T , N > , vex::multivector< T , N > > { static void resize( vex::multivector< T , N > &x1 , const vex::multivector< T , N > &x2 ) { x1.resize( x2.queue_list() , x2.size() ); } }; template< typename T , size_t N > struct same_size_impl< vex::multivector< T , N > , vex::multivector< T , N > > { static bool same_size( const vex::multivector< T , N > &x1 , const vex::multivector< T , N > &x2 ) { return x1.size() == x2.size(); } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_RESIZE_HPP_INCLUDED PK 䄟[P��2� � external/vexcl/vexcl.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/vexcl/vexcl.hpp [begin_description] includes all headers required for using vexcl in odeint [end_description] Copyright 2013 Karsten Ahnert Copyright 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_EXTERNAL_VEXCL_VEXCL_HPP_DEFINED #define BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_HPP_DEFINED #include <boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp> #include <boost/numeric/odeint/external/vexcl/vexcl_resize.hpp> #include <boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp> #include <boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp> #include <boost/numeric/odeint/external/vexcl/vexcl_abs.hpp> #include <boost/numeric/odeint/external/vexcl/vexcl_copy.hpp> #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_HPP_DEFINED PK 䄟[W֬ � external/blaze/blaze_resize.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/blaze/blaze_resize.hpp [begin_description] tba. [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_EXTERNAL_BLAZE_BLAZE_RESIZE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_BLAZE_BLAZE_RESIZE_HPP_INCLUDED #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/util/same_size.hpp> #include <blaze/math/dense/DynamicVector.h> namespace boost { namespace numeric { namespace odeint { template< typename T , bool TF > struct is_resizeable< blaze::DynamicVector< T , TF > > { typedef boost::true_type type; const static bool value = type::value; }; template< typename T1 , bool TF1, typename T2 , bool TF2 > struct same_size_impl< blaze::DynamicVector< T1 , TF1 > , blaze::DynamicVector< T2 , TF2 > > { static bool same_size( const blaze::DynamicVector< T1 , TF1 > &x1 , const blaze::DynamicVector< T2 , TF2 > &x2 ) { return x1.size() == x2.size(); } }; template< typename T1 , bool TF1, typename T2 , bool TF2 > struct resize_impl< blaze::DynamicVector< T1 , TF1 > , blaze::DynamicVector< T2 , TF2 > > { static void resize( blaze::DynamicVector< T1 , TF1 > &x1 , const blaze::DynamicVector< T2 , TF2 > &x2 ) { x1.resize( x2.size() ); } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_BLAZE_BLAZE_RESIZE_HPP_INCLUDED PK 䄟[�\� � + external/blaze/blaze_algebra_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/blaze/blaze_algebra_dispatcher.hpp [begin_description] tba. [end_description] Copyright 2009-2012 Karsten Ahnert Copyright 2009-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_EXTERNAL_BLAZE_BLAZE_ALGEBRA_DISPATCHER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_BLAZE_BLAZE_ALGEBRA_DISPATCHER_HPP_INCLUDED #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> #include <blaze/math/dense/StaticVector.h> #include <blaze/math/dense/DynamicVector.h> namespace boost { namespace numeric { namespace odeint { template< typename T , size_t N , bool TF > struct algebra_dispatcher< blaze::StaticVector< T , N , TF > > { typedef vector_space_algebra algebra_type; }; template< typename T , bool TF > struct algebra_dispatcher< blaze::DynamicVector< T , TF > > { typedef vector_space_algebra algebra_type; }; } } } #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_BLAZE_BLAZE_ALGEBRA_DISPATCHER_HPP_INCLUDED PK 䄟[��1]� � external/gsl/gsl_wrapper.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/gsl/gsl_wrapper.hpp [begin_description] Wrapper for gsl_vector. [end_description] Copyright 2011-2012 Mario Mulansky Copyright 2011 Karsten Ahnert 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_EXTERNAL_GSL_GSL_WRAPPER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_GSL_GSL_WRAPPER_HPP_INCLUDED #include <new> #include <gsl/gsl_vector.h> #include <boost/type_traits/integral_constant.hpp> #include <boost/range.hpp> #include <boost/iterator/iterator_facade.hpp> #include <boost/numeric/odeint/util/state_wrapper.hpp> #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/copy.hpp> class const_gsl_vector_iterator; /* * defines an iterator for gsl_vector */ class gsl_vector_iterator : public boost::iterator_facade< gsl_vector_iterator , double , boost::random_access_traversal_tag > { public : gsl_vector_iterator( void ): m_p(0) , m_stride( 0 ) { } explicit gsl_vector_iterator( gsl_vector *p ) : m_p( p->data ) , m_stride( p->stride ) { } friend gsl_vector_iterator end_iterator( gsl_vector * ); private : friend class boost::iterator_core_access; friend class const_gsl_vector_iterator; void increment( void ) { m_p += m_stride; } void decrement( void ) { m_p -= m_stride; } void advance( ptrdiff_t n ) { m_p += n*m_stride; } bool equal( const gsl_vector_iterator &other ) const { return this->m_p == other.m_p; } bool equal( const const_gsl_vector_iterator &other ) const; double& dereference( void ) const { return *m_p; } double *m_p; size_t m_stride; }; /* * defines an const iterator for gsl_vector */ class const_gsl_vector_iterator : public boost::iterator_facade< const_gsl_vector_iterator , const double , boost::random_access_traversal_tag > { public : const_gsl_vector_iterator( void ): m_p(0) , m_stride( 0 ) { } explicit const_gsl_vector_iterator( const gsl_vector *p ) : m_p( p->data ) , m_stride( p->stride ) { } const_gsl_vector_iterator( const gsl_vector_iterator &p ) : m_p( p.m_p ) , m_stride( p.m_stride ) { } private : friend class boost::iterator_core_access; friend class gsl_vector_iterator; friend const_gsl_vector_iterator end_iterator( const gsl_vector * ); void increment( void ) { m_p += m_stride; } void decrement( void ) { m_p -= m_stride; } void advance( ptrdiff_t n ) { m_p += n*m_stride; } bool equal( const const_gsl_vector_iterator &other ) const { return this->m_p == other.m_p; } bool equal( const gsl_vector_iterator &other ) const { return this->m_p == other.m_p; } const double& dereference( void ) const { return *m_p; } const double *m_p; size_t m_stride; }; bool gsl_vector_iterator::equal( const const_gsl_vector_iterator &other ) const { return this->m_p == other.m_p; } gsl_vector_iterator end_iterator( gsl_vector *x ) { gsl_vector_iterator iter( x ); iter.m_p += iter.m_stride * x->size; return iter; } const_gsl_vector_iterator end_iterator( const gsl_vector *x ) { const_gsl_vector_iterator iter( x ); iter.m_p += iter.m_stride * x->size; return iter; } namespace boost { template<> struct range_mutable_iterator< gsl_vector* > { typedef gsl_vector_iterator type; }; template<> struct range_const_iterator< gsl_vector* > { typedef const_gsl_vector_iterator type; }; } // namespace boost // template<> inline gsl_vector_iterator range_begin( gsl_vector *x ) { return gsl_vector_iterator( x ); } // template<> inline const_gsl_vector_iterator range_begin( const gsl_vector *x ) { return const_gsl_vector_iterator( x ); } // template<> inline gsl_vector_iterator range_end( gsl_vector *x ) { return end_iterator( x ); } // template<> inline const_gsl_vector_iterator range_end( const gsl_vector *x ) { return end_iterator( x ); } namespace boost { namespace numeric { namespace odeint { template<> struct is_resizeable< gsl_vector* > { //struct type : public boost::true_type { }; typedef boost::true_type type; const static bool value = type::value; }; template <> struct same_size_impl< gsl_vector* , gsl_vector* > { static bool same_size( const gsl_vector* x , const gsl_vector* y ) { return x->size == y->size; } }; template <> struct resize_impl< gsl_vector* , gsl_vector* > { static void resize( gsl_vector* &x , const gsl_vector* y ) { gsl_vector_free( x ); x = gsl_vector_alloc( y->size ); } }; template<> struct state_wrapper< gsl_vector* > { typedef double value_type; typedef gsl_vector* state_type; typedef state_wrapper< gsl_vector* > state_wrapper_type; state_type m_v; state_wrapper( ) { m_v = gsl_vector_alloc( 1 ); } state_wrapper( const state_wrapper_type &x ) { resize( m_v , x.m_v ); gsl_vector_memcpy( m_v , x.m_v ); } ~state_wrapper() { gsl_vector_free( m_v ); } }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_GSL_GSL_WRAPPER_HPP_INCLUDED PK 䄟[I"`Q� � external/mtl4/mtl4.hppnu �[��� /* [auto_generated] /boost/numeric/odeint/external/mtl4/mtl4.hpp [begin_description] includes all headers required for using mtl4 with odeint [end_description] Copyright 2013 Karsten Ahnert Copyright 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_EXTERNAL_MTL4_MTL4_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_MTL4_MTL4_HPP_INCLUDED #include <boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp> #include <boost/numeric/odeint/external/mtl4/mtl4_resize.hpp> #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_MTL4_MTL4_INCLUDED PK 䄟[���� � ) external/mtl4/mtl4_algebra_dispatcher.hppnu �[��� /* [auto_generated] boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp [begin_description] specialization of the algebra dispatcher for mtl4 [end_description] Copyright 2013 Karsten Ahnert Copyright 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_MTL4_MTL4_ALGEBRA_DISPATCHER_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_MTL4_MTL4_ALGEBRA_DISPATCHER_HPP_INCLUDED #include <boost/numeric/mtl/mtl.hpp> #include <boost/numeric/odeint/algebra/vector_space_algebra.hpp> #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp> namespace boost { namespace numeric { namespace odeint { template<typename Value, typename Parameters> struct algebra_dispatcher< mtl::dense_vector< Value , Parameters > > { typedef vector_space_algebra algebra_type; }; template<typename Value, typename Parameters> struct algebra_dispatcher< mtl::dense2D< Value , Parameters > > { typedef vector_space_algebra algebra_type; }; template<typename Value , size_t BitMask , typename Parameters> struct algebra_dispatcher< mtl::morton_dense< Value , BitMask, Parameters > > { typedef vector_space_algebra algebra_type; }; template<typename Value, typename Parameters> struct algebra_dispatcher< mtl::compressed2D< Value , Parameters > > { typedef vector_space_algebra algebra_type; }; // specialization of infinity norm calculation template<typename Value, typename Parameters> struct vector_space_norm_inf< mtl::dense_vector< Value , Parameters > > { typedef Value result_type; Value operator()( const mtl::dense_vector< Value , Parameters > &x ) const { return mtl::infinity_norm(x); } }; template<typename Value, typename Parameters> struct vector_space_norm_inf< mtl::dense2D< Value , Parameters > > { typedef Value result_type; Value operator()( const mtl::dense2D< Value , Parameters > &x ) const { return mtl::infinity_norm(x); } }; template<typename Value , size_t BitMask , typename Parameters> struct vector_space_norm_inf< mtl::morton_dense< Value , BitMask , Parameters > > { typedef Value result_type; Value operator()( const mtl::morton_dense< Value , BitMask , Parameters > &x ) const { return mtl::infinity_norm(x); } }; template<typename Value, typename Parameters> struct vector_space_norm_inf< mtl::compressed2D< Value , Parameters > > { typedef Value result_type; Value operator()( const mtl::compressed2D< Value , Parameters > &x ) const { return mtl::infinity_norm(x); } }; } } } #endif // BOOST_NUMERIC_ODEINT_MTL4_MTL4_ALGEBRA_DISPATCHER_INCLUDED PK 䄟[�#� external/mtl4/mtl4_resize.hppnu �[��� /* [begin_description] Modification of the implicit Euler method, works with the MTL4 matrix library only. [end_description] Copyright 2012-2013 Andreas Angelopoulos Copyright 2012-2013 Karsten Ahnert Copyright 2012-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_EXTERNAL_MTL4_RESIZE_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_MTL4_RESIZE_HPP_INCLUDED #include <boost/numeric/odeint/util/is_resizeable.hpp> #include <boost/numeric/odeint/util/resize.hpp> #include <boost/numeric/odeint/util/same_size.hpp> #include <boost/numeric/mtl/vector/dense_vector.hpp> #include <boost/numeric/mtl/matrix/dense2D.hpp> #include <boost/numeric/mtl/matrix/compressed2D.hpp> namespace boost { namespace numeric { namespace odeint { template< class Value , class Parameters > struct is_resizeable< mtl::dense_vector< Value , Parameters > > { typedef boost::true_type type; const static bool value = type::value; }; template< class Value , class Parameters > struct is_resizeable< mtl::dense2D< Value , Parameters > > { typedef boost::true_type type; const static bool value = type::value; }; template< class Value , class Parameters > struct is_resizeable< mtl::compressed2D< Value , Parameters > > { typedef boost::true_type type; const static bool value = type::value; }; template< class Value , class Parameters > struct same_size_impl< mtl::dense_vector< Value , Parameters > , mtl::dense_vector< Value , Parameters > > { static bool same_size( const mtl::dense_vector< Value , Parameters > &v1 , const mtl::dense_vector< Value , Parameters > &v2 ) { return mtl::size( v1 ) == mtl::size( v2 ); } }; template< class Value , class Parameters > struct resize_impl< mtl::dense_vector< Value , Parameters > , mtl::dense_vector< Value , Parameters > > { static void resize( mtl::dense_vector< Value , Parameters > &v1 , const mtl::dense_vector< Value , Parameters > &v2 ) { v1.change_dim( mtl::size( v2 ) ); } }; template< class Value , class MatrixParameters , class VectorParameters > struct same_size_impl< mtl::dense2D< Value , MatrixParameters > , mtl::dense_vector< Value , VectorParameters > > { static bool same_size( const mtl::dense2D< Value , MatrixParameters > &m , const mtl::dense_vector< Value , VectorParameters > &v ) { return ( ( mtl::size( v ) == m.num_cols() ) && ( mtl::size( v ) == m.num_rows() ) ); } }; template< class Value , class MatrixParameters , class VectorParameters > struct resize_impl< mtl::dense2D< Value , MatrixParameters > , mtl::dense_vector< Value , VectorParameters > > { static void resize( mtl::dense2D< Value , MatrixParameters > &m , const mtl::dense_vector< Value , VectorParameters > &v ) { m.change_dim( mtl::size( v ) , mtl::size( v ) , false ); } }; template< class Value , class MatrixParameters , class VectorParameters > struct same_size_impl< mtl::compressed2D< Value , MatrixParameters > , mtl::dense_vector< Value , VectorParameters > > { static bool same_size( const mtl::compressed2D< Value , MatrixParameters > &m , const mtl::dense_vector< Value , VectorParameters > &v ) { return ( ( mtl::size( v ) == m.num_cols() ) && ( mtl::size( v ) == m.num_rows() ) ); } }; template< class Value , class MatrixParameters , class VectorParameters > struct resize_impl< mtl::compressed2D< Value , MatrixParameters > , mtl::dense_vector< Value , VectorParameters > > { static void resize( mtl::compressed2D< Value , MatrixParameters > &m , const mtl::dense_vector< Value , VectorParameters > &v ) { m.change_dim( mtl::size( v ) , mtl::size( v ) ); } }; } // namespace odeint } // namespace numeric } // namespace boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_MTL4_RESIZE_HPP_INCLUDED PK 䄟[C�" " % external/mtl4/implicit_euler_mtl4.hppnu �[��� /* [begin_description] Modification of the implicit Euler method, works with the MTL4 matrix library only. [end_description] Copyright 2012-2013 Andreas Angelopoulos Copyright 2012-2013 Karsten Ahnert Copyright 2012-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_EXTERNAL_IMPLICIT_EULER_MTL4_HPP_INCLUDED #define BOOST_NUMERIC_ODEINT_EXTERNAL_IMPLICIT_EULER_MTL4_HPP_INCLUDED #include <utility> #include <boost/numeric/odeint/util/bind.hpp> #include <boost/numeric/odeint/util/unwrap_reference.hpp> #include <boost/numeric/odeint/stepper/stepper_categories.hpp> #include <boost/numeric/odeint/external/mtl4/mtl4_resize.hpp> #include <boost/numeric/mtl/mtl.hpp> #include <boost/numeric/itl/itl.hpp> namespace boost { namespace numeric { namespace odeint { template< class ValueType , class Resizer = initially_resizer > class implicit_euler_mtl4 { public: typedef ValueType value_type; typedef value_type time_type; typedef mtl::dense_vector<value_type> state_type; typedef state_wrapper< state_type > wrapped_state_type; typedef state_type deriv_type; typedef state_wrapper< deriv_type > wrapped_deriv_type; typedef mtl::compressed2D< value_type > matrix_type; typedef state_wrapper< matrix_type > wrapped_matrix_type; typedef Resizer resizer_type; typedef stepper_tag stepper_category; typedef implicit_euler_mtl4< ValueType , Resizer > stepper_type; implicit_euler_mtl4( const value_type epsilon = 1E-6 ) : m_epsilon( epsilon ) , m_resizer() , m_dxdt() , m_x() , m_identity() , m_jacobi() { } template< class System > void do_step( System system , state_type &x , time_type t , time_type dt ) { typedef typename odeint::unwrap_reference< System >::type system_type; typedef typename odeint::unwrap_reference< typename system_type::first_type >::type deriv_func_type; typedef typename odeint::unwrap_reference< typename system_type::second_type >::type jacobi_func_type; system_type &sys = system; deriv_func_type &deriv_func = sys.first; jacobi_func_type &jacobi_func = sys.second; m_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_impl< state_type > , detail::ref( *this ) , detail::_1 ) ); m_identity.m_v = 1; t += dt; m_x.m_v = x; deriv_func( x , m_dxdt.m_v , t ); jacobi_func( x , m_jacobi.m_v , t ); m_dxdt.m_v *= -dt; m_jacobi.m_v *= dt; m_jacobi.m_v -= m_identity.m_v ; // using ilu_0 preconditioning -incomplete LU factorisation // itl::pc::diagonal<matrix_type,double> L(m_jacobi.m_v); itl::pc::ilu_0<matrix_type> L( m_jacobi.m_v ); solve( m_jacobi.m_v , m_x.m_v , m_dxdt.m_v , L ); x+= m_x.m_v; } template< class StateType > void adjust_size( const StateType &x ) { resize_impl( x ); } private: /* Applying approximate iterative linear solvers default solver is Biconjugate gradient stabilized method itl::bicgstab(A, x, b, L, iter); */ template < class LinearOperator, class HilbertSpaceX, class HilbertSpaceB, class Preconditioner> void solve(const LinearOperator& A, HilbertSpaceX& x, const HilbertSpaceB& b, const Preconditioner& L, int max_iteractions =500) { // Termination criterion: r < 1e-6 * b or N iterations itl::basic_iteration< double > iter( b , max_iteractions , 1e-6 ); itl::bicgstab( A , x , b , L , iter ); } template< class StateIn > bool resize_impl( const StateIn &x ) { bool resized = false; resized |= adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() ); resized |= adjust_size_by_resizeability( m_x , x , typename is_resizeable<state_type>::type() ); resized |= adjust_size_by_resizeability( m_identity , x , typename is_resizeable<matrix_type>::type() ); resized |= adjust_size_by_resizeability( m_jacobi , x , typename is_resizeable<matrix_type>::type() ); return resized; } private: value_type m_epsilon; resizer_type m_resizer; wrapped_deriv_type m_dxdt; wrapped_state_type m_x; wrapped_matrix_type m_identity; wrapped_matrix_type m_jacobi; }; } // odeint } // numeric } // boost #endif // BOOST_NUMERIC_ODEINT_EXTERNAL_IMPLICIT_EULER_MTL4_HPP_INCLUDED PK 䄟[RV�]� � config.hppnu �[��� PK 䄟[43 �� � � util/split.hppnu �[��� PK 䄟[���� � util/resize.hppnu �[��� PK 䄟[��B# 0 util/split_adaptor.hppnu �[��� PK 䄟[�١� �# util/is_pair.hppnu �[��� PK 䄟[=+[n n R' util/copy.hppnu �[��� PK 䄟[4E_$ �/ util/stepper_traits.hppnu �[��� PK 䄟[p�ط� � N6 util/resizer.hppnu �[��� PK 䄟[��Z?� � #> util/bind.hppnu �[��� PK 䄟[�oť � E util/multi_array_adaption.hppnu �[��� PK 䄟[b�q S util/odeint_error.hppnu �[��� PK 䄟[x�C�� � EY util/unit_helper.hppnu �[��� PK 䄟[h� � � f util/same_instance.hppnu �[��� PK 䄟[@ɽ�� � �j util/detail/less_with_sign.hppnu �[��� PK 䄟[ �O�� � �r util/detail/is_range.hppnu �[��� PK 䄟[��I!� � �} util/n_ary_helper.hppnu �[��� PK 䄟[� R�& �& � util/ublas_wrapper.hppnu �[��� PK 䄟[Ѓ� � Ҵ util/same_size.hppnu �[��� PK 䄟[w�~ 6 6 � util/is_resizeable.hppnu �[��� PK 䄟[q�ly� � �� util/unwrap_reference.hppnu �[��� PK 䄟[Q��_J J ]� util/state_wrapper.hppnu �[��� PK 䄟[�I� � �� stepper/euler.hppnu �[��� PK 䄟[r���7 �7 + �� stepper/runge_kutta_cash_karp54_classic.hppnu �[��� PK 䄟[��o�! �! # 2* stepper/runge_kutta_cash_karp54.hppnu �[��� PK 䄟[�c���. �. # iL stepper/adams_bashforth_moulton.hppnu �[��� PK 䄟[��1�r r �{ stepper/stepper_categories.hppnu �[��� PK 䄟[6�g# 9 9 k� stepper/rosenbrock4.hppnu �[��� PK 䄟[�����4 �4 �� stepper/velocity_verlet.hppnu �[��� PK 䄟[<u6b ) �� stepper/symplectic_rkn_sb3a_mclachlan.hppnu �[��� PK 䄟[GLk��8 �8 $ U stepper/dense_output_runge_kutta.hppnu �[��� PK 䄟[����a a �A stepper/symplectic_euler.hppnu �[��� PK 䄟[-'d�`' `' . TQ stepper/controlled_adams_bashforth_moulton.hppnu �[��� PK 䄟[��'� � y stepper/adams_moulton.hppnu �[��� PK 䄟[�ثݠ; �; ;� stepper/adams_bashforth.hppnu �[��� PK 䄟[YH��� � &� stepper/generation.hppnu �[��� PK 䄟[3zL z z " 1� stepper/rosenbrock4_controller.hppnu �[��� PK 䄟[��t t �� stepper/implicit_euler.hppnu �[��� PK 䄟[d����: �: " � stepper/runge_kutta_fehlberg78.hppnu �[��� PK 䄟[r�� ( �? stepper/generation/make_dense_output.hppnu �[��� PK 䄟[�}� � D K stepper/generation/generation_controlled_adams_bashforth_moulton.hppnu �[��� PK 䄟[Nh��N N A ]T stepper/generation/generation_runge_kutta_cash_karp54_classic.hppnu �[��� PK 䄟[�8k - [ stepper/generation/generation_rosenbrock4.hppnu �[��� PK 䄟[�ybL( ( 8 �e stepper/generation/generation_controlled_runge_kutta.hppnu �[��� PK 䄟[N�. 4 n stepper/generation/generation_runge_kutta_dopri5.hppnu �[��� PK 䄟['�� � 8 v stepper/generation/generation_runge_kutta_fehlberg78.hppnu �[��� PK 䄟[��8 8 : �| stepper/generation/generation_dense_output_runge_kutta.hppnu �[��� PK 䄟[�N�� � & E� stepper/generation/make_controlled.hppnu �[��� PK 䄟[�55� � 9 �� stepper/generation/generation_runge_kutta_cash_karp54.hppnu �[��� PK 䄟[���� � ޗ stepper/runge_kutta4.hppnu �[��� PK 䄟[�1�MV V $ � stepper/detail/pid_step_adjuster.hppnu �[��� PK 䄟[�ѬJJ J ' �� stepper/detail/generic_rk_algorithm.hppnu �[��� PK 䄟[�>g>G& G& ( U� stepper/detail/generic_rk_operations.hppnu �[��� PK 䄟[�CҪ) ) * � stepper/detail/generic_rk_call_algebra.hppnu �[��� PK 䄟[d � / g4 stepper/detail/adams_bashforth_call_algebra.hppnu �[��� PK 䄟[:�|� � / �O stepper/detail/adams_bashforth_coefficients.hppnu �[��� PK 䄟[ɿ�BA A - �e stepper/detail/adams_moulton_coefficients.hppnu �[��� PK 䄟[y��> > . l{ stepper/detail/adaptive_adams_coefficients.hppnu �[��� PK 䄟[$��EH H - � stepper/detail/adams_moulton_call_algebra.hppnu �[��� PK 䄟[�U�� � " �� stepper/detail/rotating_buffer.hppnu �[��� PK 䄟[+A$�: : 1 �� stepper/detail/pid_step_adjuster_coefficients.hppnu �[��� PK 䄟[u�� �� �� " �� stepper/controlled_runge_kutta.hppnu �[��� PK 䄟[p��Tw w , �Z stepper/adaptive_adams_bashforth_moulton.hppnu �[��� PK 䄟[�����) �) % Z{ stepper/explicit_error_generic_rk.hppnu �[��� PK 䄟[*w�x� � $ �� stepper/rosenbrock4_dense_output.hppnu �[��� PK 䄟[5X���+ �+ ! �� stepper/extrapolation_stepper.hppnu �[��� PK 䄟[6S , �� stepper/symplectic_rkn_sb3a_m4_mclachlan.hppnu �[��� PK 䄟[���S �S � stepper/runge_kutta_dopri5.hppnu �[��� PK 䄟[�3F) F) ,P stepper/modified_midpoint.hppnu �[��� PK 䄟[�ª�(r (r 1 �y stepper/base/explicit_error_stepper_fsal_base.hppnu �[��� PK 䄟[�.G�� � % H� stepper/base/algebra_stepper_base.hppnu �[��� PK 䄟[�Hp�)@ )@ & s� stepper/base/explicit_stepper_base.hppnu �[��� PK 䄟[����BM BM , �6 stepper/base/symplectic_rkn_stepper_base.hppnu �[��� PK 䄟[���(Lc Lc , �� stepper/base/explicit_error_stepper_base.hppnu �[��� PK 䄟[^e +! +! 8� stepper/explicit_generic_rk.hppnu �[��� PK 䄟[��D D " � stepper/controlled_step_result.hppnu �[��� PK 䄟[��pC� C� $ H stepper/bulirsch_stoer_dense_out.hppnu �[��� PK 䄟[]b�Mf Mf ߒ stepper/bulirsch_stoer.hppnu �[��� PK 䄟[+G��'$ '$ v� stepper/runge_kutta4_classic.hppnu �[��� PK 䄟[k� � � version.hppnu �[��� PK 䄟[CzkU� � �" iterator/adaptive_iterator.hppnu �[��� PK 䄟[E� � � ! > iterator/n_step_time_iterator.hppnu �[��� PK 䄟[�eģ-' -' ( LY iterator/impl/adaptive_iterator_impl.hppnu �[��� PK 䄟[���8 �8 % р iterator/impl/times_iterator_impl.hppnu �[��� PK 䄟[ѹ&sc# c# & �� iterator/impl/n_step_iterator_impl.hppnu �[��� PK 䄟[�~r9�" �" * w� iterator/impl/const_step_iterator_impl.hppnu �[��� PK 䄟[��g�d d % ~ iterator/const_step_time_iterator.hppnu �[��� PK 䄟[dYj$" " 7 iterator/const_step_iterator.hppnu �[��� PK 䄟[8"�fR R �9 iterator/times_iterator.hppnu �[��� PK 䄟[�)B # FX iterator/adaptive_time_iterator.hppnu �[��� PK 䄟[[ [ �t iterator/n_step_iterator.hppnu �[��� PK 䄟[���X X % I� iterator/detail/ode_iterator_base.hppnu �[��� PK 䄟[� yP P ( �� iterator/integrate/integrate_n_steps.hppnu �[��� PK 䄟[�1"_ _ * �� iterator/integrate/observer_collection.hppnu �[��� PK 䄟[ .��> > & W� iterator/integrate/integrate_times.hppnu �[��� PK 䄟[��= = $ �� iterator/integrate/null_observer.hppnu �[��� PK 䄟[�!�4 4 / |� iterator/integrate/detail/integrate_n_steps.hppnu �[��� PK 䄟[ Au� � & � iterator/integrate/detail/functors.hppnu �[��� PK 䄟[$���� � - � iterator/integrate/detail/integrate_times.hppnu �[��� PK 䄟[�6�n n 0 T� iterator/integrate/detail/integrate_adaptive.hppnu �[��� PK 䄟[�vY�� � - " iterator/integrate/detail/integrate_const.hppnu �[��� PK 䄟[EpS�� � ) f iterator/integrate/integrate_adaptive.hppnu �[��� PK 䄟[��L&^ ^ �& iterator/integrate/integrate.hppnu �[��� PK 䄟[B�-> > & ]6 iterator/integrate/integrate_const.hppnu �[��� PK 䄟[�6x{ �K iterator/times_time_iterator.hppnu �[��� PK 䄟[��� � \k algebra/range_algebra.hppnu �[��� PK 䄟[X�l��, �, K� algebra/fusion_algebra.hppnu �[��� PK 䄟[�b��\ �\ 3� algebra/default_operations.hppnu �[��� PK 䄟[x�!�� � s algebra/algebra_dispatcher.hppnu �[��� PK 䄟[Yc��� � � algebra/multi_array_algebra.hppnu �[��� PK 䄟[�y| 5 5 �= algebra/norm_result_type.hppnu �[��� PK 䄟[=�m�n n qA algebra/detail/macros.hppnu �[��� PK 䄟[�w��N N % (F algebra/detail/extract_value_type.hppnu �[��� PK 䄟[���O% O% �K algebra/detail/for_each.hppnu �[��� PK 䄟[d{ώ� � eq algebra/detail/norm_inf.hppnu �[��� PK 䄟[�hHA^* ^* yu algebra/array_algebra.hppnu �[��� PK 䄟[��£� � % � algebra/fusion_algebra_dispatcher.hppnu �[��� PK 䄟[%y�� � _� algebra/vector_space_algebra.hppnu �[��� PK 䄟[�_ � � ! �� algebra/operations_dispatcher.hppnu �[��� PK 䄟[/g��C C �� integrate/integrate_n_steps.hppnu �[��� PK 䄟[�a-_ _ ! S� integrate/observer_collection.hppnu �[��� PK 䄟[��p�� � � integrate/check_adapter.hppnu �[��� PK 䄟[� \u# u# A� integrate/integrate_times.hppnu �[��� PK 䄟[rJ��= = integrate/null_observer.hppnu �[��� PK 䄟[2�Qz� � & �# integrate/detail/integrate_n_steps.hppnu �[��� PK 䄟[ Au� � �: integrate/detail/functors.hppnu �[��� PK 䄟[? I�# # $ �A integrate/detail/integrate_times.hppnu �[��� PK 䄟[���V� � ' Y integrate/detail/integrate_adaptive.hppnu �[��� PK 䄟[2�� � $ Pn integrate/detail/integrate_const.hppnu �[��� PK 䄟[�/ � � �� integrate/integrate_adaptive.hppnu �[��� PK 䄟[��`�% % ʗ integrate/max_step_checker.hppnu �[��� PK 䄟[3?�' =� integrate/integrate.hppnu �[��� PK 䄟[s��� � � integrate/integrate_const.hppnu �[��� PK 䄟[�/�� � + 4� external/eigen/eigen_algebra_dispatcher.hppnu �[��� PK 䄟[��IK� � �� external/eigen/eigen.hppnu �[��� PK 䄟[�G#5/ / �� external/eigen/eigen_resize.hppnu �[��� PK 䄟[��B$� � =� external/eigen/eigen_algebra.hppnu �[��� PK 䄟[�H��� � 2 %� external/compute/compute_operations_dispatcher.hppnu �[��� PK 䄟[37�� � / 9� external/compute/compute_algebra_dispatcher.hppnu �[��� PK 䄟[ ��-" -" ' ) external/compute/compute_operations.hppnu �[��� PK 䄟[w(Z�� � �# external/compute/compute.hppnu �[��� PK 䄟[ ��R� � $ �' external/compute/compute_algebra.hppnu �[��� PK 䄟[�_;� � # 0 external/compute/compute_resize.hppnu �[��� PK 䄟[�ro�� � " ": external/thrust/thrust_algebra.hppnu �[��� PK 䄟[��[� � 5Z external/thrust/thrust.hppnu �[��� PK 䄟[ ( % (^ external/thrust/thrust_operations.hppnu �[��� PK 䄟[�F#:) ) - �{ external/thrust/thrust_algebra_dispatcher.hppnu �[��� PK 䄟[W�!�v v 0 � external/thrust/thrust_operations_dispatcher.hppnu �[��� PK 䄟[���E&! &! ! � external/thrust/thrust_resize.hppnu �[��� PK 䄟[�3�+� � a� external/mpi/mpi_state.hppnu �[��� PK 䄟[�\�"} } =� external/mpi/mpi.hppnu �[��� PK 䄟[�?�\ \ # �� external/mpi/mpi_nested_algebra.hppnu �[��� PK 䄟[B� � � ! �� external/mpi/mpi_vector_state.hppnu �[��� PK 䄟[h� B^ ^ ) �� external/viennacl/viennacl_operations.hppnu �[��� PK 䄟[� Y2 2 % c� external/viennacl/viennacl_resize.hppnu �[��� PK 䄟[#��I �I ) � external/openmp/openmp_nested_algebra.hppnu �[��� PK 䄟[P;#N� � E external/openmp/openmp.hppnu �[��� PK 䄟[�>��T T �H external/openmp/openmp_state.hppnu �[��� PK 䄟[ ��F �F ( t] external/openmp/openmp_range_algebra.hppnu �[��� PK 䄟[|���K K n� external/mkl/mkl_operations.hppnu �[��� PK 䄟[`�\ f f � external/nt2/nt2_resize.hppnu �[��� PK 䄟[�el3~ ~ �� external/nt2/nt2_copy.hppnu �[��� PK 䄟[\��\ ' �� external/nt2/nt2_algebra_dispatcher.hppnu �[��� PK 䄟[���| | �� external/nt2/nt2_norm_inf.hppnu �[��� PK 䄟[p��^� � �� external/vexcl/vexcl_copy.hppnu �[��� PK 䄟[� ��� � ! �� external/vexcl/vexcl_norm_inf.hppnu �[��� PK 䄟[=>�' ' � external/vexcl/vexcl_abs.hppnu �[��� PK 䄟[���� + {� external/vexcl/vexcl_algebra_dispatcher.hppnu �[��� PK 䄟[�=з & �� external/vexcl/vexcl_same_instance.hppnu �[��� PK 䄟[�E� � � _� external/vexcl/vexcl_resize.hppnu �[��� PK 䄟[P��2� � �� external/vexcl/vexcl.hppnu �[��� PK 䄟[W֬ � �� external/blaze/blaze_resize.hppnu �[��� PK 䄟[�\� � + � external/blaze/blaze_algebra_dispatcher.hppnu �[��� PK 䄟[��1]� � � external/gsl/gsl_wrapper.hppnu �[��� PK 䄟[I"`Q� � V external/mtl4/mtl4.hppnu �[��� PK 䄟[���� � ) \# external/mtl4/mtl4_algebra_dispatcher.hppnu �[��� PK 䄟[�#� o. external/mtl4/mtl4_resize.hppnu �[��� PK 䄟[C�" " % �> external/mtl4/implicit_euler_mtl4.hppnu �[��� PK � � �C CQ
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0.02 |
proxy
|
phpinfo
|
???????????