boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/odeint/util/n_ary_helper.hpp

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

package/boost/numeric/odeint/util/odeint_error.hpp

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

package/boost/numeric/odeint/util/resize.hpp

@@ -0,0 +1,120 @@
+/*
+ [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 <type_traits>
+
+#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 , std::true_type ) const
+        {
+            resize( x1 , x2 );
+        }
+
+        template< class StateOut , class StateIn >
+        void resize_op( StateOut &/*x1*/ , const StateIn &/*x2*/ , std::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

package/boost/numeric/odeint/util/resizer.hpp

@@ -0,0 +1,94 @@
+/*
+ [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>
+#include <type_traits>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class ResizeWrappedState , class State >
+bool adjust_size_by_resizeability( ResizeWrappedState &x , const State &y , std::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 */ , std::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

package/boost/numeric/odeint/util/same_instance.hpp

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

package/boost/numeric/odeint/util/same_size.hpp

@@ -0,0 +1,117 @@
+/*
+ [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 <type_traits>
+
+#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 , std::true_type ) const
+    {
+        return same_size( x1 , x2 );
+    }
+
+    template< class S1 , class S2 >
+    bool same_size_op( const S1 &/*x1*/ , const S2 &/*x2*/ , std::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

package/boost/numeric/odeint/util/split.hpp

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