整理

include/boost/numeric/odeint/external/blaze/blaze_algebra_dispatcher.hpp

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

include/boost/numeric/odeint/external/blaze/blaze_resize.hpp

@@ -0,0 +1,64 @@
+/*
+  [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>
+
+#include <type_traits>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< typename T , bool TF >
+struct is_resizeable< blaze::DynamicVector< T , TF > > 
+{ 
+    typedef std::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

include/boost/numeric/odeint/external/compute/compute.hpp

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

include/boost/numeric/odeint/external/compute/compute_algebra.hpp

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

include/boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp

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

include/boost/numeric/odeint/external/compute/compute_operations.hpp

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

include/boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp

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

include/boost/numeric/odeint/external/compute/compute_resize.hpp

@@ -0,0 +1,92 @@
+/*
+ [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>
+
+#include <type_traits>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class T, class A >
+struct is_resizeable< boost::compute::vector< T , A > >
+{
+    struct type : public std::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

include/boost/numeric/odeint/external/eigen/eigen.hpp

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

include/boost/numeric/odeint/external/eigen/eigen_algebra.hpp

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

include/boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp

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

include/boost/numeric/odeint/external/eigen/eigen_resize.hpp

@@ -0,0 +1,103 @@
+/*
+  [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 <type_traits>
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+#include <Eigen/Dense>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class Derived >
+struct is_resizeable_sfinae< Derived ,
+                      typename std::enable_if< std::is_base_of< Eigen::MatrixBase< Derived > , Derived >::value >::type >
+{ 
+    typedef std::integral_constant<bool, true> type;
+    const static bool value = type::value;
+};
+
+
+template < class Derived  >
+struct is_resizeable_sfinae< Derived ,
+                      typename std::enable_if< std::is_base_of< Eigen::ArrayBase< Derived > , Derived >::value >::type >
+{ 
+    typedef std::integral_constant<bool, true> type;
+    const static bool value = type::value;
+};
+
+
+
+template< class Derived >
+struct same_size_impl_sfinae< Derived , Derived ,
+                       typename std::enable_if< std::is_base_of< Eigen::MatrixBase< Derived > , Derived >::value >::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 std::enable_if< std::is_base_of< Eigen::ArrayBase< Derived > , Derived >::value >::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 std::enable_if< std::is_base_of< Eigen::MatrixBase< Derived > , Derived >::value >::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 std::enable_if< std::is_base_of< Eigen::ArrayBase< Derived > , Derived >::value >::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

include/boost/numeric/odeint/external/gsl/gsl_wrapper.hpp

@@ -0,0 +1,228 @@
+/*
+ [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/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 std::integral_constant<bool, true> { };
+    typedef std::integral_constant<bool, true> 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

include/boost/numeric/odeint/external/mkl/mkl_operations.hpp

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

include/boost/numeric/odeint/external/mpi/mpi.hpp

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

include/boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp

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

include/boost/numeric/odeint/external/mpi/mpi_state.hpp

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

include/boost/numeric/odeint/external/mpi/mpi_vector_state.hpp

@@ -0,0 +1,95 @@
+/*
+ [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>
+#include <boost/numeric/odeint/tools/assert.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_NUMERIC_ODEINT_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
+

include/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp

@@ -0,0 +1,161 @@
+/*
+[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, [this](auto&& arg) { return this->resize_impl<StateIn>(std::forward<decltype(arg)>(arg)); });
+
+        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

include/boost/numeric/odeint/external/mtl4/mtl4.hpp

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

include/boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp

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

include/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp

@@ -0,0 +1,134 @@
+/*
+[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>
+
+#include <type_traits>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template< class Value , class Parameters >
+struct is_resizeable< mtl::dense_vector< Value , Parameters > >
+{ 
+    typedef std::true_type type;
+    const static bool value = type::value;
+};
+
+template< class Value , class Parameters >
+struct is_resizeable< mtl::dense2D< Value , Parameters > >
+{
+    typedef std::true_type type;
+    const static bool value = type::value;
+};
+
+template< class Value , class Parameters >
+struct is_resizeable< mtl::compressed2D< Value , Parameters > >
+{
+    typedef std::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

include/boost/numeric/odeint/external/nt2/nt2_algebra_dispatcher.hpp

@@ -0,0 +1,25 @@
+//==============================================================================
+//         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

include/boost/numeric/odeint/external/nt2/nt2_copy.hpp

@@ -0,0 +1,33 @@
+//==============================================================================
+//         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

include/boost/numeric/odeint/external/nt2/nt2_norm_inf.hpp

@@ -0,0 +1,31 @@
+//==============================================================================
+//         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

include/boost/numeric/odeint/external/nt2/nt2_resize.hpp

@@ -0,0 +1,54 @@
+//==============================================================================
+//         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>
+
+#include <type_traits>
+
+namespace boost { namespace numeric { namespace odeint {
+
+template<typename T, typename S>
+struct is_resizeable< nt2::container::table<T,S> >
+{
+  typedef std::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

include/boost/numeric/odeint/external/openmp/openmp.hpp

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

include/boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp

@@ -0,0 +1,281 @@
+/*
+ [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/range.hpp>
+#include <boost/numeric/odeint/algebra/norm_result_type.hpp>
+#include <boost/numeric/odeint/util/n_ary_helper.hpp>
+#include <boost/numeric/odeint/tools/assert.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_NUMERIC_ODEINT_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

include/boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp

@@ -0,0 +1,276 @@
+/*
+ [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/range.hpp>
+#include <boost/numeric/odeint/algebra/norm_result_type.hpp>
+#include <boost/numeric/odeint/util/n_ary_helper.hpp>
+#include <boost/numeric/odeint/tools/assert.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_NUMERIC_ODEINT_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

include/boost/numeric/odeint/external/openmp/openmp_state.hpp

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

include/boost/numeric/odeint/external/thrust/thrust.hpp

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

include/boost/numeric/odeint/external/thrust/thrust_algebra.hpp

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

include/boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp

@@ -0,0 +1,118 @@
+/*
+  [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 >= 101000
+
+#include <thrust/detail/vector_base.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct algebra_dispatcher< thrust::detail::vector_base< T , A > >
+    {
+        typedef thrust_algebra algebra_type;
+    };
+} } }
+
+#elif 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
+

include/boost/numeric/odeint/external/thrust/thrust_operations.hpp

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

include/boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp

@@ -0,0 +1,118 @@
+/*
+  [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 >= 101000
+
+#include <thrust/detail/vector_base.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct operations_dispatcher< thrust::detail::vector_base< T , A > >
+    {
+        typedef thrust_operations operations_type;
+    };
+} } }
+
+#elif 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
+

include/boost/numeric/odeint/external/thrust/thrust_resize.hpp

@@ -0,0 +1,197 @@
+/*
+ [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 <type_traits>
+
+#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 std::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 >= 101000
+
+#include <thrust/detail/vector_base.h>
+namespace boost { namespace numeric { namespace odeint {
+    ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::detail::vector_base )
+    ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::detail::vector_base )
+    ODEINT_THRUST_SAME_SIZE_IMPL( thrust::detail::vector_base )
+    ODEINT_THRUST_COPY_IMPL( thrust::detail::vector_base )
+} } }
+
+#elif 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

include/boost/numeric/odeint/external/vexcl/vexcl.hpp

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

include/boost/numeric/odeint/external/vexcl/vexcl_abs.hpp

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

include/boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp

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

include/boost/numeric/odeint/external/vexcl/vexcl_copy.hpp

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

include/boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp

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

include/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp

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

include/boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp

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

include/boost/numeric/odeint/external/viennacl/viennacl_operations.hpp

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

include/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp

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