boost.cxx 0.0.2 → 1.90.1

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

@@ -0,0 +1,103 @@
+/*
+ [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/numeric/odeint/tools/assert.hpp>
+#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_NUMERIC_ODEINT_ASSERT( parts > 0 );
+    BOOST_NUMERIC_ODEINT_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

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

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

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

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

package/boost/numeric/odeint/util/ublas_matrix_expression.patch

@@ -0,0 +1,6 @@
+3390,3392c3390
+<     typename enable_if< is_convertible<typename E1::value_type , T2>,
+<                         typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type 
+<                         > ::result_type
+---
+>     typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type

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

@@ -0,0 +1,297 @@
+/*
+ [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 <type_traits>
+
+#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 std::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 std::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 std::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

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

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