diff --git a/include/boost/numeric/odeint.hpp b/include/boost/numeric/odeint.hpp
new file mode 100644
index 0000000..e010089
--- /dev/null
+++ b/include/boost/numeric/odeint.hpp
@@ -0,0 +1,84 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint.hpp
+
+ [begin_description]
+ Forward include for odeint. Includes nearly everything.
+ [end_description]
+
+ Copyright 2009-2013 Karsten Ahnert
+ Copyright 2010-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_HPP_INCLUDED
+
+#include <boost/numeric/odeint/version.hpp>
+#include <boost/numeric/odeint/config.hpp>
+
+// start with ublas wrapper because we need its specializations before including state_wrapper.hpp
+#include <boost/numeric/odeint/util/ublas_wrapper.hpp>
+
+#include <boost/numeric/odeint/stepper/euler.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta4_classic.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta4.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp>
+
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+
+#include <boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp>
+
+#include <boost/numeric/odeint/stepper/bulirsch_stoer.hpp>
+
+#ifndef __CUDACC__
+/* Bulirsch Stoer with Dense Output does not compile with nvcc
+ * because of the binomial library used there which relies on unsupported SSE functions
+ */
+#include <boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp>
+#endif
+
+#include <boost/numeric/odeint/stepper/symplectic_euler.hpp>
+#include <boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp>
+#include <boost/numeric/odeint/stepper/velocity_verlet.hpp>
+
+#include <boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp>
+
+#include <boost/numeric/odeint/stepper/implicit_euler.hpp>
+#include <boost/numeric/odeint/stepper/rosenbrock4.hpp>
+#include <boost/numeric/odeint/stepper/rosenbrock4_controller.hpp>
+#include <boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp>
+
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/multi_array_algebra.hpp>
+#include <boost/numeric/odeint/util/multi_array_adaption.hpp>
+/*
+ * Including this algebra slows down the compilation time
+ */
+// #include <boost/numeric/odeint/algebra/fusion_algebra.hpp>
+
+#include <boost/numeric/odeint/integrate/integrate.hpp>
+#include <boost/numeric/odeint/integrate/integrate_adaptive.hpp>
+#include <boost/numeric/odeint/integrate/integrate_const.hpp>
+#include <boost/numeric/odeint/integrate/integrate_n_steps.hpp>
+#include <boost/numeric/odeint/integrate/integrate_times.hpp>
+
+#include <boost/numeric/odeint/integrate/observer_collection.hpp>
+#include <boost/numeric/odeint/integrate/max_step_checker.hpp>
+
+#include <boost/numeric/odeint/stepper/generation.hpp>
+
+#include <boost/numeric/odeint/iterator/adaptive_iterator.hpp>
+#include <boost/numeric/odeint/iterator/adaptive_time_iterator.hpp>
+#include <boost/numeric/odeint/iterator/const_step_iterator.hpp>
+#include <boost/numeric/odeint/iterator/const_step_time_iterator.hpp>
+
+
+#endif // BOOST_NUMERIC_ODEINT_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/algebra/algebra_dispatcher.hpp b/include/boost/numeric/odeint/algebra/algebra_dispatcher.hpp
new file mode 100644
index 0000000..88cf159
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/algebra_dispatcher.hpp
@@ -0,0 +1,110 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/algebra_dispatcher.hpp
+
+ [begin_description]
+ Algebra dispatcher to automatically chose suitable algebra.
+ [end_description]
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_ALGEBRA_DISPATCHER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_ALGEBRA_DISPATCHER_HPP_INCLUDED
+
+#include <boost/numeric/odeint/config.hpp>
+
+#include <complex>
+#include <boost/type_traits/is_floating_point.hpp>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/array_algebra.hpp>
+#include <boost/numeric/odeint/algebra/vector_space_algebra.hpp>
+
+#include <boost/array.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+    
+template< class StateType , class Enabler = void >
+struct algebra_dispatcher_sfinae
+{
+    // range_algebra is the standard algebra
+    typedef range_algebra algebra_type;
+};
+
+template< class StateType >
+struct algebra_dispatcher : algebra_dispatcher_sfinae< StateType > { };
+
+// specialize for array
+template< class T , size_t N >
+struct algebra_dispatcher< boost::array< T , N > >
+{
+    typedef array_algebra algebra_type;
+};
+
+//specialize for some integral types
+template< typename T >
+struct algebra_dispatcher_sfinae< T , typename boost::enable_if< typename boost::is_floating_point< T >::type >::type >
+{
+    typedef vector_space_algebra algebra_type;
+};
+
+template< typename T >
+struct algebra_dispatcher< std::complex<T> >
+{
+    typedef vector_space_algebra algebra_type;
+};
+
+///* think about that again....
+// specialize for ublas vector and matrix types
+template< class T , class A >
+struct algebra_dispatcher< boost::numeric::ublas::vector< T , A > >
+{
+    typedef vector_space_algebra algebra_type;
+};
+
+template< class T , class L , class A >
+struct algebra_dispatcher< boost::numeric::ublas::matrix< T , L , A > >
+{
+    typedef vector_space_algebra algebra_type;
+};
+//*/
+
+}
+}
+}
+
+#ifdef BOOST_NUMERIC_ODEINT_CXX11
+
+// c++11 mode: specialization for std::array if available
+
+#include <array>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+    
+// specialize for std::array
+template< class T , size_t N >
+struct algebra_dispatcher< std::array< T , N > >
+{
+    typedef array_algebra algebra_type;
+};
+
+} } }
+
+#endif
+
+
+#endif
diff --git a/include/boost/numeric/odeint/algebra/array_algebra.hpp b/include/boost/numeric/odeint/algebra/array_algebra.hpp
new file mode 100644
index 0000000..471e866
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/array_algebra.hpp
@@ -0,0 +1,293 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/array_algebra.hpp
+
+ [begin_description]
+ Algebra for Arrays. Highly specialized for odeint. Const arguments are
+ introduce to work with odeint.
+ The Array algebra can be used for Array structures with two template
+ parameters: 
+ Array<T, N>
+ [end_description]
+
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2011-2012 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_ARRAY_ALGEBRA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_ARRAY_ALGEBRA_HPP_INCLUDED
+
+#include <algorithm>
+#include <boost/array.hpp>
+
+#include <boost/numeric/odeint/algebra/norm_result_type.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+struct array_algebra
+{
+    //template< typename T , size_t dim , class Op >
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each1( Array< T, dim > &s1, Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each2( Array< T, dim > &s1, const Array< T, dim > &s2,
+                           Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each3( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] );
+    }
+
+    /* different const signature - required for the scale_sum_swap2 operation */
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each3( Array< T , dim > &s1 ,
+            Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each4( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each5( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each6( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each7( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 ,
+            const Array< T , dim > &s7 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each8( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 ,
+            const Array< T , dim > &s7 ,
+            const Array< T , dim > &s8 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each9( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 ,
+            const Array< T , dim > &s7 ,
+            const Array< T , dim > &s8 ,
+            const Array< T , dim > &s9 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each10( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 ,
+            const Array< T , dim > &s7 ,
+            const Array< T , dim > &s8 ,
+            const Array< T , dim > &s9 ,
+            const Array< T , dim > &s10 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each11( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 ,
+            const Array< T , dim > &s7 ,
+            const Array< T , dim > &s8 ,
+            const Array< T , dim > &s9 ,
+            const Array< T , dim > &s10 ,
+            const Array< T , dim > &s11 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each12( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 ,
+            const Array< T , dim > &s7 ,
+            const Array< T , dim > &s8 ,
+            const Array< T , dim > &s9 ,
+            const Array< T , dim > &s10 ,
+            const Array< T , dim > &s11 ,
+            const Array< T , dim > &s12 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] , s12[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each13( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 ,
+            const Array< T , dim > &s7 ,
+            const Array< T , dim > &s8 ,
+            const Array< T , dim > &s9 ,
+            const Array< T , dim > &s10 ,
+            const Array< T , dim > &s11 ,
+            const Array< T , dim > &s12 ,
+            const Array< T , dim > &s13 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] , s12[i] , s13[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each14( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 ,
+            const Array< T , dim > &s7 ,
+            const Array< T , dim > &s8 ,
+            const Array< T , dim > &s9 ,
+            const Array< T , dim > &s10 ,
+            const Array< T , dim > &s11 ,
+            const Array< T , dim > &s12 ,
+            const Array< T , dim > &s13 ,
+            const Array< T , dim > &s14 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] , s12[i] , s13[i] , s14[i] );
+    }
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim, class Op >
+    static void for_each15( Array< T , dim > &s1 ,
+            const Array< T , dim > &s2 ,
+            const Array< T , dim > &s3 ,
+            const Array< T , dim > &s4 ,
+            const Array< T , dim > &s5 ,
+            const Array< T , dim > &s6 ,
+            const Array< T , dim > &s7 ,
+            const Array< T , dim > &s8 ,
+            const Array< T , dim > &s9 ,
+            const Array< T , dim > &s10 ,
+            const Array< T , dim > &s11 ,
+            const Array< T , dim > &s12 ,
+            const Array< T , dim > &s13 ,
+            const Array< T , dim > &s14 ,
+            const Array< T , dim > &s15 , Op op )
+    {
+        for( size_t i=0 ; i<dim ; ++i )
+            op( s1[i] , s2[i] , s3[i] , s4[i] , s5[i] , s6[i] , s7[i] , s8[i] , s9[i] , s10[i] , s11[i] , s12[i] , s13[i] , s14[i] , s15[i] );
+    }
+
+
+    template < template < typename, size_t > class Array, typename T,
+               size_t dim>
+    static typename norm_result_type< Array< T , dim > >::type norm_inf( const Array< T , dim > &s )
+    {
+        BOOST_USING_STD_MAX();
+        using std::abs;
+        typedef typename norm_result_type< Array< T , dim > >::type result_type;
+        result_type init = static_cast< result_type >( 0 );
+        for( size_t i=0 ; i<dim ; ++i )
+            init = max BOOST_PREVENT_MACRO_SUBSTITUTION ( init , static_cast< result_type >(abs(s[i])) );
+        return init;
+    }
+
+};
+
+}
+}
+}
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_ARRAY_ALGEBRA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/algebra/default_operations.hpp b/include/boost/numeric/odeint/algebra/default_operations.hpp
new file mode 100644
index 0000000..5613908
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/default_operations.hpp
@@ -0,0 +1,599 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/default_operations.hpp
+
+ [begin_description]
+ Default operations. They work with the default numerical types, like float, double, complex< double> ...
+ [end_description]
+
+ Copyright 2010-2012 Karsten Ahnert
+ Copyright 2010-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_DEFAULT_OPERATIONS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_DEFAULT_OPERATIONS_HPP_INCLUDED
+
+#include <algorithm>
+
+#include <boost/config.hpp>
+#include <boost/array.hpp>
+
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+/*
+ * Notes:
+ *
+ * * the results structs are needed in order to work with fusion_algebra
+ */
+struct default_operations
+{
+
+    template< class Fac1 = double >
+    struct scale
+    {
+        const Fac1 m_alpha1;
+
+        scale( Fac1 alpha1 ) : m_alpha1( alpha1 ) { }
+
+        template< class T1 >
+        void operator()( T1 &t1 ) const
+        {
+            t1 *= m_alpha1;
+        }
+
+        typedef void result_type;
+    };
+
+    template< class Fac1 = double >
+    struct scale_sum1
+    {
+        const Fac1 m_alpha1;
+
+        scale_sum1( Fac1 alpha1 ) : m_alpha1( alpha1 ) { }
+
+        template< class T1 , class T2 >
+        void operator()( T1 &t1 , const T2 &t2 ) const
+        {
+            t1 = m_alpha1 * t2;
+        }
+
+        typedef void result_type;
+    };
+
+
+    template< class Fac1 = double , class Fac2 = Fac1 >
+    struct scale_sum2
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+
+        scale_sum2( Fac1 alpha1 , Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { }
+
+        template< class T1 , class T2 , class T3 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3;
+        }
+
+        typedef void result_type;
+    };
+
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 >
+    struct scale_sum3
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+
+        scale_sum3( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 ) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4;
+        }
+
+        typedef void result_type;
+    };
+
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 >
+    struct scale_sum4
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+
+        scale_sum4( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5;
+        }
+
+        typedef void result_type;
+    };
+
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 >
+    struct scale_sum5
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+
+        scale_sum5( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6;
+        }
+
+        typedef void result_type;
+    };
+
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 >
+    struct scale_sum6
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+        const Fac6 m_alpha6;
+
+        scale_sum6( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 , Fac5 alpha5 , Fac6 alpha6 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ){ }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 ,const T7 &t7) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7;
+        }
+
+        typedef void result_type;
+    };
+
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 >
+    struct scale_sum7
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+        const Fac6 m_alpha6;
+        const Fac7 m_alpha7;
+
+        scale_sum7( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ,
+                Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 ) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8;
+        }
+
+        typedef void result_type;
+    };
+
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 >
+    struct scale_sum8
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+        const Fac6 m_alpha6;
+        const Fac7 m_alpha7;
+        const Fac8 m_alpha8;
+
+        scale_sum8( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ,
+                Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 ) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9;
+        }
+
+        typedef void result_type;
+    };
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 >
+    struct scale_sum9
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+        const Fac6 m_alpha6;
+        const Fac7 m_alpha7;
+        const Fac8 m_alpha8;
+        const Fac9 m_alpha9;
+
+        scale_sum9( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ,
+                Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 ) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10;
+        }
+
+        typedef void result_type;
+    };
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 >
+    struct scale_sum10
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+        const Fac6 m_alpha6;
+        const Fac7 m_alpha7;
+        const Fac8 m_alpha8;
+        const Fac9 m_alpha9;
+        const Fac10 m_alpha10;
+
+        scale_sum10( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ,
+                Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 , Fac10 alpha10 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 ) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11;
+        }
+
+        typedef void result_type;
+    };
+
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 , class Fac11 = Fac10 >
+    struct scale_sum11
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+        const Fac6 m_alpha6;
+        const Fac7 m_alpha7;
+        const Fac8 m_alpha8;
+        const Fac9 m_alpha9;
+        const Fac10 m_alpha10;
+        const Fac11 m_alpha11;
+
+        scale_sum11( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ,
+                Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 ,
+                Fac10 alpha10 , Fac11 alpha11 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) , m_alpha11( alpha11 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 , const T12 &t12 ) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11 + m_alpha11 * t12;
+        }
+
+        typedef void result_type;
+    };
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 , class Fac11 = Fac10 , class Fac12 = Fac11 >
+    struct scale_sum12
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+        const Fac6 m_alpha6;
+        const Fac7 m_alpha7;
+        const Fac8 m_alpha8;
+        const Fac9 m_alpha9;
+        const Fac10 m_alpha10;
+        const Fac11 m_alpha11;
+        const Fac12 m_alpha12;
+
+        scale_sum12( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ,
+                Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 ,
+                Fac10 alpha10 , Fac11 alpha11 , Fac12 alpha12 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) , m_alpha11( alpha11 ) , m_alpha12( alpha12 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 , const T12 &t12 , const T13 &t13 ) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11 + m_alpha11 * t12 + m_alpha12 * t13;
+        }
+
+        typedef void result_type;
+    };
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 , class Fac11 = Fac10 , class Fac12 = Fac11 , class Fac13 = Fac12 >
+    struct scale_sum13
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+        const Fac6 m_alpha6;
+        const Fac7 m_alpha7;
+        const Fac8 m_alpha8;
+        const Fac9 m_alpha9;
+        const Fac10 m_alpha10;
+        const Fac11 m_alpha11;
+        const Fac12 m_alpha12;
+        const Fac13 m_alpha13;
+
+        scale_sum13( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ,
+                Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 ,
+                Fac10 alpha10 , Fac11 alpha11 , Fac12 alpha12 , Fac13 alpha13 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) , m_alpha11( alpha11 ) , m_alpha12( alpha12 ) , m_alpha13( alpha13 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 , const T12 &t12 , const T13 &t13 , const T14 &t14 ) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11 + m_alpha11 * t12 + m_alpha12 * t13 + m_alpha13 * t14;
+        }
+
+        typedef void result_type;
+    };
+
+    template< class Fac1 = double , class Fac2 = Fac1 , class Fac3 = Fac2 , class Fac4 = Fac3 , class Fac5 = Fac4 , class Fac6 = Fac5 , class Fac7 = Fac6 , class Fac8 = Fac7 , class Fac9 = Fac8 , class Fac10 = Fac9 , class Fac11 = Fac10 , class Fac12 = Fac11 , class Fac13 = Fac12 , class Fac14 = Fac13 >
+    struct scale_sum14
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+        const Fac3 m_alpha3;
+        const Fac4 m_alpha4;
+        const Fac5 m_alpha5;
+        const Fac6 m_alpha6;
+        const Fac7 m_alpha7;
+        const Fac8 m_alpha8;
+        const Fac9 m_alpha9;
+        const Fac10 m_alpha10;
+        const Fac11 m_alpha11;
+        const Fac12 m_alpha12;
+        const Fac13 m_alpha13;
+        const Fac14 m_alpha14;
+
+        scale_sum14( Fac1 alpha1 , Fac2 alpha2 , Fac3 alpha3 , Fac4 alpha4 ,
+                Fac5 alpha5 , Fac6 alpha6 , Fac7 alpha7 , Fac8 alpha8 , Fac9 alpha9 ,
+                Fac10 alpha10 , Fac11 alpha11 , Fac12 alpha12 , Fac13 alpha13 , Fac14 alpha14 )
+        : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) , m_alpha3( alpha3 ) , m_alpha4( alpha4 ) , m_alpha5( alpha5 ) , m_alpha6( alpha6 ) , m_alpha7( alpha7 ) , m_alpha8( alpha8 ) , m_alpha9( alpha9 ) , m_alpha10( alpha10 ) , m_alpha11( alpha11 ) , m_alpha12( alpha12 ) , m_alpha13( alpha13 ) , m_alpha14( alpha14 ) { }
+
+        template< class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
+        void operator()( T1 &t1 , const T2 &t2 , const T3 &t3 , const T4 &t4 , const T5 &t5 , const T6 &t6 , const T7 &t7 , const T8 &t8 , const T9 &t9 , const T10 &t10 , const T11 &t11 , const T12 &t12 , const T13 &t13 , const T14 &t14 , const T15 &t15 ) const
+        {
+            t1 = m_alpha1 * t2 + m_alpha2 * t3 + m_alpha3 * t4 + m_alpha4 * t5 + m_alpha5 * t6 + m_alpha6 * t7 + m_alpha7 * t8 + m_alpha8 * t9 + m_alpha9 * t10 + m_alpha10 * t11 + m_alpha11 * t12 + m_alpha12 * t13 + m_alpha13 * t14 + m_alpha14 * t15;
+        }
+
+        typedef void result_type;
+    };
+
+    template< class Fac1 = double , class Fac2 = Fac1 >
+    struct scale_sum_swap2
+    {
+        const Fac1 m_alpha1;
+        const Fac2 m_alpha2;
+
+        scale_sum_swap2( Fac1 alpha1 , Fac2 alpha2 ) : m_alpha1( alpha1 ) , m_alpha2( alpha2 ) { }
+
+        template< class T1 , class T2 , class T3 >
+        void operator()( T1 &t1 , T2 &t2 , const T3 &t3) const
+        {
+            const T1 tmp( t1 );
+            t1 = m_alpha1 * t2 + m_alpha2 * t3;
+            t2 = tmp;
+        }
+
+        typedef void result_type;
+    };
+
+    /*
+     * for usage in for_each2
+     *
+     * Works with boost::units by eliminating the unit
+     */
+    template< class Fac1 = double >
+    struct rel_error
+    {
+        const Fac1 m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt;
+
+        rel_error( Fac1 eps_abs , Fac1 eps_rel , Fac1 a_x , Fac1 a_dxdt )
+        : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt ) { }
+
+
+        template< class T1 , class T2 , class T3 >
+        void operator()( T3 &t3 , const T1 &t1 , const T2 &t2 ) const
+        {
+            using std::abs;
+            set_unit_value( t3 , abs( get_unit_value( t3 ) ) / ( m_eps_abs + m_eps_rel * ( m_a_x * abs( get_unit_value( t1 ) ) + m_a_dxdt * abs( get_unit_value( t2 ) ) ) ) );
+        }
+
+        typedef void result_type;
+    };
+
+
+    /*
+     * for usage in for_each3
+     *
+     * used in the controller for the rosenbrock4 method
+     *
+     * Works with boost::units by eliminating the unit
+     */
+    template< class Fac1 = double >
+    struct default_rel_error
+    {
+        const Fac1 m_eps_abs , m_eps_rel ;
+
+        default_rel_error( Fac1 eps_abs , Fac1 eps_rel )
+        : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) { }
+
+
+        /*
+         * xerr = xerr / ( eps_abs + eps_rel * max( x , x_old ) )
+         */
+        template< class T1 , class T2 , class T3 >
+        void operator()( T3 &t3 , const T1 &t1 , const T2 &t2 ) const
+        {
+            BOOST_USING_STD_MAX();
+            using std::abs;
+            Fac1 x1 = abs( get_unit_value( t1 ) ) , x2 = abs( get_unit_value( t2 ) );
+            set_unit_value( t3 , abs( get_unit_value( t3 ) ) / ( m_eps_abs + m_eps_rel * max BOOST_PREVENT_MACRO_SUBSTITUTION ( x1 , x2 ) ) );
+        }
+
+        typedef void result_type;
+    };
+
+
+
+    /*
+     * for usage in reduce
+     */
+
+    template< class Value >
+    struct maximum
+    {
+        template< class Fac1 , class Fac2 >
+        Value operator()( Fac1 t1 , const Fac2 t2 ) const
+        {
+            using std::abs;
+            Value a1 = abs( get_unit_value( t1 ) ) , a2 = abs( get_unit_value( t2 ) );
+            return ( a1 < a2 ) ? a2 : a1 ;
+        }
+
+        typedef Value result_type;
+    };
+
+
+    template< class Fac1 = double >
+    struct rel_error_max
+    {
+        const Fac1 m_eps_abs , m_eps_rel;
+
+        rel_error_max( Fac1 eps_abs , Fac1 eps_rel )
+        : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel )
+        { }
+
+        template< class Res , class T1 , class T2 , class T3 >
+        Res operator()( Res r , const T1 &x_old , const T2 &x , const T3 &x_err )
+        {
+            BOOST_USING_STD_MAX();
+            using std::abs;
+            Res tmp = abs( get_unit_value( x_err ) ) / ( m_eps_abs + m_eps_rel * max BOOST_PREVENT_MACRO_SUBSTITUTION ( abs( x_old ) , abs( x ) ) );
+            return max BOOST_PREVENT_MACRO_SUBSTITUTION ( r , tmp );
+        }
+    };
+
+
+    template< class Fac1 = double >
+    struct rel_error_max2
+    {
+        const Fac1 m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt;
+
+        rel_error_max2( Fac1 eps_abs , Fac1 eps_rel , Fac1 a_x , Fac1 a_dxdt )
+        : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt )
+        { }
+
+        template< class Res , class T1 , class T2 , class T3 , class T4 >
+        Res operator()( Res r , const T1 &x_old , const T2 &/*x*/ , const T3 &dxdt_old , const T4 &x_err )
+        {
+            BOOST_USING_STD_MAX();
+            using std::abs;
+            Res tmp = abs( get_unit_value( x_err ) ) /
+                    ( m_eps_abs + m_eps_rel * ( m_a_x * abs( get_unit_value( x_old ) ) + m_a_dxdt * abs( get_unit_value( dxdt_old ) ) ) );
+            return max BOOST_PREVENT_MACRO_SUBSTITUTION ( r , tmp );
+        }
+    };
+
+
+
+
+    template< class Fac1 = double >
+    struct rel_error_l2
+    {
+        const Fac1 m_eps_abs , m_eps_rel;
+
+        rel_error_l2( Fac1 eps_abs , Fac1 eps_rel )
+        : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel )
+        { }
+
+        template< class Res , class T1 , class T2 , class T3 >
+        Res operator()( Res r , const T1 &x_old , const T2 &x , const T3 &x_err )
+        {
+            BOOST_USING_STD_MAX();
+            using std::abs;
+            Res tmp = abs( get_unit_value( x_err ) ) / ( m_eps_abs + m_eps_rel * max BOOST_PREVENT_MACRO_SUBSTITUTION ( abs( x_old ) , abs( x ) ) );
+            return r + tmp * tmp;
+        }
+    };
+
+
+
+
+    template< class Fac1 = double >
+    struct rel_error_l2_2
+    {
+        const Fac1 m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt;
+
+        rel_error_l2_2( Fac1 eps_abs , Fac1 eps_rel , Fac1 a_x , Fac1 a_dxdt )
+        : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt )
+        { }
+
+        template< class Res , class T1 , class T2 , class T3 , class T4 >
+        Res operator()( Res r , const T1 &x_old , const T2 &/*x*/ , const T3 &dxdt_old , const T4 &x_err )
+        {
+            using std::abs;
+            Res tmp = abs( get_unit_value( x_err ) ) /
+                    ( m_eps_abs + m_eps_rel * ( m_a_x * abs( get_unit_value( x_old ) ) + m_a_dxdt * abs( get_unit_value( dxdt_old ) ) ) );
+            return r + tmp * tmp;
+        }
+    };
+
+
+
+
+
+
+};
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_DEFAULT_OPERATIONS_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/algebra/detail/extract_value_type.hpp b/include/boost/numeric/odeint/algebra/detail/extract_value_type.hpp
new file mode 100644
index 0000000..c5246bb
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/detail/extract_value_type.hpp
@@ -0,0 +1,52 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/detail/extract_value_type.hpp
+
+ [begin_description]
+ Extract true value type from complex types (eg. std::complex)
+ [end_description]
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_EXTRACT_VALUE_TYPE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_EXTRACT_VALUE_TYPE_HPP_INCLUDED
+
+#include <boost/utility.hpp>
+#include <boost/mpl/has_xxx.hpp>
+
+BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< typename S , typename Enabler = void >
+struct extract_value_type {};
+
+// as long as value_types are defined we go down the value_type chain
+// e.g. returning S::value_type::value_type::value_type
+
+template< typename S >
+struct extract_value_type<S , typename boost::disable_if< has_value_type<S> >::type >
+{
+    // no value_type defined, return S
+    typedef S type;
+};
+
+template< typename S >
+struct extract_value_type< S , typename boost::enable_if< has_value_type<S> >::type >
+{
+    // go down the value_type
+    typedef typename extract_value_type< typename S::value_type >::type type;
+};
+
+} } } }
+
+#endif
diff --git a/include/boost/numeric/odeint/algebra/detail/for_each.hpp b/include/boost/numeric/odeint/algebra/detail/for_each.hpp
new file mode 100644
index 0000000..5387a47
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/detail/for_each.hpp
@@ -0,0 +1,165 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/detail/for_each.hpp
+
+ [begin_description]
+ Default for_each implementations.
+ [end_description]
+
+ Copyright 2010-2012 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_FOR_EACH_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_FOR_EACH_HPP_INCLUDED
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+
+    template< class Iterator1 , class Operation >
+    inline void for_each1( Iterator1 first1 , Iterator1 last1 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ );
+    }
+
+
+    template< class Iterator1 , class Iterator2 , class Operation >
+    inline void for_each2( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ );
+    }
+
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Operation >
+    inline void for_each3( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ );
+    }
+
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Operation >
+    inline void for_each4( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3, Iterator4 first4, Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ );
+    }
+
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Operation >
+    inline void for_each5( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                           Iterator4 first4, Iterator5 first5, Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ );
+    }
+
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Operation >
+    inline void for_each6( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                           Iterator4 first4, Iterator5 first5, Iterator6 first6 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ );
+    }
+
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Operation >
+    inline void for_each7( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                           Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ );
+    }
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Operation >
+    inline void for_each8( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                           Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ );
+    }
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Operation >
+    inline void for_each9( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                           Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 ,
+                           Iterator9 first9 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ );
+    }
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Operation >
+    inline void for_each10( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                            Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 ,
+                            Iterator9 first9 , Iterator10 first10 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ );
+    }
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Operation >
+    inline void for_each11( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                            Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 ,
+                            Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ );
+    }
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Iterator12 , class Operation >
+    inline void for_each12( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                            Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 ,
+                            Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Iterator12 first12 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ , *first12++ );
+    }
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Iterator12 , class Iterator13 , class Operation >
+    inline void for_each13( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                            Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 ,
+                            Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Iterator12 first12 , Iterator13 first13 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ , *first12++ , *first13++ );
+    }
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Iterator12 , class Iterator13 , class Iterator14 , class Operation >
+    inline void for_each14( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                            Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 ,
+                            Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Iterator12 first12 , Iterator13 first13 ,
+                            Iterator14 first14 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ , *first12++ , *first13++ , *first14++ );
+    }
+
+    template< class Iterator1 , class Iterator2 , class Iterator3 , class Iterator4 , class Iterator5 , class Iterator6 , class Iterator7 , class Iterator8 , class Iterator9 , class Iterator10 , class Iterator11 , class Iterator12 , class Iterator13 , class Iterator14 , class Iterator15 , class Operation >
+    inline void for_each15( Iterator1 first1 , Iterator1 last1 , Iterator2 first2 , Iterator3 first3,
+                            Iterator4 first4, Iterator5 first5, Iterator6 first6 , Iterator7 first7 , Iterator8 first8 ,
+                            Iterator9 first9 , Iterator10 first10 , Iterator11 first11 , Iterator12 first12 , Iterator13 first13 ,
+                            Iterator14 first14 , Iterator15 first15 , Operation op )
+    {
+        for( ; first1 != last1 ; )
+            op( *first1++ , *first2++ , *first3++ , *first4++ , *first5++ , *first6++ , *first7++ , *first8++ , *first9++ , *first10++ , *first11++ , *first12++ , *first13++ , *first14++ , *first15++ );
+    }
+
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_FOR_EACH_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/algebra/detail/macros.hpp b/include/boost/numeric/odeint/algebra/detail/macros.hpp
new file mode 100644
index 0000000..9e18a8a
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/detail/macros.hpp
@@ -0,0 +1,43 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/detail/macros.hpp
+
+ [begin_description]
+ Some macros for type checking.
+ [end_description]
+
+ Copyright 2010-2012 Karsten Ahnert
+ Copyright 2010 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_MACROS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_MACROS_HPP_INCLUDED
+
+
+//type traits aren't working with nvcc
+#ifndef __CUDACC__
+#include <boost/type_traits.hpp>
+#include <boost/static_assert.hpp>
+
+#define BOOST_ODEINT_CHECK_CONTAINER_TYPE( Type1 , Type2 ) \
+        BOOST_STATIC_ASSERT(( boost::is_same< typename boost::remove_const< Type1 >::type , Type2 >::value ))
+
+#else
+//empty macro for nvcc
+#define BOOST_ODEINT_CHECK_CONTAINER_TYPE( Type1 , Type2 )
+
+#endif // __CUDACC__
+
+
+
+/*
+#define BOOST_ODEINT_CHECK_OPERATION_ARITY( Operation , Arity ) \
+        BOOST_STATIC_ASSERT(( boost::function_traits< Operation >::arity == Arity ))
+ */
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_MACROS_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/algebra/detail/norm_inf.hpp b/include/boost/numeric/odeint/algebra/detail/norm_inf.hpp
new file mode 100644
index 0000000..3d32c99
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/detail/norm_inf.hpp
@@ -0,0 +1,45 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/detail/norm_inf.hpp
+
+ [begin_description]
+ Default reduce implementation.
+ [end_description]
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_NORM_INF_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_NORM_INF_HPP_INCLUDED
+
+#include <cmath>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< typename Value , class Iterator1 >
+inline Value norm_inf( Iterator1 first1 , Iterator1 last1 , Value init )
+{
+    using std::max;
+    using std::abs;
+    for( ; first1 != last1 ; )
+        init = max( init , abs( *first1++ ) );
+    return init;
+}
+
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_DETAIL_NORM_INF_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/algebra/fusion_algebra.hpp b/include/boost/numeric/odeint/algebra/fusion_algebra.hpp
new file mode 100644
index 0000000..0055e5d
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/fusion_algebra.hpp
@@ -0,0 +1,216 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/fusion_algebra.hpp
+
+ [begin_description]
+ Algebra for boost::fusion sequences.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_HPP_INCLUDED
+
+#include <algorithm>
+
+#include <boost/numeric/odeint/config.hpp>
+
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/fusion/view/zip_view.hpp>
+#include <boost/fusion/functional/generation/make_fused.hpp>
+#include <boost/fusion/algorithm/iteration/accumulate.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+namespace detail {
+
+    template< class Value >
+    struct fusion_maximum
+    {
+        template< class Fac1 , class Fac2 >
+        Value operator()( Fac1 t1 , const Fac2 t2 ) const
+        {
+            using std::abs;
+            Value a1 = abs( get_unit_value( t1 ) ) , a2 = abs( get_unit_value( t2 ) );
+            return ( a1 < a2 ) ? a2 : a1 ;
+        }
+
+        typedef Value result_type;
+    };
+}
+
+/* specialize this if the fundamental numeric type in your fusion sequence is
+ * anything else but double (most likely not)
+ */
+template< typename Sequence >
+struct fusion_traits {
+    typedef double value_type;
+};
+
+struct fusion_algebra
+{
+    template< class S1 , class Op >
+    static void for_each1( S1 &s1 , Op op )
+    {
+        boost::fusion::for_each( s1 , op );
+    };
+
+
+    template< class S1 , class S2 , class Op >
+    static void for_each2( S1 &s1 , S2 &s2 , Op op )
+    {
+        typedef boost::fusion::vector< S1& , S2& > Sequences;
+        Sequences sequences( s1 , s2 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+
+    template< class S1 , class S2 , class S3 , class Op >
+    static void for_each3( S1 &s1 , S2 &s2 , S3 &s3 , Op op )
+    {
+        typedef boost::fusion::vector< S1& , S2& , S3& > Sequences;
+        Sequences sequences( s1 , s2 , s3 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class Op >
+    static void for_each4( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op )
+    {
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class Op >
+    static void for_each5( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op )
+    {
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op >
+    static void for_each6( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op )
+    {
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class Op >
+    static void for_each7( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op )
+    {
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class Op >
+    static void for_each8( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op )
+    {
+        BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 8 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" );
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class Op >
+    static void for_each9( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op )
+    {
+        BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 9 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" );
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class Op >
+    static void for_each10( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op )
+    {
+        BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 10 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" );
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class Op >
+    static void for_each11( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op )
+    {
+        BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 11 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" );
+        BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 11 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" );
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op >
+    static void for_each12( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op )
+    {
+        BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 12 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" );
+        BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 12 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" );
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& , S12& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op >
+    static void for_each13( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op )
+    {
+        BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 13 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" );
+        BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 13 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" );
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& , S12& , S13& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op >
+    static void for_each14( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op )
+    {
+        BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 14 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" );
+        BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 14 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" );
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& , S12& , S13& , S14& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 , s14 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class S15 , class Op >
+    static void for_each15( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , S15 &s15 , Op op )
+    {
+        BOOST_STATIC_ASSERT_MSG( BOOST_FUSION_INVOKE_MAX_ARITY >= 15 , "Macro Parameter BOOST_FUSION_INVOKE_MAX_ARITY to small!" );
+        BOOST_STATIC_ASSERT_MSG( BOOST_RESULT_OF_NUM_ARGS >= 15 , "Macro Parameter BOOST_RESULT_OF_NUM_ARGS to small!" );
+        typedef boost::fusion::vector< S1& , S2& , S3& , S4& , S5& , S6& , S7& , S8& , S9& , S10& , S11& , S12& , S13& , S14& , S15& > Sequences;
+        Sequences sequences( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 , s14 , s15 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( op ) );
+    }
+
+    template< class S >
+    static typename fusion_traits< S >::value_type norm_inf( const S &s )
+    {
+        typedef typename fusion_traits< S >::value_type value_type;
+        return boost::fusion::accumulate( s , static_cast<value_type>(0) ,
+                                          detail::fusion_maximum<value_type>() );
+    }
+
+};
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp b/include/boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp
new file mode 100644
index 0000000..4bfc5c2
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp
@@ -0,0 +1,48 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2013 Karsten Ahnert
+  Copyright 2013 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_DISPATCHER_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_DISPATCHER_HPP_DEFINED
+
+#include <boost/numeric/odeint/algebra/fusion_algebra.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/include/is_sequence.hpp>
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+// specialization for fusion sequences
+template< class FusionSequence >
+struct algebra_dispatcher_sfinae< FusionSequence ,
+                           typename boost::enable_if<
+                               typename boost::fusion::traits::is_sequence< FusionSequence >::type >::type >
+{
+    typedef fusion_algebra algebra_type;
+};
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_FUSION_ALGEBRA_DISPATCHER_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/algebra/multi_array_algebra.hpp b/include/boost/numeric/odeint/algebra/multi_array_algebra.hpp
new file mode 100644
index 0000000..0bc476e
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/multi_array_algebra.hpp
@@ -0,0 +1,148 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/algebra/multi_array_algebra.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2009-2012 Karsten Ahnert
+  Copyright 2009-2012 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_MULTI_ARRAY_ALGEBRA_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_MULTI_ARRAY_ALGEBRA_HPP_DEFINED
+
+
+#include <boost/numeric/odeint/algebra/detail/for_each.hpp>
+#include <boost/numeric/odeint/algebra/detail/norm_inf.hpp>
+#include <boost/numeric/odeint/algebra/norm_result_type.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+// not ready
+struct multi_array_algebra
+{
+    template< class S1 , class Op >
+    static void for_each1( S1 &s1 , Op op )
+    {
+        detail::for_each1( s1.data() , s1.data() + s1.num_elements() , op );
+    }
+
+    template< class S1 , class S2 , class Op >
+    static void for_each2( S1 &s1 , S2 &s2 , Op op )
+    {
+        detail::for_each2( s1.data() , s1.data() + s1.num_elements() , s2.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class Op >
+    static void for_each3( S1 &s1 , S2 &s2 , S3 &s3 , Op op )
+    {
+        detail::for_each3( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class Op >
+    static void for_each4( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op )
+    {
+        detail::for_each4( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class Op >
+    static void for_each5( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op )
+    {
+        detail::for_each5( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op >
+    static void for_each6( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op )
+    {
+        detail::for_each6( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class Op >
+    static void for_each7( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op )
+    {
+        detail::for_each7( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class Op >
+    static void for_each8( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op )
+    {
+        detail::for_each8( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class Op >
+    static void for_each9( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op )
+    {
+        detail::for_each9( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class Op >
+    static void for_each10( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op )
+    {
+        detail::for_each10( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class Op >
+    static void for_each11( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op )
+    {
+        detail::for_each11( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op >
+    static void for_each12( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op )
+    {
+        detail::for_each12( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , s12.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op >
+    static void for_each13( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op )
+    {
+        detail::for_each13( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , s12.data() , s13.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op >
+    static void for_each14( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op )
+    {
+        detail::for_each14( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , s12.data() , s13.data() , s14.data() , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class S15 , class Op >
+    static void for_each15( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , S15 &s15 , Op op )
+    {
+        detail::for_each15( s1.data() , s1.data() + s1.num_elements() , s2.data() , s3.data() , s4.data() , s5.data() , s6.data() , s7.data() , s8.data() , s9.data() , s10.data() , s11.data() , s12.data() , s13.data() , s14.data() , s15.data() , op );
+    }
+    
+    template< typename S >
+    static typename norm_result_type<S>::type norm_inf( const S &s )
+    {
+        return detail::norm_inf( s.data() , s.data() + s.num_elements()  , static_cast< typename norm_result_type<S>::type >( 0 ) );
+    }
+};
+
+// template< class T , size_t N >
+// struct algebra_dispatcher< boost::array< T , N > >
+// {
+//     typedef array_algebra algebra_type;
+// };
+
+
+
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_MULTI_ARRAY_ALGEBRA_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/algebra/norm_result_type.hpp b/include/boost/numeric/odeint/algebra/norm_result_type.hpp
new file mode 100644
index 0000000..0e99e8f
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/norm_result_type.hpp
@@ -0,0 +1,33 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/norm_result_type.hpp
+
+ [begin_description]
+ Calculates the type of the norm_inf operation for container types
+ [end_description]
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_NORM_RESULT_TYPE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_NORM_RESULT_TYPE_HPP_INCLUDED
+
+#include <boost/numeric/odeint/algebra/detail/extract_value_type.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< typename S , typename Enabler = void >
+struct norm_result_type {
+    typedef typename detail::extract_value_type< S >::type type;
+};
+
+} } }
+
+#endif
diff --git a/include/boost/numeric/odeint/algebra/operations_dispatcher.hpp b/include/boost/numeric/odeint/algebra/operations_dispatcher.hpp
new file mode 100644
index 0000000..faeb5e8
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/operations_dispatcher.hpp
@@ -0,0 +1,41 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/operations_dispatcher.hpp
+
+ [begin_description]
+ Operations dispatcher to automatically chose suitable operations.
+ [end_description]
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_OPERATIONS_DISPATCHER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_OPERATIONS_DISPATCHER_HPP_INCLUDED
+
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+    
+template< class StateType , class Enabler = void >
+struct operations_dispatcher_sfinae
+{
+    typedef default_operations operations_type;
+};
+
+template< class StateType >
+struct operations_dispatcher : operations_dispatcher_sfinae< StateType > {};
+
+// no further specializations required
+
+}
+}
+}
+
+#endif
diff --git a/include/boost/numeric/odeint/algebra/range_algebra.hpp b/include/boost/numeric/odeint/algebra/range_algebra.hpp
new file mode 100644
index 0000000..3d7695c
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/range_algebra.hpp
@@ -0,0 +1,142 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/range_algebra.hpp
+
+ [begin_description]
+ Default algebra, which works with the most state types, like vector< double >, boost::array< double >, boost::range.
+ Internally is uses boost::range to obtain the begin and end iterator of the according sequence.
+ [end_description]
+
+ Copyright 2010-2013 Karsten Ahnert
+ Copyright 2010-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_RANGE_ALGEBRA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_RANGE_ALGEBRA_HPP_INCLUDED
+
+#include <boost/range.hpp>
+#include <boost/mpl/size_t.hpp>
+
+#include <boost/numeric/odeint/algebra/detail/macros.hpp>
+#include <boost/numeric/odeint/algebra/detail/for_each.hpp>
+#include <boost/numeric/odeint/algebra/detail/norm_inf.hpp>
+#include <boost/numeric/odeint/algebra/norm_result_type.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+struct range_algebra
+{
+    template< class S1 , class Op >
+    static void for_each1( S1 &s1 , Op op )
+    {
+        detail::for_each1( boost::begin( s1 ) , boost::end( s1 ) ,
+                op );
+    }
+
+    template< class S1 , class S2 , class Op >
+    static void for_each2( S1 &s1 , S2 &s2 , Op op )
+    {
+        detail::for_each2( boost::begin( s1 ) , boost::end( s1 ) ,
+                boost::begin( s2 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class Op >
+    static void for_each3( S1 &s1 , S2 &s2 , S3 &s3 , Op op )
+    {
+        detail::for_each3( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class Op >
+    static void for_each4( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op )
+    {
+        detail::for_each4( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class Op >
+    static void for_each5( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op )
+    {
+        detail::for_each5( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op >
+    static void for_each6( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op )
+    {
+        detail::for_each6( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class Op >
+    static void for_each7( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op )
+    {
+        detail::for_each7( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class Op >
+    static void for_each8( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op )
+    {
+        detail::for_each8( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class Op >
+    static void for_each9( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op )
+    {
+        detail::for_each9( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class Op >
+    static void for_each10( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op )
+    {
+        detail::for_each10( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class Op >
+    static void for_each11( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op )
+    {
+        detail::for_each11( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op >
+    static void for_each12( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op )
+    {
+        detail::for_each12( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op >
+    static void for_each13( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op )
+    {
+        detail::for_each13( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , boost::begin( s13 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op >
+    static void for_each14( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op )
+    {
+        detail::for_each14( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , boost::begin( s13 ) , boost::begin( s14 ) , op );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class S15 , class Op >
+    static void for_each15( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , S15 &s15 , Op op )
+    {
+        detail::for_each15( boost::begin( s1 ) , boost::end( s1 ) , boost::begin( s2 ) , boost::begin( s3 ) , boost::begin( s4 ) , boost::begin( s5 ) , boost::begin( s6 ) , boost::begin( s7 ) , boost::begin( s8 ) , boost::begin( s9 ) , boost::begin( s10 ) , boost::begin( s11 ) , boost::begin( s12 ) , boost::begin( s13 ) , boost::begin( s14 ) , boost::begin( s15 ) , op );
+    }
+
+    template< typename S >
+    static typename norm_result_type<S>::type norm_inf( const S &s )
+    {
+        return detail::norm_inf( boost::begin( s ) , boost::end( s ) ,
+                                 static_cast< typename norm_result_type<S>::type >( 0 ) );
+    }
+
+};
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_RANGE_ALGEBRA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/algebra/vector_space_algebra.hpp b/include/boost/numeric/odeint/algebra/vector_space_algebra.hpp
new file mode 100644
index 0000000..17ff007
--- /dev/null
+++ b/include/boost/numeric/odeint/algebra/vector_space_algebra.hpp
@@ -0,0 +1,178 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/algebra/vector_space_algebra.hpp
+
+ [begin_description]
+ An algebra for types which have vector space semantics, hence types on which the operators +,-,* are well defined.
+ [end_description]
+
+ Copyright 2010-2012 Karsten Ahnert
+ Copyright 2010-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ALGEBRA_VECTOR_SPACE_ALGEBRA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ALGEBRA_VECTOR_SPACE_ALGEBRA_HPP_INCLUDED
+
+#include <complex>
+
+#include <boost/type_traits/remove_reference.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/*
+ * This class template has to be overload in order to call vector_space_algebra::norm_inf
+ */
+template< class State > struct vector_space_norm_inf;
+
+/*
+ * Example: instantiation for sole doubles and complex
+ */
+template<>
+struct vector_space_norm_inf< double >
+{
+    typedef double result_type;
+    double operator()( double x ) const
+    {
+        using std::abs;
+        return abs(x);
+    }
+};
+
+template<>
+struct vector_space_norm_inf< float >
+{
+    typedef float result_type;
+    result_type operator()( float x ) const
+    {
+        using std::abs;
+        return abs(x);
+    }
+};
+
+template< typename T >
+struct vector_space_norm_inf< std::complex<T> >
+{
+    typedef T result_type;
+    result_type operator()( std::complex<T> x ) const
+    {
+        using std::abs;
+        return abs( x );
+    }
+};
+
+struct vector_space_algebra
+{
+    template< class S1 , class Op >
+    static void for_each1( S1 &s1 , Op op )
+    {
+        // ToDo : build checks, that the +-*/ operators are well defined
+        op( s1 );
+    }
+
+    template< class S1 , class S2 , class Op >
+    static void for_each2( S1 &s1 , S2 &s2 , Op op )
+    {
+        op( s1 , s2 );
+    }
+
+    template< class S1 , class S2 , class S3 , class Op >
+    static void for_each3( S1 &s1 , S2 &s2 , S3 &s3 , Op op )
+    {
+        op( s1 , s2 , s3 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class Op >
+    static void for_each4( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class Op >
+    static void for_each5( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op >
+    static void for_each6( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class Op >
+    static void for_each7( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 , s7 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class Op >
+    static void for_each8( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class Op >
+    static void for_each9( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class Op >
+    static void for_each10( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class Op >
+    static void for_each11( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op >
+    static void for_each12( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op >
+    static void for_each13( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op >
+    static void for_each14( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 , s14 );
+    }
+
+    template< class S1 , class S2 , class S3 , class S4 , class S5 , class S6 ,class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class S15 , class Op >
+    static void for_each15( S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , S15 &s15 , Op op )
+    {
+        op( s1 , s2 , s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 , s14 , s15 );
+    }
+
+    template< class S >
+    static typename boost::numeric::odeint::vector_space_norm_inf< S >::result_type norm_inf( const S &s )
+    {
+        boost::numeric::odeint::vector_space_norm_inf< S > n;
+        return n( s );
+    }
+};
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ALGEBRA_VECTOR_SPACE_ALGEBRA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/config.hpp b/include/boost/numeric/odeint/config.hpp
new file mode 100644
index 0000000..f191582
--- /dev/null
+++ b/include/boost/numeric/odeint/config.hpp
@@ -0,0 +1,53 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/config.hpp
+
+ [begin_description]
+ Sets configurations for odeint and used libraries. Should be included before any other odeint library
+ [end_description]
+
+ Copyright 2011-2012 Mario Mulansky
+ Copyright 2011-2012 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_CONFIG_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_CONFIG_HPP_INCLUDED
+
+
+//increase macro variable to allow rk78 scheme
+#ifndef FUSION_MAX_VECTOR_SIZE
+#define FUSION_MAX_VECTOR_SIZE 15
+#endif
+
+
+/*
+ * the following definitions are only required if fusion vectors are used as state types
+ * in the rk78 scheme
+ * they should be defined by the user if required, see e.g. libs/numeric/examples/harmonic_oscillator_units.cpp
+ */
+#ifndef BOOST_FUSION_INVOKE_MAX_ARITY
+#define BOOST_FUSION_INVOKE_MAX_ARITY 15
+#endif
+
+#ifndef BOOST_RESULT_OF_NUM_ARGS
+#define BOOST_RESULT_OF_NUM_ARGS 15
+#endif
+
+
+
+
+
+#include <boost/config.hpp>
+
+#if __cplusplus >= 201103L
+#define BOOST_NUMERIC_ODEINT_CXX11 1
+#endif
+
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_CONFIG_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/external/blaze/blaze_algebra_dispatcher.hpp b/include/boost/numeric/odeint/external/blaze/blaze_algebra_dispatcher.hpp
new file mode 100644
index 0000000..29bf786
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/blaze/blaze_resize.hpp b/include/boost/numeric/odeint/external/blaze/blaze_resize.hpp
new file mode 100644
index 0000000..3c5f2d4
--- /dev/null
+++ b/include/boost/numeric/odeint/external/blaze/blaze_resize.hpp
@@ -0,0 +1,62 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/external/blaze/blaze_resize.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2009-2012 Karsten Ahnert
+  Copyright 2009-2012 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_BLAZE_BLAZE_RESIZE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_BLAZE_BLAZE_RESIZE_HPP_INCLUDED
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+#include <blaze/math/dense/DynamicVector.h>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< typename T , bool TF >
+struct is_resizeable< blaze::DynamicVector< T , TF > > 
+{ 
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+template< typename T1 , bool TF1, typename T2 , bool TF2 >
+struct same_size_impl< blaze::DynamicVector< T1 , TF1 > , blaze::DynamicVector< T2 , TF2 > >
+{
+    static bool same_size( const blaze::DynamicVector< T1 , TF1 > &x1 , const blaze::DynamicVector< T2 , TF2 > &x2 )
+    {
+        return x1.size() == x2.size();
+    }
+};
+
+template< typename T1 , bool TF1, typename T2 , bool TF2 >
+struct resize_impl< blaze::DynamicVector< T1 , TF1 > , blaze::DynamicVector< T2 , TF2 > >
+{
+    static void resize( blaze::DynamicVector< T1 , TF1 > &x1 , const blaze::DynamicVector< T2 , TF2 > &x2 )
+    {
+        x1.resize( x2.size() );
+    }
+};
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_BLAZE_BLAZE_RESIZE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/external/compute/compute.hpp b/include/boost/numeric/odeint/external/compute/compute.hpp
new file mode 100644
index 0000000..fe04b58
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/compute/compute_algebra.hpp b/include/boost/numeric/odeint/external/compute/compute_algebra.hpp
new file mode 100644
index 0000000..9cd3912
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp b/include/boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp
new file mode 100644
index 0000000..6df360b
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/compute/compute_operations.hpp b/include/boost/numeric/odeint/external/compute/compute_operations.hpp
new file mode 100644
index 0000000..58d5f69
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp b/include/boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp
new file mode 100644
index 0000000..76df2f3
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/compute/compute_resize.hpp b/include/boost/numeric/odeint/external/compute/compute_resize.hpp
new file mode 100644
index 0000000..013a7ac
--- /dev/null
+++ b/include/boost/numeric/odeint/external/compute/compute_resize.hpp
@@ -0,0 +1,90 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/external/compute/compute_resize.hpp
+
+ [begin_description]
+ Enable resizing for Boost.Compute vector
+ [end_description]
+
+ Copyright 2009-2011 Karsten Ahnert
+ Copyright 2009-2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_RESIZE_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_RESIZE_HPP_DEFINED
+
+#include <boost/compute/container/vector.hpp>
+
+#include <boost/numeric/odeint/util/copy.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class T, class A >
+struct is_resizeable< boost::compute::vector< T , A > >
+{
+    struct type : public boost::true_type { };
+    const static bool value = type::value;
+};
+
+template< class T, class A >
+struct same_size_impl< boost::compute::vector< T, A > , boost::compute::vector< T, A > >
+{
+    static bool same_size( const boost::compute::vector< T, A > &x , const boost::compute::vector< T, A > &y )
+    {
+        return x.size() == y.size();
+    }
+};
+
+template< class T, class A >
+struct resize_impl< boost::compute::vector< T, A > , boost::compute::vector< T, A > >
+{
+    static void resize( boost::compute::vector< T, A > &x , const boost::compute::vector< T, A > &y )
+    {
+        x.resize( y.size() );
+    }
+};
+
+
+template< class Container1, class T, class A >
+struct copy_impl< Container1 , boost::compute::vector< T, A > >
+{
+    static void copy( const Container1 &from , boost::compute::vector< T, A > &to )
+    {
+        boost::compute::copy( boost::begin( from ) , boost::end( from ) , boost::begin( to ) );
+    }
+};
+
+template< class T, class A, class Container2 >
+struct copy_impl< boost::compute::vector< T, A > , Container2 >
+{
+    static void copy( const boost::compute::vector< T, A > &from , Container2 &to )
+    {
+        boost::compute::copy( boost::begin( from ) , boost::end( from ) , boost::begin( to ) );
+    }
+};
+
+template< class T, class A >
+struct copy_impl< boost::compute::vector< T, A > , boost::compute::vector< T, A > >
+{
+    static void copy( const boost::compute::vector< T, A > &from , boost::compute::vector< T, A > &to )
+    {
+        boost::compute::copy( boost::begin( from ) , boost::end( from ) , boost::begin( to ) );
+    }
+};
+
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_RESIZE_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/external/eigen/eigen.hpp b/include/boost/numeric/odeint/external/eigen/eigen.hpp
new file mode 100644
index 0000000..620acae
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/eigen/eigen_algebra.hpp b/include/boost/numeric/odeint/external/eigen/eigen_algebra.hpp
new file mode 100644
index 0000000..b4ee5c3
--- /dev/null
+++ b/include/boost/numeric/odeint/external/eigen/eigen_algebra.hpp
@@ -0,0 +1,109 @@
+/*
+  [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::CwiseUnaryOp<
+          typename Eigen::internal::scalar_add_op<
+               typename Eigen::internal::traits<D>::Scalar>,
+          const D >
+operator+(const typename Eigen::MatrixBase<D> &m,
+          const typename Eigen::internal::traits<D>::Scalar &s) {
+     return Eigen::CwiseUnaryOp<
+          typename Eigen::internal::scalar_add_op<
+               typename Eigen::internal::traits<D>::Scalar>,
+          const D >(m.derived(),Eigen::internal::scalar_add_op<
+                    typename Eigen::internal::traits<D>::Scalar>(s));
+}
+
+template<typename D>
+inline const
+typename Eigen::CwiseUnaryOp<
+          typename Eigen::internal::scalar_add_op<
+               typename Eigen::internal::traits<D>::Scalar>,
+          const D >
+operator+(const typename Eigen::internal::traits<D>::Scalar &s,
+const typename Eigen::MatrixBase<D> &m) {
+     return Eigen::CwiseUnaryOp<
+          typename Eigen::internal::scalar_add_op<
+               typename Eigen::internal::traits<D>::Scalar>,
+          const D >(m.derived(),Eigen::internal::scalar_add_op<
+                    typename Eigen::internal::traits<D>::Scalar>(s));
+}
+
+
+
+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
diff --git a/include/boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp b/include/boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp
new file mode 100644
index 0000000..6c8a3a2
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/eigen/eigen_resize.hpp b/include/boost/numeric/odeint/external/eigen/eigen_resize.hpp
new file mode 100644
index 0000000..1989cc3
--- /dev/null
+++ b/include/boost/numeric/odeint/external/eigen/eigen_resize.hpp
@@ -0,0 +1,107 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/external/eigen/eigen_resize.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2013 Ankur Sinha
+  Copyright 2013 Karsten Ahnert
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_RESIZE_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_RESIZE_HPP_DEFINED
+
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+#include <Eigen/Dense>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+template< class Derived >
+struct is_resizeable_sfinae< Derived ,
+                      typename boost::enable_if< typename boost::is_base_of< Eigen::MatrixBase< Derived > , Derived >::type >::type >
+{ 
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+
+template < class Derived  >
+struct is_resizeable_sfinae< Derived ,
+                      typename boost::enable_if< typename boost::is_base_of< Eigen::ArrayBase< Derived > , Derived >::type >::type >
+{ 
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+
+
+template< class Derived >
+struct same_size_impl_sfinae< Derived , Derived ,
+                       typename boost::enable_if< typename boost::is_base_of< Eigen::MatrixBase< Derived > , Derived >::type >::type >
+{
+    static bool same_size( const Eigen::MatrixBase< Derived > &m1 , const Eigen::MatrixBase< Derived > &m2 )
+
+    {
+        return ( ( m1.innerSize () == m2.innerSize () ) && ( m1.outerSize() == m2.outerSize() ) );
+    }
+};
+
+template< class Derived  >
+struct same_size_impl_sfinae< Derived , Derived ,
+                       typename boost::enable_if< typename boost::is_base_of< Eigen::ArrayBase< Derived > , Derived >::type >::type >
+{
+    static bool same_size( const Eigen::ArrayBase< Derived > &v1 , const Eigen::ArrayBase< Derived >  &v2 )
+    {
+        return  ( ( v1.innerSize () == v2.innerSize () ) && ( v1.outerSize() == v2.outerSize() ) );
+    }
+};
+
+
+
+
+template< class Derived >
+struct resize_impl_sfinae< Derived , Derived ,
+                    typename boost::enable_if< typename boost::is_base_of< Eigen::MatrixBase< Derived > , Derived >::type >::type >
+{
+    static void resize( Eigen::MatrixBase< Derived > &m1 , const Eigen::MatrixBase< Derived > &m2 )
+    {
+        m1.derived().resizeLike(m2);
+    }
+};
+
+template< class Derived >
+struct resize_impl_sfinae< Derived , Derived ,
+                    typename boost::enable_if< typename boost::is_base_of< Eigen::ArrayBase< Derived > , Derived >::type >::type >
+{
+    static void resize( Eigen::ArrayBase< Derived > &v1 , const Eigen::ArrayBase< Derived > &v2 )
+    {
+        v1.derived().resizeLike(v2);
+    }
+};
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_EIGEN_EIGEN_RESIZE_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/external/gsl/gsl_wrapper.hpp b/include/boost/numeric/odeint/external/gsl/gsl_wrapper.hpp
new file mode 100644
index 0000000..a856f6e
--- /dev/null
+++ b/include/boost/numeric/odeint/external/gsl/gsl_wrapper.hpp
@@ -0,0 +1,229 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/external/gsl/gsl_wrapper.hpp
+
+ [begin_description]
+ Wrapper for gsl_vector.
+ [end_description]
+
+ Copyright 2011-2012 Mario Mulansky
+ Copyright 2011 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_GSL_GSL_WRAPPER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_GSL_GSL_WRAPPER_HPP_INCLUDED
+
+#include <new>
+
+#include <gsl/gsl_vector.h>
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/range.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+
+class const_gsl_vector_iterator;
+
+/*
+ * defines an iterator for gsl_vector
+ */
+class gsl_vector_iterator : public boost::iterator_facade< gsl_vector_iterator , double , boost::random_access_traversal_tag >
+{
+public :
+
+    gsl_vector_iterator( void ): m_p(0) , m_stride( 0 ) { }
+    explicit gsl_vector_iterator( gsl_vector *p ) : m_p( p->data ) , m_stride( p->stride ) { }
+    friend gsl_vector_iterator end_iterator( gsl_vector * );
+
+private :
+
+    friend class boost::iterator_core_access;
+    friend class const_gsl_vector_iterator;
+
+    void increment( void ) { m_p += m_stride; }
+    void decrement( void ) { m_p -= m_stride; }
+    void advance( ptrdiff_t n ) { m_p += n*m_stride; }
+    bool equal( const gsl_vector_iterator &other ) const { return this->m_p == other.m_p; }
+    bool equal( const const_gsl_vector_iterator &other ) const;
+    double& dereference( void ) const { return *m_p; }
+
+    double *m_p;
+    size_t m_stride;
+};
+
+
+
+/*
+ * defines an const iterator for gsl_vector
+ */
+class const_gsl_vector_iterator : public boost::iterator_facade< const_gsl_vector_iterator , const double , boost::random_access_traversal_tag >
+{
+public :
+
+    const_gsl_vector_iterator( void ): m_p(0) , m_stride( 0 ) { }
+    explicit const_gsl_vector_iterator( const gsl_vector *p ) : m_p( p->data ) , m_stride( p->stride ) { }
+    const_gsl_vector_iterator( const gsl_vector_iterator &p ) : m_p( p.m_p ) , m_stride( p.m_stride ) { }
+
+private :
+
+    friend class boost::iterator_core_access;
+    friend class gsl_vector_iterator;
+    friend const_gsl_vector_iterator end_iterator( const gsl_vector * );
+
+    void increment( void ) { m_p += m_stride; }
+    void decrement( void ) { m_p -= m_stride; }
+    void advance( ptrdiff_t n ) { m_p += n*m_stride; }
+    bool equal( const const_gsl_vector_iterator &other ) const { return this->m_p == other.m_p; }
+    bool equal( const gsl_vector_iterator &other ) const { return this->m_p == other.m_p; }
+    const double& dereference( void ) const { return *m_p; }
+
+    const double *m_p;
+    size_t m_stride;
+};
+
+
+bool gsl_vector_iterator::equal( const const_gsl_vector_iterator &other ) const { return this->m_p == other.m_p; }
+
+
+gsl_vector_iterator end_iterator( gsl_vector *x )
+{
+    gsl_vector_iterator iter( x );
+    iter.m_p += iter.m_stride * x->size;
+    return iter;
+}
+
+const_gsl_vector_iterator end_iterator( const gsl_vector *x )
+{
+    const_gsl_vector_iterator iter( x );
+    iter.m_p += iter.m_stride * x->size;
+    return iter;
+}
+
+
+
+
+namespace boost
+{
+template<>
+struct range_mutable_iterator< gsl_vector* >
+{
+    typedef gsl_vector_iterator type;
+};
+
+template<>
+struct range_const_iterator< gsl_vector* >
+{
+    typedef const_gsl_vector_iterator type;
+};
+} // namespace boost
+
+
+
+
+// template<>
+inline gsl_vector_iterator range_begin( gsl_vector *x )
+{
+    return gsl_vector_iterator( x );
+}
+
+// template<>
+inline const_gsl_vector_iterator range_begin( const gsl_vector *x )
+{
+    return const_gsl_vector_iterator( x );
+}
+
+// template<>
+inline gsl_vector_iterator range_end( gsl_vector *x )
+{
+    return end_iterator( x );
+}
+
+// template<>
+inline const_gsl_vector_iterator range_end( const gsl_vector *x )
+{
+    return end_iterator( x );
+}
+
+
+
+
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template<>
+struct is_resizeable< gsl_vector* >
+{
+    //struct type : public boost::true_type { };
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+template <>
+struct same_size_impl< gsl_vector* , gsl_vector* >
+{
+    static bool same_size( const gsl_vector* x , const gsl_vector* y )
+    {
+        return x->size == y->size;
+    }
+};
+
+template <>
+struct resize_impl< gsl_vector* , gsl_vector* >
+{
+    static void resize( gsl_vector* &x , const gsl_vector* y )
+    {
+        gsl_vector_free( x );
+        x = gsl_vector_alloc( y->size );
+    }
+};
+
+template<>
+struct state_wrapper< gsl_vector* >
+{
+    typedef double value_type;
+    typedef gsl_vector* state_type;
+    typedef state_wrapper< gsl_vector* > state_wrapper_type;
+
+    state_type m_v;
+
+    state_wrapper( )
+    {
+        m_v = gsl_vector_alloc( 1 );
+    }
+
+    state_wrapper( const state_wrapper_type &x )
+    {
+        resize( m_v , x.m_v );
+        gsl_vector_memcpy( m_v , x.m_v );
+    }
+
+
+    ~state_wrapper()
+    {
+        gsl_vector_free( m_v );
+    }
+
+};
+
+} // odeint
+} // numeric
+} // boost
+
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_GSL_GSL_WRAPPER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/external/mkl/mkl_operations.hpp b/include/boost/numeric/odeint/external/mkl/mkl_operations.hpp
new file mode 100644
index 0000000..59ac4b8
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/mpi/mpi.hpp b/include/boost/numeric/odeint/external/mpi/mpi.hpp
new file mode 100644
index 0000000..26e1ae9
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp b/include/boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp
new file mode 100644
index 0000000..5d90225
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/mpi/mpi_state.hpp b/include/boost/numeric/odeint/external/mpi/mpi_state.hpp
new file mode 100644
index 0000000..aba179c
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/mpi/mpi_vector_state.hpp b/include/boost/numeric/odeint/external/mpi/mpi_vector_state.hpp
new file mode 100644
index 0000000..096d40a
--- /dev/null
+++ b/include/boost/numeric/odeint/external/mpi/mpi_vector_state.hpp
@@ -0,0 +1,94 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/external/mpi/mpi_vector_state.hpp
+
+ [begin_description]
+ Copying a container from/to an mpi_state splits/joins it.
+ [end_description]
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+ Copyright 2013 Pascal Germroth
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_MPI_MPI_VECTOR_STATE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_MPI_MPI_VECTOR_STATE_HPP_INCLUDED
+
+#include <vector>
+#include <algorithm>
+#include <boost/mpi.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+#include <boost/numeric/odeint/util/split_adaptor.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/external/mpi/mpi_state.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/** \brief Split data from some container on node 0 to the slaves.
+ * Source must be a model of Random Access Range. */
+template< class Source , class InnerState >
+struct split_impl< Source, mpi_state< InnerState >,
+    typename boost::enable_if< boost::has_range_const_iterator<Source> >::type >
+{
+    typedef typename boost::range_iterator<const Source>::type iterator;
+
+    static void split( const Source &from, mpi_state< InnerState > &to )
+    {
+        std::vector< InnerState > pieces;
+        if(to.world.rank() == 0) {
+            const size_t num = static_cast<size_t>(to.world.size());
+            pieces.resize(num);
+            for(size_t i = 0 ; i < num ; i++) {
+                iterator_range<iterator> part = detail::make_split_range(from, i, num);
+                boost::numeric::odeint::resize(pieces[i], part);
+                boost::numeric::odeint::copy(part, pieces[i]);
+            }
+        }
+        // send to nodes
+        boost::mpi::scatter(to.world, pieces, to(), 0);
+    }
+};
+
+/** \brief Merge data from an mpi_state to some container on node 0.
+ * Target must be a model Single Pass Range. */
+template< class Target, class InnerState >
+struct unsplit_impl< mpi_state< InnerState >, Target,
+    typename boost::enable_if< boost::has_range_iterator<Target> >::type >
+{
+    typedef typename boost::range_iterator<Target>::type iterator;
+
+    static void unsplit( const mpi_state< InnerState > &from , Target &to )
+    {
+        std::vector< InnerState > pieces;
+        // send data to root
+        boost::mpi::gather(from.world, from(), pieces, 0);
+        if(from.world.rank() == 0) {
+            // check target size
+            size_t total_size = 0;
+            for(size_t i = 0 ; i < pieces.size() ; i++)
+                total_size += boost::size(pieces[i]);
+            BOOST_ASSERT( total_size <= boost::size(to) );
+            // copy parts
+            iterator out = boost::begin(to);
+            for(size_t i = 0 ; i < pieces.size() ; i++)
+                out = boost::copy(pieces[i], out);
+        }
+    }
+};
+
+
+}
+}
+}
+
+
+#endif
+
diff --git a/include/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp b/include/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp
new file mode 100644
index 0000000..a3f0350
--- /dev/null
+++ b/include/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp
@@ -0,0 +1,162 @@
+/*
+[begin_description]
+Modification of the implicit Euler method, works with the MTL4 matrix library only. 
+[end_description]
+
+Copyright 2012-2013 Andreas Angelopoulos
+Copyright 2012-2013 Karsten Ahnert
+Copyright 2012-2013 Mario Mulansky
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or
+copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_IMPLICIT_EULER_MTL4_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_IMPLICIT_EULER_MTL4_HPP_INCLUDED
+
+
+#include <utility>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/external/mtl4/mtl4_resize.hpp>
+
+#include <boost/numeric/mtl/mtl.hpp>
+#include <boost/numeric/itl/itl.hpp>
+
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template< class ValueType , class Resizer = initially_resizer >
+class implicit_euler_mtl4
+{
+
+public:
+
+    typedef ValueType value_type;
+    typedef value_type time_type;
+    typedef mtl::dense_vector<value_type> state_type;
+
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef state_type deriv_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef mtl::compressed2D< value_type > matrix_type;
+    typedef state_wrapper< matrix_type > wrapped_matrix_type;
+
+    typedef Resizer resizer_type;
+    typedef stepper_tag stepper_category;
+
+    typedef implicit_euler_mtl4< ValueType , Resizer > stepper_type;
+
+
+    implicit_euler_mtl4( const value_type epsilon = 1E-6 )
+        : m_epsilon( epsilon ) , m_resizer() ,
+          m_dxdt() , m_x() ,
+          m_identity() , m_jacobi()
+    { }
+
+
+    template< class System >
+    void do_step( System system , state_type &x , time_type t , time_type dt )
+    {
+        typedef typename odeint::unwrap_reference< System >::type system_type;
+        typedef typename odeint::unwrap_reference< typename system_type::first_type >::type deriv_func_type;
+        typedef typename odeint::unwrap_reference< typename system_type::second_type >::type jacobi_func_type;
+        system_type &sys = system;
+        deriv_func_type &deriv_func = sys.first;
+        jacobi_func_type &jacobi_func = sys.second;
+
+        m_resizer.adjust_size( x , detail::bind(
+                                   &stepper_type::template resize_impl< state_type > , detail::ref( *this ) , detail::_1 ) );
+
+        m_identity.m_v = 1;
+
+        t += dt;
+        m_x.m_v = x;
+
+        deriv_func( x , m_dxdt.m_v , t );
+        jacobi_func( x , m_jacobi.m_v , t );
+
+
+        m_dxdt.m_v *= -dt;
+
+        m_jacobi.m_v *= dt;
+        m_jacobi.m_v -= m_identity.m_v ;
+
+
+
+        // using ilu_0 preconditioning -incomplete LU factorisation
+        // itl::pc::diagonal<matrix_type,double> L(m_jacobi.m_v);
+        itl::pc::ilu_0<matrix_type> L( m_jacobi.m_v );
+
+        solve( m_jacobi.m_v , m_x.m_v , m_dxdt.m_v , L );
+        x+= m_x.m_v;
+
+
+    }
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_impl( x );
+    }
+
+
+private:
+
+
+    /*
+      Applying approximate iterative linear solvers
+      default solver is Biconjugate gradient stabilized method
+      itl::bicgstab(A, x, b, L, iter);
+    */
+    template < class LinearOperator, class HilbertSpaceX, class HilbertSpaceB, class Preconditioner>
+    void solve(const LinearOperator& A, HilbertSpaceX& x, const HilbertSpaceB& b,
+               const Preconditioner& L, int max_iteractions =500)
+    {
+        // Termination criterion: r < 1e-6 * b or N iterations
+        itl::basic_iteration< double > iter( b , max_iteractions , 1e-6 );
+        itl::bicgstab( A , x , b , L , iter );
+
+    }
+
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_identity , x , typename is_resizeable<matrix_type>::type() );
+        resized |= adjust_size_by_resizeability( m_jacobi , x , typename is_resizeable<matrix_type>::type() );
+        return resized;
+    }
+
+
+private:
+
+    value_type m_epsilon;
+    resizer_type m_resizer;
+    wrapped_deriv_type m_dxdt;
+    wrapped_state_type m_x;
+    wrapped_matrix_type m_identity;
+    wrapped_matrix_type m_jacobi;
+};
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_IMPLICIT_EULER_MTL4_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/external/mtl4/mtl4.hpp b/include/boost/numeric/odeint/external/mtl4/mtl4.hpp
new file mode 100644
index 0000000..9b9ebf7
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp b/include/boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp
new file mode 100644
index 0000000..8f6bfbe
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp b/include/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp
new file mode 100644
index 0000000..6295c03
--- /dev/null
+++ b/include/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp
@@ -0,0 +1,133 @@
+/*
+[begin_description]
+Modification of the implicit Euler method, works with the MTL4 matrix library only. 
+[end_description]
+
+Copyright 2012-2013 Andreas Angelopoulos
+Copyright 2012-2013 Karsten Ahnert
+Copyright 2012-2013 Mario Mulansky
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or
+copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_MTL4_RESIZE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_MTL4_RESIZE_HPP_INCLUDED
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+#include <boost/numeric/mtl/vector/dense_vector.hpp>
+#include <boost/numeric/mtl/matrix/dense2D.hpp>
+#include <boost/numeric/mtl/matrix/compressed2D.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template< class Value , class Parameters >
+struct is_resizeable< mtl::dense_vector< Value , Parameters > >
+{ 
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+template< class Value , class Parameters >
+struct is_resizeable< mtl::dense2D< Value , Parameters > >
+{
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+template< class Value , class Parameters >
+struct is_resizeable< mtl::compressed2D< Value , Parameters > >
+{
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+
+
+
+template< class Value , class Parameters >
+struct same_size_impl< mtl::dense_vector< Value , Parameters > , mtl::dense_vector< Value , Parameters > >
+{
+    static bool same_size( const mtl::dense_vector< Value , Parameters > &v1 ,
+                           const mtl::dense_vector< Value , Parameters > &v2 )
+    {
+        return mtl::size( v1 ) == mtl::size( v2 );
+    }
+};
+
+template< class Value , class Parameters >
+struct resize_impl< mtl::dense_vector< Value , Parameters > , mtl::dense_vector< Value , Parameters > >
+{
+    static void resize( mtl::dense_vector< Value , Parameters > &v1 ,
+                        const mtl::dense_vector< Value , Parameters > &v2 )
+    {
+        v1.change_dim( mtl::size( v2 ) );
+    }
+};
+
+
+
+template< class Value , class MatrixParameters , class VectorParameters >
+struct same_size_impl< mtl::dense2D< Value , MatrixParameters > , mtl::dense_vector< Value , VectorParameters > >
+{
+    static bool same_size( const mtl::dense2D< Value , MatrixParameters > &m , 
+                           const mtl::dense_vector< Value , VectorParameters > &v )
+    {
+        return ( ( mtl::size( v ) == m.num_cols() ) && ( mtl::size( v ) == m.num_rows() ) );
+    }
+};
+
+template< class Value , class MatrixParameters , class VectorParameters >
+struct resize_impl< mtl::dense2D< Value , MatrixParameters > , mtl::dense_vector< Value , VectorParameters > >
+{
+    static void resize( mtl::dense2D< Value , MatrixParameters > &m , 
+                        const mtl::dense_vector< Value , VectorParameters > &v )
+    {
+        m.change_dim( mtl::size( v ) , mtl::size( v ) , false );
+    }
+};
+
+
+
+
+template< class Value , class MatrixParameters , class VectorParameters >
+struct same_size_impl< mtl::compressed2D< Value , MatrixParameters > , mtl::dense_vector< Value , VectorParameters > >
+{
+    static bool same_size( const mtl::compressed2D< Value , MatrixParameters > &m , 
+                           const mtl::dense_vector< Value , VectorParameters > &v )
+    {
+        return ( ( mtl::size( v ) == m.num_cols() ) && ( mtl::size( v ) == m.num_rows() ) );
+    }
+};
+
+template< class Value , class MatrixParameters , class VectorParameters >
+struct resize_impl< mtl::compressed2D< Value , MatrixParameters > , mtl::dense_vector< Value , VectorParameters > >
+{
+    static void resize( mtl::compressed2D< Value , MatrixParameters > &m , 
+                        const mtl::dense_vector< Value , VectorParameters > &v )
+    {
+        m.change_dim( mtl::size( v ) , mtl::size( v ) );
+    }
+};
+
+
+
+
+
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_MTL4_RESIZE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/external/nt2/nt2_algebra_dispatcher.hpp b/include/boost/numeric/odeint/external/nt2/nt2_algebra_dispatcher.hpp
new file mode 100644
index 0000000..7b82a8b
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/nt2/nt2_copy.hpp b/include/boost/numeric/odeint/external/nt2/nt2_copy.hpp
new file mode 100644
index 0000000..0fd5588
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/nt2/nt2_norm_inf.hpp b/include/boost/numeric/odeint/external/nt2/nt2_norm_inf.hpp
new file mode 100644
index 0000000..81f867e
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/nt2/nt2_resize.hpp b/include/boost/numeric/odeint/external/nt2/nt2_resize.hpp
new file mode 100644
index 0000000..d9c2359
--- /dev/null
+++ b/include/boost/numeric/odeint/external/nt2/nt2_resize.hpp
@@ -0,0 +1,52 @@
+//==============================================================================
+//         Copyright 2014          LRI    UMR 8623 CNRS/Univ Paris Sud XI
+//         Copyright 2014          NumScale SAS
+//
+//          Distributed under the Boost Software License, Version 1.0.
+//                 See accompanying file LICENSE.txt or copy at
+//                     http://www.boost.org/LICENSE_1_0.txt
+//==============================================================================
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_RESIZE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_NT2_NT2_RESIZE_HPP_INCLUDED
+
+#include <nt2/core/container/table/table.hpp>
+
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+namespace boost { namespace numeric { namespace odeint {
+
+template<typename T, typename S>
+struct is_resizeable< nt2::container::table<T,S> >
+{
+  typedef boost::true_type type;
+  static const bool value = type::value;
+};
+
+template<typename T, typename S>
+struct same_size_impl< nt2::container::table<T,S>
+                     , nt2::container::table<T,S>
+                     >
+{
+  static bool same_size ( const nt2::container::table<T,S> &v1
+                        , const nt2::container::table<T,S> &v2
+                        )
+  {
+    return v1.extent() == v2.extent();
+  }
+};
+
+template<typename T, typename S>
+struct resize_impl< nt2::container::table<T,S>
+                  , nt2::container::table<T,S>
+                  >
+{
+  static void resize ( nt2::container::table<T,S> &v1
+                     , const nt2::container::table<T,S> &v2
+                     )
+  {
+    v1.resize( v2.extent() );
+  }
+};
+} } }
+
+#endif
diff --git a/include/boost/numeric/odeint/external/openmp/openmp.hpp b/include/boost/numeric/odeint/external/openmp/openmp.hpp
new file mode 100644
index 0000000..0d6fb0b
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp b/include/boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp
new file mode 100644
index 0000000..a3d299f
--- /dev/null
+++ b/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/assert.hpp>
+#include <boost/range.hpp>
+#include <boost/numeric/odeint/algebra/norm_result_type.hpp>
+#include <boost/numeric/odeint/util/n_ary_helper.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/** \brief OpenMP-parallelized algebra, wrapping another, non-parallelized algebra.
+ *
+ * NestedState must be a model of Random Access Range, where the elements are sub-states
+ * which will be processed in parallel.
+ */
+template< class InnerAlgebra >
+struct openmp_nested_algebra
+{
+
+#if __cplusplus >= 201103L // C++11 supports _Pragma
+
+#define BOOST_ODEINT_GEN_LOCAL(z, n, unused) \
+    BOOST_ASSERT_MSG( len == boost::size(s ## n), "All nested state ranges must have the same size." ); \
+    typename boost::range_iterator<S ## n>::type beg ## n = boost::begin(s ## n);
+#define BOOST_ODEINT_GEN_BODY(n) \
+    const size_t len = boost::size(s0); \
+    BOOST_PP_REPEAT(n, BOOST_ODEINT_GEN_LOCAL, ~) \
+    _Pragma("omp parallel for schedule(runtime)") \
+    for( size_t i = 0 ; i < len ; i++ ) \
+        InnerAlgebra::for_each##n( \
+            BOOST_PP_ENUM_BINARY_PARAMS(n, beg, [i] BOOST_PP_INTERCEPT) , \
+            op \
+        );
+BOOST_ODEINT_GEN_FOR_EACH(BOOST_ODEINT_GEN_BODY)
+#undef BOOST_ODEINT_GEN_BODY
+#undef BOOST_ODEINT_GEN_LOCAL
+
+#else
+
+    template< class S0 , class Op > static void for_each1 ( S0 &s0 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each1( beg0 [i] , op );
+    }
+    template< class S0 , class S1 , class Op > static void for_each2 ( S0 &s0 , S1 &s1 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each2( beg0 [i] , beg1 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class Op > static void for_each3 ( S0 &s0 , S1 &s1 , S2 &s2 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each3( beg0 [i] , beg1 [i] , beg2 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class Op > static void for_each4 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each4( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class Op > static void for_each5 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each5( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each6 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each6( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each7 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each7( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class Op > static void for_each8 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each8( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class Op > static void for_each9 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each9( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class Op > static void for_each10 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each10( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class Op > static void for_each11 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each11( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each12 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each12( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each13 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
+        typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each13( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each14 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
+        typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
+        typename boost::range_iterator<S13>::type beg13 = boost::begin(s13);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each14( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] , op );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each15 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
+        typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
+        typename boost::range_iterator<S13>::type beg13 = boost::begin(s13);
+        typename boost::range_iterator<S14>::type beg14 = boost::begin(s14);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each15( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] , beg14 [i] , op );
+    }
+
+#endif
+
+
+    template< class NestedState >
+    static typename norm_result_type< typename NestedState::value_type >::type norm_inf( const NestedState &s )
+    {
+        typedef typename boost::range_iterator<const NestedState>::type iterator;
+        typedef typename std::iterator_traits<iterator>::value_type value_type;
+        typedef typename norm_result_type<value_type>::type result_type;
+        result_type init = static_cast< result_type >( 0 );
+        const size_t len = boost::size(s);
+        iterator beg = boost::begin(s);
+#       pragma omp parallel for reduction(max: init) schedule(dynamic)
+        for( size_t i = 0 ; i < len ; i++ )
+            init = (std::max)( init , InnerAlgebra::norm_inf( beg[i] ) );
+        return init;
+    }
+
+};
+
+
+}
+}
+}
+
+#endif
diff --git a/include/boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp b/include/boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp
new file mode 100644
index 0000000..295db64
--- /dev/null
+++ b/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/assert.hpp>
+#include <boost/range.hpp>
+#include <boost/numeric/odeint/algebra/norm_result_type.hpp>
+#include <boost/numeric/odeint/util/n_ary_helper.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/** \brief OpenMP-parallelized range algebra.
+ *
+ * State must be a model of Random Access Range.
+ */
+struct openmp_range_algebra
+{
+
+#if __cplusplus >= 201103L // C++11 supports _Pragma
+
+#define BOOST_ODEINT_GEN_LOCAL(z, n, unused) \
+    BOOST_ASSERT_MSG( len == boost::size(s ## n), "All state ranges must have the same size." ); \
+    typename boost::range_iterator<S ## n>::type beg ## n = boost::begin(s ## n);
+#define BOOST_ODEINT_GEN_BODY(n) \
+    const size_t len = boost::size(s0); \
+    BOOST_PP_REPEAT(n, BOOST_ODEINT_GEN_LOCAL, ~) \
+    _Pragma("omp parallel for schedule(runtime)") \
+    for( size_t i = 0 ; i < len ; i++ ) \
+        op( BOOST_PP_ENUM_BINARY_PARAMS(n, beg, [i] BOOST_PP_INTERCEPT) );
+BOOST_ODEINT_GEN_FOR_EACH(BOOST_ODEINT_GEN_BODY)
+#undef BOOST_ODEINT_GEN_BODY
+#undef BOOST_ODEINT_GEN_LOCAL
+
+#else
+
+    template< class S0 , class Op > static void for_each1 ( S0 &s0 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] );
+    }
+    template< class S0 , class S1 , class Op > static void for_each2 ( S0 &s0 , S1 &s1 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class Op > static void for_each3 ( S0 &s0 , S1 &s1 , S2 &s2 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class Op > static void for_each4 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class Op > static void for_each5 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each6 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each7 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class Op > static void for_each8 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class Op > static void for_each9 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class Op > static void for_each10 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class Op > static void for_each11 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each12 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each13 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
+        typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each14 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
+        typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
+        typename boost::range_iterator<S13>::type beg13 = boost::begin(s13);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] );
+    }
+    template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each15 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) {
+        const size_t len = boost::size(s0);
+        typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
+        typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
+        typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
+        typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
+        typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
+        typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
+        typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
+        typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
+        typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
+        typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
+        typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
+        typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
+        typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
+        typename boost::range_iterator<S13>::type beg13 = boost::begin(s13);
+        typename boost::range_iterator<S14>::type beg14 = boost::begin(s14);
+        #pragma omp parallel for schedule(runtime)
+        for( size_t i = 0 ; i < len ; i++ ) op( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] , beg14 [i] );
+    }
+
+#endif
+
+
+    template< class S >
+    static typename norm_result_type< S >::type norm_inf( const S &s )
+    {
+        using std::max;
+        using std::abs;
+        typedef typename norm_result_type< S >::type result_type;
+        result_type init = static_cast< result_type >( 0 );
+        const size_t len = boost::size(s);
+        typename boost::range_iterator<const S>::type beg = boost::begin(s);
+#       pragma omp parallel for reduction(max: init) schedule(dynamic)
+        for( size_t i = 0 ; i < len ; ++i )
+            init = max( init , abs( beg[i] ) );
+        return init;
+    }
+
+};
+
+
+}
+}
+}
+
+#endif
diff --git a/include/boost/numeric/odeint/external/openmp/openmp_state.hpp b/include/boost/numeric/odeint/external/openmp/openmp_state.hpp
new file mode 100644
index 0000000..83bbc19
--- /dev/null
+++ b/include/boost/numeric/odeint/external/openmp/openmp_state.hpp
@@ -0,0 +1,171 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/external/openmp/openmp_state.hpp
+
+ [begin_description]
+ Wrappers for OpenMP.
+ [end_description]
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+ Copyright 2013 Pascal Germroth
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_STATE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_STATE_HPP_INCLUDED
+
+#include <omp.h>
+#include <vector>
+#include <algorithm>
+#include <boost/range/adaptor/sliced.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+#include <boost/numeric/odeint/util/split.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/** \brief A container that is split into distinct parts, for threading.
+ * Just a wrapper for vector<vector<T>>, use `copy` for splitting/joining.
+ */
+template< class T >
+struct openmp_state : public std::vector< std::vector< T > >
+{
+    openmp_state() {}
+
+    openmp_state(size_t n, const std::vector<T>& val = std::vector<T>())
+    : std::vector< std::vector< T > >(n, val) {}
+
+    template<class InputIterator>
+    openmp_state(InputIterator first, InputIterator last)
+    : std::vector< std::vector< T > >(first, last) {}
+
+    openmp_state(const std::vector< std::vector< T > > &orig)
+    : std::vector< std::vector< T > >(orig) {}
+
+};
+
+
+
+
+template< class T >
+struct is_resizeable< openmp_state< T > > : boost::true_type { };
+
+
+template< class T >
+struct same_size_impl< openmp_state< T > , openmp_state< T > >
+{
+    static bool same_size( const openmp_state< T > &x , const openmp_state< T > &y )
+    {
+        if( x.size() != y.size() ) return false;
+        for( size_t i = 0 ; i != x.size() ; i++ )
+            if( x[i].size() != y[i].size() ) return false;
+        return true;
+    }
+};
+
+
+template< class T >
+struct resize_impl< openmp_state< T > , openmp_state< T > >
+{
+    static void resize( openmp_state< T > &x , const openmp_state< T > &y )
+    {
+        x.resize( y.size() );
+#       pragma omp parallel for schedule(dynamic)
+        for(size_t i = 0 ; i < x.size() ; i++)
+            x[i].resize( y[i].size() );
+    }
+};
+
+
+/** \brief Copy data between openmp_states of same size. */
+template< class T >
+struct copy_impl< openmp_state< T >, openmp_state< T > >
+{
+    static void copy( const openmp_state< T > &from, openmp_state< T > &to )
+    {
+#       pragma omp parallel for schedule(dynamic)
+        for(size_t i = 0 ; i < from.size() ; i++)
+            std::copy( from[i].begin() , from[i].end() , to.begin() );
+    }
+};
+
+
+
+/** \brief Copy data from some container to an openmp_state and resize it.
+ * Target container size will determine number of blocks to split into.
+ * If it is empty, it will be resized to the maximum number of OpenMP threads.
+ * SourceContainer must support `s::value_type`, `s::const_iterator`, `s.begin()`, `s.end()` and `s.size()`,
+ * with Random Access Iterators; i.e. it must be a Random Access Container. */
+template< class SourceContainer >
+struct split_impl< SourceContainer, openmp_state< typename SourceContainer::value_type > >
+{
+    static void split( const SourceContainer &from, openmp_state< typename SourceContainer::value_type > &to )
+    {
+        if(to.size() == 0) to.resize( omp_get_max_threads() );
+        const size_t part = from.size() / to.size();
+#       pragma omp parallel for schedule(dynamic)
+        for(size_t i = 0 ; i < to.size() ; i++) {
+            typedef typename SourceContainer::const_iterator it_t;
+            const it_t begin = from.begin() + i * part;
+            it_t end = begin + part;
+            // for cases where from.size() % to.size() > 0
+            if(i + 1 == to.size() || end > from.end()) end = from.end();
+            to[i].resize(end - begin);
+            std::copy(begin, end, to[i].begin());
+        }
+    }
+};
+
+/** \brief Copy data from an openmp_state to some container and resize it.
+ * TargetContainer must support `s::value_type`, `s::iterator`, `s.begin()` and `s.resize(n)`,
+ * i.e. it must be a `std::vector`. */
+template< class TargetContainer >
+struct unsplit_impl< openmp_state< typename TargetContainer::value_type >, TargetContainer >
+{
+    static void unsplit( const openmp_state< typename TargetContainer::value_type > &from , TargetContainer &to )
+    {
+        // resize target
+        size_t total_size = 0;
+        for(size_t i = 0 ; i < from.size() ; i++)
+            total_size += from[i].size();
+        to.resize( total_size );
+        // copy parts
+        typename TargetContainer::iterator out = to.begin();
+        for(size_t i = 0 ; i < from.size() ; i++)
+            out = std::copy(from[i].begin(), from[i].end(), out);
+    }
+};
+
+
+
+
+/** \brief OpenMP-parallelized algebra.
+ * For use with openmp_state.
+ */
+typedef openmp_nested_algebra< range_algebra > openmp_algebra;
+
+
+
+/** \brief Use `openmp_algebra` for `openmp_state`. */
+template< class T >
+struct algebra_dispatcher< openmp_state< T > >
+{
+    typedef openmp_algebra algebra_type;
+};
+
+
+}
+}
+}
+
+
+#endif
+
diff --git a/include/boost/numeric/odeint/external/thrust/thrust.hpp b/include/boost/numeric/odeint/external/thrust/thrust.hpp
new file mode 100644
index 0000000..5c4987c
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/thrust/thrust_algebra.hpp b/include/boost/numeric/odeint/external/thrust/thrust_algebra.hpp
new file mode 100644
index 0000000..f33e862
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp b/include/boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp
new file mode 100644
index 0000000..0961346
--- /dev/null
+++ b/include/boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp
@@ -0,0 +1,107 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp
+
+  [begin_description]
+  algebra_dispatcher specialization for thrust
+  [end_description]
+
+  Copyright 2013 Karsten Ahnert
+  Copyright 2013 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_DISPATCHER_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_DISPATCHER_HPP_DEFINED
+
+#include <thrust/host_vector.h>
+#include <thrust/device_vector.h>
+
+#include <boost/numeric/odeint/external/thrust/thrust_algebra.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+
+// specializations for the standard thrust containers
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+// specialization for thrust host_vector
+template< class T , class A >
+struct algebra_dispatcher< thrust::host_vector< T , A > >
+{
+    typedef thrust_algebra algebra_type;
+};
+
+// specialization for thrust device_vector
+template< class T , class A >
+struct algebra_dispatcher< thrust::device_vector< T , A > >
+{
+    typedef thrust_algebra algebra_type;
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+// add support for thrust backend vectors, if available
+
+#include <thrust/version.h>
+
+#if THRUST_VERSION >= 100600
+
+// specialization for thrust cpp vector
+#include <thrust/system/cpp/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct algebra_dispatcher< thrust::cpp::vector< T , A > >
+    {
+        typedef thrust_algebra algebra_type;
+    };
+} } }
+
+// specialization for thrust omp vector
+#ifdef _OPENMP
+#include <thrust/system/omp/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct algebra_dispatcher< thrust::omp::vector< T , A > >
+    {
+        typedef thrust_algebra algebra_type;
+    };
+} } }
+#endif // _OPENMP
+
+// specialization for thrust tbb vector
+#ifdef TBB_VERSION_MAJOR
+#include <thrust/system/tbb/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct algebra_dispatcher< thrust::tbb::vector< T , A > >
+    {
+        typedef thrust_algebra algebra_type;
+    };
+} } }
+#endif // TBB_VERSION_MAJOR
+
+// specialization for thrust cuda vector
+#ifdef __CUDACC__
+#include <thrust/system/cuda/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct algebra_dispatcher< thrust::cuda::vector< T , A > >
+    {
+        typedef thrust_algebra algebra_type;
+    };
+} } }
+#endif // __CUDACC__
+
+#endif // THRUST_VERSION >= 100600
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_ALGEBRA_DISPATCHER_HPP_DEFINED
+
diff --git a/include/boost/numeric/odeint/external/thrust/thrust_operations.hpp b/include/boost/numeric/odeint/external/thrust/thrust_operations.hpp
new file mode 100644
index 0000000..ce2d372
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp b/include/boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp
new file mode 100644
index 0000000..e9b3a64
--- /dev/null
+++ b/include/boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp
@@ -0,0 +1,107 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp
+
+  [begin_description]
+  operations_dispatcher specialization for thrust
+  [end_description]
+
+  Copyright 2013-2014 Karsten Ahnert
+  Copyright 2013-2014 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_DISPATCHER_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_DISPATCHER_HPP_DEFINED
+
+#include <thrust/host_vector.h>
+#include <thrust/device_vector.h>
+
+#include <boost/numeric/odeint/external/thrust/thrust_operations.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+// support for the standard thrust containers
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+// specialization for thrust host_vector
+template< class T , class A >
+struct operations_dispatcher< thrust::host_vector< T , A > >
+{
+    typedef thrust_operations operations_type;
+};
+
+// specialization for thrust device_vector
+template< class T , class A >
+struct operations_dispatcher< thrust::device_vector< T , A > >
+{
+    typedef thrust_operations operations_type;
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+// add support for thrust backend vectors, if available
+
+#include <thrust/version.h>
+
+#if THRUST_VERSION >= 100600
+
+// specialization for thrust cpp vector
+#include <thrust/system/cpp/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct operations_dispatcher< thrust::cpp::vector< T , A > >
+    {
+        typedef thrust_operations operations_type;
+    };
+} } }
+
+// specialization for thrust omp vector
+#ifdef _OPENMP
+#include <thrust/system/omp/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct operations_dispatcher< thrust::omp::vector< T , A > >
+    {
+        typedef thrust_operations operations_type;
+    };
+} } }
+#endif // _OPENMP
+
+// specialization for thrust tbb vector
+#ifdef TBB_VERSION_MAJOR
+#include <thrust/system/tbb/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct operations_dispatcher< thrust::tbb::vector< T , A > >
+    {
+        typedef thrust_operations operations_type;
+    };
+} } }
+#endif // TBB_VERSION_MAJOR
+
+// specialization for thrust cuda vector
+#ifdef __CUDACC__
+#include <thrust/system/cuda/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    template< class T , class A >
+    struct operations_dispatcher< thrust::cuda::vector< T , A > >
+    {
+        typedef thrust_operations operations_type;
+    };
+} } }
+#endif // __CUDACC__
+
+#endif // THRUST_VERSION >= 100600
+
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_OPERATIONS_DISPATCHER_HPP_DEFINED
+
diff --git a/include/boost/numeric/odeint/external/thrust/thrust_resize.hpp b/include/boost/numeric/odeint/external/thrust/thrust_resize.hpp
new file mode 100644
index 0000000..2f7f7b2
--- /dev/null
+++ b/include/boost/numeric/odeint/external/thrust/thrust_resize.hpp
@@ -0,0 +1,185 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/external/thrust/thrust_resize.hpp
+
+ [begin_description]
+ Enable resizing for thrusts device and host_vector.
+ [end_description]
+
+ Copyright 2010-2014 Mario Mulansky
+ Copyright 2010-2011 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_RESIZE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_RESIZE_HPP_INCLUDED
+
+#include <boost/range.hpp>
+
+#include <thrust/device_vector.h>
+#include <thrust/host_vector.h>
+#include <thrust/distance.h>
+
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+// some macros that define the necessary utilities
+
+#define ODEINT_THRUST_VECTOR_IS_RESIZEABLE( THRUST_VECTOR ) \
+template< class T , class A >                               \
+struct is_resizeable< THRUST_VECTOR<T,A> >                  \
+{                                                           \
+    struct type : public boost::true_type { };              \
+    const static bool value = type::value;                  \
+};                                                          \
+
+#define ODEINT_TRHUST_VECTOR_RESIZE_IMPL( THRUST_VECTOR )     \
+template< class T, class A >                                  \
+struct resize_impl< THRUST_VECTOR<T,A> , THRUST_VECTOR<T,A> > \
+{                                                             \
+    static void resize( THRUST_VECTOR<T,A> &x ,               \
+                        const THRUST_VECTOR<T,A> &y )         \
+    {                                                         \
+        x.resize( y.size() );                                 \
+    }                                                         \
+};                                                            \
+template< class T, class A, typename Range >                  \
+struct resize_impl< THRUST_VECTOR<T,A> , Range >              \
+{                                                             \
+    static void resize( THRUST_VECTOR<T,A> &x ,               \
+                        const Range &y )                      \
+    {                                                         \
+        x.resize( thrust::distance(boost::begin(y),           \
+                                   boost::end(y)));           \
+    }                                                         \
+};                                                            \
+
+
+#define ODEINT_THRUST_SAME_SIZE_IMPL( THRUST_VECTOR )            \
+template< class T , class A >                                    \
+struct same_size_impl< THRUST_VECTOR<T,A> , THRUST_VECTOR<T,A> > \
+{                                                                \
+    static bool same_size( const THRUST_VECTOR<T,A> &x ,         \
+                           const THRUST_VECTOR<T,A> &y )         \
+    {                                                            \
+        return x.size() == y.size();                             \
+    }                                                            \
+};                                                               \
+template< class T , class A, typename Range >                    \
+struct same_size_impl< THRUST_VECTOR<T,A> , Range >              \
+{                                                                \
+    static bool same_size( const THRUST_VECTOR<T,A> &x ,         \
+                           const Range &y )                      \
+    {                                                            \
+        return x.size() == thrust::distance(boost::begin(y),     \
+                                            boost::end(y));      \
+    }                                                            \
+};                                                               \
+
+
+#define ODEINT_THRUST_COPY_IMPL( THRUST_VECTOR )                        \
+template< class Container1 , class T , class A >                        \
+struct copy_impl< Container1 , THRUST_VECTOR<T,A> >                     \
+{                                                                       \
+    static void copy( const Container1 &from , THRUST_VECTOR<T,A> &to ) \
+    {                                                                   \
+        thrust::copy( boost::begin( from ) , boost::end( from ) ,       \
+                      boost::begin( to ) );                             \
+    }                                                                   \
+};                                                                      \
+                                                                        \
+template< class T , class A , class Container2 >                        \
+struct copy_impl< THRUST_VECTOR<T,A> , Container2 >                     \
+{                                                                       \
+    static void copy( const THRUST_VECTOR<T,A> &from , Container2 &to ) \
+    {                                                                   \
+        thrust::copy( boost::begin( from ) , boost::end( from ) ,       \
+                      boost::begin( to ) );                             \
+    }                                                                   \
+};                                                                      \
+                                                                        \
+template< class T , class A >                                           \
+struct copy_impl< THRUST_VECTOR<T,A> , THRUST_VECTOR<T,A> >             \
+{                                                                       \
+    static void copy( const THRUST_VECTOR<T,A> &from ,                  \
+                      THRUST_VECTOR<T,A> &to )                          \
+    {                                                                   \
+        thrust::copy( boost::begin( from ) , boost::end( from ) ,       \
+                      boost::begin( to ) );                             \
+    }                                                                   \
+};                                                                      \
+
+// add support for the standard thrust containers
+
+ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::device_vector )
+ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::device_vector )
+ODEINT_THRUST_SAME_SIZE_IMPL( thrust::device_vector )
+ODEINT_THRUST_COPY_IMPL( thrust::device_vector )
+
+
+ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::host_vector )
+ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::host_vector )
+ODEINT_THRUST_SAME_SIZE_IMPL( thrust::host_vector )
+ODEINT_THRUST_COPY_IMPL( thrust::host_vector )
+
+
+} // odeint
+} // numeric
+} // boost
+
+// add support for thrust backend vectors, if available
+
+#include <thrust/version.h>
+
+#if THRUST_VERSION >= 100600
+
+#include <thrust/system/cpp/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::cpp::vector )
+    ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::cpp::vector )
+    ODEINT_THRUST_SAME_SIZE_IMPL( thrust::cpp::vector )
+    ODEINT_THRUST_COPY_IMPL( thrust::cpp::vector )
+} } }
+
+#ifdef _OPENMP
+#include <thrust/system/omp/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::omp::vector )
+    ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::omp::vector )
+    ODEINT_THRUST_SAME_SIZE_IMPL( thrust::omp::vector )
+    ODEINT_THRUST_COPY_IMPL( thrust::omp::vector )
+} } }
+#endif // _OPENMP
+
+#ifdef TBB_VERSION_MAJOR
+#include <thrust/system/tbb/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::tbb::vector )
+    ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::tbb::vector )
+    ODEINT_THRUST_SAME_SIZE_IMPL( thrust::tbb::vector )
+    ODEINT_THRUST_COPY_IMPL( thrust::tbb::vector )
+} } }
+#endif // TBB_VERSION_MAJOR
+
+#ifdef __CUDACC__
+#include <thrust/system/cuda/vector.h>
+namespace boost { namespace numeric { namespace odeint {
+    ODEINT_THRUST_VECTOR_IS_RESIZEABLE( thrust::cuda::vector )
+    ODEINT_TRHUST_VECTOR_RESIZE_IMPL( thrust::cuda::vector )
+    ODEINT_THRUST_SAME_SIZE_IMPL( thrust::cuda::vector )
+    ODEINT_THRUST_COPY_IMPL( thrust::cuda::vector )
+} } }
+#endif // __CUDACC__
+
+#endif // THRUST_VERSION >= 100600
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_THRUST_THRUST_RESIZE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/external/vexcl/vexcl.hpp b/include/boost/numeric/odeint/external/vexcl/vexcl.hpp
new file mode 100644
index 0000000..0a99e27
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/vexcl/vexcl_abs.hpp b/include/boost/numeric/odeint/external/vexcl/vexcl_abs.hpp
new file mode 100644
index 0000000..c5e5c73
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp b/include/boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp
new file mode 100644
index 0000000..9511137
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/vexcl/vexcl_copy.hpp b/include/boost/numeric/odeint/external/vexcl/vexcl_copy.hpp
new file mode 100644
index 0000000..6a5afac
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp b/include/boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp
new file mode 100644
index 0000000..a0a62af
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp b/include/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp
new file mode 100644
index 0000000..2d6291e
--- /dev/null
+++ b/include/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp
@@ -0,0 +1,94 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/external/vexcl/vexcl_resize.hpp
+
+ [begin_description]
+ Enable resizing for vexcl vector and multivector.
+ [end_description]
+
+ Copyright 2012 Karsten Ahnert
+ Copyright 2012 Mario Mulansky
+ Copyright 2012 Denis Demidov
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_RESIZE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_RESIZE_HPP_INCLUDED
+
+#include <vexcl/vector.hpp>
+#include <vexcl/multivector.hpp>
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+/*
+ * specializations for vex::vector< T >
+ */
+template< typename T >
+struct is_resizeable< vex::vector< T > > : boost::true_type { };
+
+template< typename T >
+struct resize_impl< vex::vector< T > , vex::vector< T > >
+{
+    static void resize( vex::vector< T > &x1 , const vex::vector< T > &x2 )
+    {
+        x1.resize( x2.queue_list() , x2.size() );
+    }
+};
+
+template< typename T >
+struct same_size_impl< vex::vector< T > , vex::vector< T > >
+{
+    static bool same_size( const vex::vector< T > &x1 , const vex::vector< T > &x2 )
+    {
+        return x1.size() == x2.size();
+    }
+};
+
+
+
+
+
+/*
+ * specializations for vex::multivector< T >
+ */
+template< typename T , size_t N >
+struct is_resizeable< vex::multivector< T , N > > : boost::true_type { };
+
+template< typename T , size_t N >
+struct resize_impl< vex::multivector< T , N > , vex::multivector< T , N > >
+{
+    static void resize( vex::multivector< T , N > &x1 , const vex::multivector< T , N > &x2 )
+    {
+        x1.resize( x2.queue_list() , x2.size() );
+    }
+};
+
+template< typename T , size_t N >
+struct same_size_impl< vex::multivector< T , N > , vex::multivector< T , N > >
+{
+    static bool same_size( const vex::multivector< T , N > &x1 , const vex::multivector< T , N > &x2 )
+    {
+        return x1.size() == x2.size();
+    }
+};
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VEXCL_VEXCL_RESIZE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp b/include/boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp
new file mode 100644
index 0000000..f5a7378
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/viennacl/viennacl_operations.hpp b/include/boost/numeric/odeint/external/viennacl/viennacl_operations.hpp
new file mode 100644
index 0000000..662c36a
--- /dev/null
+++ b/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
diff --git a/include/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp b/include/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp
new file mode 100644
index 0000000..d324070
--- /dev/null
+++ b/include/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp
@@ -0,0 +1,66 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/external/viennacl/viennacl_resize.hpp
+
+ [begin_description]
+ Enable resizing for viennacl vector.
+ [end_description]
+
+ Copyright 2012 Denis Demidov
+ Copyright 2012 Karsten Ahnert
+ Copyright 2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_RESIZE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_RESIZE_HPP_INCLUDED
+
+#include <viennacl/vector.hpp>
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+/*
+ * specializations for viennacl::vector< T >
+ */
+template< typename T >
+struct is_resizeable< viennacl::vector< T > > : boost::true_type { };
+
+template< typename T >
+struct resize_impl< viennacl::vector< T > , viennacl::vector< T > >
+{
+    static void resize( viennacl::vector< T > &x1 , const viennacl::vector< T > &x2 )
+    {
+        x1.resize( x2.size() , false );
+    }
+};
+
+template< typename T >
+struct same_size_impl< viennacl::vector< T > , viennacl::vector< T > >
+{
+    static bool same_size( const viennacl::vector< T > &x1 , const viennacl::vector< T > &x2 )
+    {
+        return x1.size() == x2.size();
+    }
+};
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_VIENNACL_VIENNACL_RESIZE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/check_adapter.hpp b/include/boost/numeric/odeint/integrate/check_adapter.hpp
new file mode 100644
index 0000000..3d3ebd6
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/check_adapter.hpp
@@ -0,0 +1,222 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/check_adapter.hpp
+
+ [begin_description]
+ Adapters to add checking facility to stepper and observer
+ [end_description]
+
+ Copyright 2015 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_CHECK_ADAPTER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_CHECK_ADAPTER_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template<class Stepper, class Checker,
+         class StepperCategory = typename base_tag<typename Stepper::stepper_category>::type>
+class checked_stepper;
+
+
+/**
+ * \brief Adapter to combine basic stepper and checker.
+ */
+template<class Stepper, class Checker>
+class checked_stepper<Stepper, Checker, stepper_tag>
+{
+
+public:
+    typedef Stepper stepper_type;
+    typedef Checker checker_type;
+    // forward stepper typedefs
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::time_type time_type;
+
+private:
+    stepper_type &m_stepper;
+    checker_type &m_checker;
+
+public:
+    /**
+     * \brief Construct the checked_stepper.
+     */
+    checked_stepper(stepper_type &stepper, checker_type &checker)
+            : m_stepper(stepper), m_checker(checker) { }
+
+    /**
+     * \brief forward of the do_step method
+     */
+    template<class System, class StateInOut>
+    void do_step(System system, StateInOut &state, const time_type t, const time_type dt)
+    {
+        // do the step
+        m_stepper.do_step(system, state, t, dt);
+        // call the checker
+        m_checker();
+    }
+};
+
+
+/**
+ * \brief Adapter to combine controlled stepper and checker.
+ */
+template<class ControlledStepper, class Checker>
+class checked_stepper<ControlledStepper, Checker, controlled_stepper_tag>
+{
+
+public:
+    typedef ControlledStepper stepper_type;
+    typedef Checker checker_type;
+    // forward stepper typedefs
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::time_type time_type;
+
+private:
+    stepper_type &m_stepper;
+    checker_type &m_checker;
+
+public:
+    /**
+     * \brief Construct the checked_stepper.
+     */
+    checked_stepper(stepper_type &stepper, checker_type &checker)
+            : m_stepper(stepper), m_checker(checker) { }
+
+    /**
+     * \brief forward of the do_step method
+     */
+    template< class System , class StateInOut >
+    controlled_step_result try_step( System system , StateInOut &state , time_type &t , time_type &dt )
+    {
+        // do the step
+        if( m_stepper.try_step(system, state, t, dt) == success )
+        {
+            // call the checker if step was successful
+            m_checker();
+            return success;
+        } else
+        {
+            // step failed -> return fail
+            return fail;
+        }
+    }
+};
+
+
+/**
+ * \brief Adapter to combine dense out stepper and checker.
+ */
+template<class DenseOutStepper, class Checker>
+class checked_stepper<DenseOutStepper, Checker, dense_output_stepper_tag>
+{
+
+public:
+    typedef DenseOutStepper stepper_type;
+    typedef Checker checker_type;
+    // forward stepper typedefs
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::time_type time_type;
+
+private:
+    stepper_type &m_stepper;
+    checker_type &m_checker;
+
+public:
+    /**
+     * \brief Construct the checked_stepper.
+     */
+    checked_stepper(stepper_type &stepper, checker_type &checker)
+            : m_stepper(stepper), m_checker(checker) { }
+
+
+    template< class System >
+    std::pair< time_type , time_type > do_step( System system )
+    {
+        m_checker();
+        return m_stepper.do_step(system);
+    }
+
+    /* provide the remaining dense out stepper interface */
+    template< class StateType >
+    void initialize( const StateType &x0 , time_type t0 , time_type dt0 )
+    { m_stepper.initialize(x0, t0, dt0); }
+
+
+    template< class StateOut >
+    void calc_state( time_type t , StateOut &x ) const
+    { m_stepper.calc_state(t, x); }
+
+    template< class StateOut >
+    void calc_state( time_type t , const StateOut &x ) const
+    { m_stepper.calc_state(t, x); }
+
+    const state_type& current_state( void ) const
+    { return m_stepper.current_state(); }
+
+    time_type current_time( void ) const
+    { return m_stepper.current_time(); }
+
+    const state_type& previous_state( void ) const
+    { return m_stepper.previous_state(); }
+
+    time_type previous_time( void ) const
+    { return m_stepper.previous_time(); }
+
+    time_type current_time_step( void ) const
+    { return m_stepper.current_time_step(); }
+
+};
+
+
+/**
+ * \brief Adapter to combine observer and checker.
+ */
+template<class Observer, class Checker>
+class checked_observer
+{
+public:
+    typedef Observer observer_type;
+    typedef Checker checker_type;
+
+private:
+    observer_type &m_observer;
+    checker_type &m_checker;
+
+public:
+    checked_observer(observer_type &observer, checker_type &checker)
+            : m_observer(observer), m_checker(checker)
+    {}
+
+    template< class State , class Time >
+    void operator()(const State& state, Time t) const
+    {
+        // call the observer
+        m_observer(state, t);
+        // reset the checker
+        m_checker.reset();
+    }
+};
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif
\ No newline at end of file
diff --git a/include/boost/numeric/odeint/integrate/detail/functors.hpp b/include/boost/numeric/odeint/integrate/detail/functors.hpp
new file mode 100644
index 0000000..b239217
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/detail/functors.hpp
@@ -0,0 +1,70 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/functors.hpp
+
+ [begin_description]
+ some functors for the iterator based integrate routines
+ [end_description]
+
+ Copyright 2009-2013 Karsten Ahnert
+ Copyright 2009-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_FUNCTORS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_FUNCTORS_HPP_INCLUDED
+
+#include <utility>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+
+template< class Observer >
+struct obs_caller {
+
+    size_t &m_n;
+    Observer m_obs;
+
+    obs_caller( size_t &m , Observer &obs ) : m_n(m) , m_obs( obs ) {}
+
+    template< class State , class Time >
+    void operator()( std::pair< const State & , const Time & > x )
+    {
+        typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+        observer_type &obs = m_obs;
+        obs( x.first , x.second );
+        m_n++;
+    }
+};
+
+template< class Observer , class Time >
+struct obs_caller_time {
+
+    Time &m_t;
+    Observer m_obs;
+
+    obs_caller_time( Time &t , Observer &obs ) : m_t(t) , m_obs( obs ) {}
+
+    template< class State >
+    void operator()( std::pair< const State & , const Time & > x )
+    {
+        typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+        observer_type &obs = m_obs;
+        obs( x.first , x.second );
+        m_t = x.second;
+    }
+};
+
+} // namespace detail
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_FUNCTORS_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp b/include/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp
new file mode 100644
index 0000000..7516d44
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp
@@ -0,0 +1,161 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp
+
+ [begin_description]
+ Default Integrate adaptive implementation.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2015 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED
+
+#include <stdexcept>
+
+#include <boost/throw_exception.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/integrate/max_step_checker.hpp>
+#include <boost/numeric/odeint/integrate/detail/integrate_const.hpp>
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+
+#include <iostream>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+// forward declaration
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , stepper_tag );
+
+/*
+ * integrate_adaptive for simple stepper is basically an integrate_const + some last step
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , stepper_tag
+)
+{
+    size_t steps = detail::integrate_const( stepper , system , start_state , start_time ,
+                                            end_time , dt , observer , stepper_tag() );
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+
+    Time end = start_time + dt*steps;
+    if( less_with_sign( end , end_time , dt ) )
+    {   //make a last step to end exactly at end_time
+        st.do_step( system , start_state , end , end_time - end );
+        steps++;
+        obs( start_state , end_time );
+    }
+    return steps;
+}
+
+
+/*
+ * integrate adaptive for controlled stepper
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time &start_time , Time end_time , Time &dt ,
+        Observer observer , controlled_stepper_tag
+)
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+
+    failed_step_checker fail_checker;  // to throw a runtime_error if step size adjustment fails
+    size_t count = 0;
+    while( less_with_sign( start_time , end_time , dt ) )
+    {
+        obs( start_state , start_time );
+        if( less_with_sign( end_time , static_cast<Time>(start_time + dt) , dt ) )
+        {
+            dt = end_time - start_time;
+        }
+
+        controlled_step_result res;
+        do
+        {
+            res = st.try_step( system , start_state , start_time , dt );
+            fail_checker();  // check number of failed steps
+        }
+        while( res == fail );
+        fail_checker.reset();  // if we reach here, the step was successful -> reset fail checker
+
+        ++count;
+    }
+    obs( start_state , start_time );
+    return count;
+}
+
+
+/*
+ * integrate adaptive for dense output steppers
+ *
+ * step size control is used if the stepper supports it
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , dense_output_stepper_tag )
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+
+    size_t count = 0;
+    st.initialize( start_state , start_time , dt );
+
+    while( less_with_sign( st.current_time() , end_time , st.current_time_step() ) )
+    {
+        while( less_eq_with_sign( static_cast<Time>(st.current_time() + st.current_time_step()) ,
+               end_time ,
+               st.current_time_step() ) )
+        {   //make sure we don't go beyond the end_time
+            obs( st.current_state() , st.current_time() );
+            st.do_step( system );
+            ++count;
+        }
+        // calculate time step to arrive exactly at end time
+        st.initialize( st.current_state() , st.current_time() , static_cast<Time>(end_time - st.current_time()) );
+    }
+    obs( st.current_state() , st.current_time() );
+    // overwrite start_state with the final point
+    boost::numeric::odeint::copy( st.current_state() , start_state );
+    return count;
+}
+
+
+
+
+} // namespace detail
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/detail/integrate_const.hpp b/include/boost/numeric/odeint/integrate/detail/integrate_const.hpp
new file mode 100644
index 0000000..7a86b32
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/detail/integrate_const.hpp
@@ -0,0 +1,167 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/integrate_const.hpp
+
+ [begin_description]
+ integrate const implementation
+ [end_description]
+
+ Copyright 2012-2015 Mario Mulansky
+ Copyright 2012 Christoph Koke
+ Copyright 2012 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_CONST_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_CONST_HPP_INCLUDED
+
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+#include <boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp>
+
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+// forward declaration
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time &start_time , Time end_time , Time &dt ,
+        Observer observer , controlled_stepper_tag
+);
+
+
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , stepper_tag
+)
+{
+
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+
+    Time time = start_time;
+    int step = 0;
+    // cast time+dt explicitely in case of expression templates (e.g. multiprecision)
+    while( less_eq_with_sign( static_cast<Time>(time+dt) , end_time , dt ) )
+    {
+        obs( start_state , time );
+        st.do_step( system , start_state , time , dt );
+        // direct computation of the time avoids error propagation happening when using time += dt
+        // we need clumsy type analysis to get boost units working here
+        ++step;
+        time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * dt;
+    }
+    obs( start_state , time );
+
+    return step;
+}
+
+
+
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , controlled_stepper_tag
+)
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+
+    Time time = start_time;
+    const Time time_step = dt;
+    int real_steps = 0;
+    int step = 0;
+    
+    while( less_eq_with_sign( static_cast<Time>(time+time_step) , end_time , dt ) )
+    {
+        obs( start_state , time );
+        // integrate_adaptive_checked uses the given checker to throw if an overflow occurs
+        real_steps += detail::integrate_adaptive(stepper, system, start_state, time,
+                                                 static_cast<Time>(time + time_step), dt,
+                                                 null_observer(), controlled_stepper_tag());
+        // direct computation of the time avoids error propagation happening when using time += dt
+        // we need clumsy type analysis to get boost units working here
+        step++;
+        time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * time_step;
+    }
+    obs( start_state , time );
+
+    return real_steps;
+}
+
+
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , dense_output_stepper_tag
+)
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+
+    Time time = start_time;
+    
+    st.initialize( start_state , time , dt );
+    obs( start_state , time );
+    time += dt;
+
+    int obs_step( 1 );
+    int real_step( 0 );
+    
+    while( less_eq_with_sign( static_cast<Time>(time+dt) , end_time , dt ) )
+    {
+        while( less_eq_with_sign( time , st.current_time() , dt ) )
+        {
+            st.calc_state( time , start_state );
+            obs( start_state , time );
+            ++obs_step;
+            // direct computation of the time avoids error propagation happening when using time += dt
+            // we need clumsy type analysis to get boost units working here
+            time = start_time + static_cast< typename unit_value_type<Time>::type >(obs_step) * dt;
+        }
+        // we have not reached the end, do another real step
+        if( less_with_sign( static_cast<Time>(st.current_time()+st.current_time_step()) ,
+                            end_time ,
+                            st.current_time_step() ) )
+        {
+            while( less_eq_with_sign( st.current_time() , time , dt ) )
+            {
+                st.do_step( system );
+                ++real_step;
+            }
+        }
+        else if( less_with_sign( st.current_time() , end_time , st.current_time_step() ) )
+        { // do the last step ending exactly on the end point
+            st.initialize( st.current_state() , st.current_time() , end_time - st.current_time() );
+            st.do_step( system );
+            ++real_step;
+        }
+        
+    }
+    // last observation, if we are still in observation interval
+    // might happen due to finite precision problems when computing the the time
+    if( less_eq_with_sign( time , end_time , dt ) )
+    {
+        st.calc_state( time , start_state );
+        obs( start_state , time );
+    }
+    
+    return real_step;
+}
+
+
+} } } }
+
+#endif
diff --git a/include/boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp b/include/boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp
new file mode 100644
index 0000000..2ef490d
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp
@@ -0,0 +1,161 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp
+
+ [begin_description]
+ integrate steps implementation
+ [end_description]
+
+ Copyright 2012-2015 Mario Mulansky
+ Copyright 2012 Christoph Koke
+ Copyright 2012 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED
+
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+// forward declaration
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive_checked(
+        Stepper stepper , System system , State &start_state ,
+        Time &start_time , Time end_time , Time &dt ,
+        Observer observer, controlled_stepper_tag
+);
+
+
+/* basic version */
+template< class Stepper , class System , class State , class Time , class Observer>
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer , stepper_tag )
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+
+    Time time = start_time;
+
+    for( size_t step = 0; step < num_of_steps ; ++step )
+    {
+        obs( start_state , time );
+        st.do_step( system , start_state , time , dt );
+        // direct computation of the time avoids error propagation happening when using time += dt
+        // we need clumsy type analysis to get boost units working here
+        time = start_time + static_cast< typename unit_value_type<Time>::type >( step+1 ) * dt;
+    }
+    obs( start_state , time );
+
+    return time;
+}
+
+
+/* controlled version */
+template< class Stepper , class System , class State , class Time , class Observer >
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer , controlled_stepper_tag )
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+
+    Time time = start_time;
+    Time time_step = dt;
+
+    for( size_t step = 0; step < num_of_steps ; ++step )
+    {
+        obs( start_state , time );
+        // integrate_adaptive_checked uses the given checker to throw if an overflow occurs
+        detail::integrate_adaptive(stepper, system, start_state, time, static_cast<Time>(time + time_step), dt,
+                                   null_observer(), controlled_stepper_tag());
+        // direct computation of the time avoids error propagation happening when using time += dt
+        // we need clumsy type analysis to get boost units working here
+        time = start_time + static_cast< typename unit_value_type<Time>::type >(step+1) * time_step;
+    }
+    obs( start_state , time );
+
+    return time;
+}
+
+
+/* dense output version */
+template< class Stepper , class System , class State , class Time , class Observer >
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer , dense_output_stepper_tag )
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+
+    Time time = start_time;
+    const Time end_time = start_time + static_cast< typename unit_value_type<Time>::type >(num_of_steps) * dt;
+
+    st.initialize( start_state , time , dt );
+
+    size_t step = 0;
+
+    while( step < num_of_steps )
+    {
+        while( less_with_sign( time , st.current_time() , st.current_time_step() ) )
+        {
+            st.calc_state( time , start_state );
+            obs( start_state , time );
+            ++step;
+            // direct computation of the time avoids error propagation happening when using time += dt
+            // we need clumsy type analysis to get boost units working here
+            time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * dt;
+        }
+
+        // we have not reached the end, do another real step
+        if( less_with_sign( static_cast<Time>(st.current_time()+st.current_time_step()) ,
+                            end_time ,
+                            st.current_time_step() ) )
+        {
+            st.do_step( system );
+        }
+        else if( less_with_sign( st.current_time() , end_time , st.current_time_step() ) )
+        { // do the last step ending exactly on the end point
+            st.initialize( st.current_state() , st.current_time() , static_cast<Time>(end_time - st.current_time()) );
+            st.do_step( system );
+        }
+    }
+
+    // make sure we really end exactly where we should end
+    while( st.current_time() < end_time )
+    {
+        if( less_with_sign( end_time ,
+                            static_cast<Time>(st.current_time()+st.current_time_step()) ,
+                            st.current_time_step() ) )
+            st.initialize( st.current_state() , st.current_time() , static_cast<Time>(end_time - st.current_time()) );
+        st.do_step( system );
+    }
+
+    // observation at final point
+    obs( st.current_state() , end_time );
+
+    return time;
+}
+
+
+}
+}
+}
+}
+
+#endif /* BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED */
diff --git a/include/boost/numeric/odeint/integrate/detail/integrate_times.hpp b/include/boost/numeric/odeint/integrate/detail/integrate_times.hpp
new file mode 100644
index 0000000..2e27990
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/detail/integrate_times.hpp
@@ -0,0 +1,179 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/integrate_times.hpp
+
+ [begin_description]
+ Default integrate times implementation.
+ [end_description]
+
+ Copyright 2011-2015 Mario Mulansky
+ Copyright 2012 Karsten Ahnert
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_TIMES_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_TIMES_HPP_INCLUDED
+
+#include <stdexcept>
+
+#include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+#include <boost/numeric/odeint/integrate/max_step_checker.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+
+
+/*
+ * integrate_times for simple stepper
+ */
+template<class Stepper, class System, class State, class TimeIterator, class Time, class Observer>
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        TimeIterator start_time , TimeIterator end_time , Time dt ,
+        Observer observer , stepper_tag
+)
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type stepper_type;
+    typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+
+    stepper_type &st = stepper;
+    observer_type &obs = observer;
+    typedef typename unit_value_type<Time>::type time_type;
+
+    size_t steps = 0;
+    Time current_dt = dt;
+    while( true )
+    {
+        Time current_time = *start_time++;
+        obs( start_state , current_time );
+        if( start_time == end_time )
+            break;
+        while( less_with_sign( current_time , static_cast<time_type>(*start_time) , current_dt ) )
+        {
+            current_dt = min_abs( dt , *start_time - current_time );
+            st.do_step( system , start_state , current_time , current_dt );
+            current_time += current_dt;
+            steps++;
+        }
+    }
+    return steps;
+}
+
+/*
+ * integrate_times for controlled stepper
+ */
+template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        TimeIterator start_time , TimeIterator end_time , Time dt ,
+        Observer observer , controlled_stepper_tag
+)
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+    typedef typename unit_value_type<Time>::type time_type;
+
+    failed_step_checker fail_checker;  // to throw a runtime_error if step size adjustment fails
+    size_t steps = 0;
+    while( true )
+    {
+        Time current_time = *start_time++;
+        obs( start_state , current_time );
+        if( start_time == end_time )
+            break;
+        while( less_with_sign( current_time , static_cast<time_type>(*start_time) , dt ) )
+        {
+            // adjust stepsize to end up exactly at the observation point
+            Time current_dt = min_abs( dt , *start_time - current_time );
+            if( st.try_step( system , start_state , current_time , current_dt ) == success )
+            {
+                ++steps;
+                // successful step -> reset the fail counter, see #173
+                fail_checker.reset();
+                // continue with the original step size if dt was reduced due to observation
+                dt = max_abs( dt , current_dt );
+            }
+            else
+            {
+                fail_checker();  // check for possible overflow of failed steps in step size adjustment
+                dt = current_dt;
+            }
+        }
+    }
+    return steps;
+}
+
+/*
+ * integrate_times for dense output stepper
+ */
+template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        TimeIterator start_time , TimeIterator end_time , Time dt ,
+        Observer observer , dense_output_stepper_tag
+)
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+
+    typedef typename unit_value_type<Time>::type time_type;
+
+    if( start_time == end_time )
+        return 0;
+
+    TimeIterator last_time_iterator = end_time;
+    --last_time_iterator;
+    Time last_time_point = static_cast<time_type>(*last_time_iterator);
+
+    st.initialize( start_state , *start_time , dt );
+    obs( start_state , *start_time++ );
+
+    size_t count = 0;
+    while( start_time != end_time )
+    {
+        while( ( start_time != end_time ) && less_eq_with_sign( static_cast<time_type>(*start_time) , st.current_time() , st.current_time_step() ) )
+        {
+            st.calc_state( *start_time , start_state );
+            obs( start_state , *start_time );
+            start_time++;
+        }
+
+        // we have not reached the end, do another real step
+        if( less_eq_with_sign( st.current_time() + st.current_time_step() ,
+                               last_time_point ,
+                               st.current_time_step() ) )
+        {
+            st.do_step( system );
+            ++count;
+        }
+        else if( start_time != end_time )
+        { // do the last step ending exactly on the end point
+            st.initialize( st.current_state() , st.current_time() , last_time_point - st.current_time() );
+            st.do_step( system );
+            ++count;
+        }
+    }
+    return count;
+}
+
+
+} // namespace detail
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/integrate.hpp b/include/boost/numeric/odeint/integrate/integrate.hpp
new file mode 100644
index 0000000..446656b
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/integrate.hpp
@@ -0,0 +1,133 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate.hpp
+
+ [begin_description]
+ Convenience methods which choose the stepper for the current ODE.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED
+
+#include <boost/utility/enable_if.hpp>
+
+#include <boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp>
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/integrate/integrate_adaptive.hpp>
+
+// for has_value_type trait
+#include <boost/numeric/odeint/algebra/detail/extract_value_type.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * ToDo :
+ *
+ * determine type of dxdt for units
+ *
+ */
+template< class System , class State , class Time , class Observer >
+typename boost::enable_if< typename has_value_type<State>::type , size_t >::type
+integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer )
+{
+    typedef controlled_runge_kutta< runge_kutta_dopri5< State , typename State::value_type , State , Time > > stepper_type;
+    return integrate_adaptive( stepper_type() , system , start_state , start_time , end_time , dt , observer );
+}
+
+template< class Value , class System , class State , class Time , class Observer >
+size_t 
+integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer )
+{
+    typedef controlled_runge_kutta< runge_kutta_dopri5< State , Value , State , Time > > stepper_type;
+    return integrate_adaptive( stepper_type() , system , start_state , start_time , end_time , dt , observer );
+}
+
+
+
+
+/*
+ * the two overloads are needed in order to solve the forwarding problem
+ */
+template< class System , class State , class Time >
+size_t integrate( System system , State &start_state , Time start_time , Time end_time , Time dt )
+{
+    return integrate( system , start_state , start_time , end_time , dt , null_observer() );
+}
+
+template< class Value , class System , class State , class Time >
+size_t integrate( System system , State &start_state , Time start_time , Time end_time , Time dt )
+{
+    return integrate< Value >( system , start_state , start_time , end_time , dt , null_observer() );
+}
+
+
+
+/**
+ * \fn integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer )
+ * \brief Integrates the ODE.
+ *
+ * Integrates the ODE given by system from start_time to end_time starting 
+ * with start_state as initial condition and dt as initial time step.
+ * This function uses a dense output dopri5 stepper and performs an adaptive
+ * integration with step size control, thus dt changes during the integration.
+ * This method uses standard error bounds of 1E-6.
+ * After each step, the observer is called.
+ * 
+ * \attention A second version of this function template exists which explicitly
+ * expects the value type as template parameter, i.e. integrate< double >( sys , x , t0 , t1 , dt , obs );
+ *
+ * \param system The system function to solve, hence the r.h.s. of the 
+ * ordinary differential equation.
+ * \param start_state The initial state.
+ * \param start_time Start time of the integration.
+ * \param end_time End time of the integration.
+ * \param dt Initial step size, will be adjusted during the integration.
+ * \param observer Observer that will be called after each time step.
+ * \return The number of steps performed.
+ */
+
+
+/**
+ * \fn integrate( System system , State &start_state , Time start_time , Time end_time , Time dt )
+ * \brief Integrates the ODE without observer calls.
+ *
+ * Integrates the ODE given by system from start_time to end_time starting 
+ * with start_state as initial condition and dt as initial time step.
+ * This function uses a dense output dopri5 stepper and performs an adaptive
+ * integration with step size control, thus dt changes during the integration.
+ * This method uses standard error bounds of 1E-6.
+ * No observer is called.
+ * 
+ * \attention A second version of this function template exists which explicitly
+ * expects the value type as template parameter, i.e. integrate< double >( sys , x , t0 , t1 , dt );
+ *
+ * \param system The system function to solve, hence the r.h.s. of the 
+ * ordinary differential equation.
+ * \param start_state The initial state.
+ * \param start_time Start time of the integration.
+ * \param end_time End time of the integration.
+ * \param dt Initial step size, will be adjusted during the integration.
+ * \return The number of steps performed.
+ */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/integrate_adaptive.hpp b/include/boost/numeric/odeint/integrate/integrate_adaptive.hpp
new file mode 100644
index 0000000..0999714
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/integrate_adaptive.hpp
@@ -0,0 +1,129 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate_adaptive.hpp
+
+ [begin_description]
+ Adaptive integration of ODEs.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2015 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * the two overloads are needed in order to solve the forwarding problem
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    return detail::integrate_adaptive(
+            stepper , system , start_state ,
+            start_time , end_time , dt ,
+            observer , stepper_category() );
+
+    /*
+     * Suggestion for a new extendable version:
+     *
+     * integrator_adaptive< Stepper , System, State , Time , Observer , typename Stepper::stepper_category > integrator;
+     * return integrator.run( stepper , system , start_state , start_time , end_time , dt , observer );
+     */
+}
+
+/**
+ * \brief Second version to solve the forwarding problem,
+ * can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    return detail::integrate_adaptive(
+            stepper , system , start_state ,
+            start_time , end_time , dt ,
+            observer , stepper_category() );
+}
+
+
+
+
+/**
+ * \brief integrate_adaptive without an observer.
+ */
+template< class Stepper , class System , class State , class Time >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt )
+{
+    return integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , null_observer() );
+}
+
+/**
+ * \brief Second version to solve the forwarding problem,
+ * can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time >
+size_t integrate_adaptive(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time end_time , Time dt )
+{
+    return integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , null_observer() );
+}
+
+
+/************* DOXYGEN ************/
+
+    /** 
+     * \fn integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer )
+     * \brief Integrates the ODE with adaptive step size.
+     * 
+     * This function integrates the ODE given by system with the given stepper.
+     * The observer is called after each step. If the stepper has no error 
+     * control, the step size remains constant and the observer is called at
+     * equidistant time points t0+n*dt. If the stepper is a ControlledStepper,
+     * the step size is adjusted and the observer is called in non-equidistant
+     * intervals.
+     *
+     * \param stepper The stepper to be used for numerical integration.
+     * \param system Function/Functor defining the rhs of the ODE.
+     * \param start_state The initial condition x0.
+     * \param start_time The initial time t0.
+     * \param end_time The final integration time tend.
+     * \param dt The time step between observer calls, _not_ necessarily the 
+     * time step of the integration.
+     * \param observer Function/Functor called at equidistant time intervals.
+     * \return The number of steps performed.
+     */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/integrate_const.hpp b/include/boost/numeric/odeint/integrate/integrate_const.hpp
new file mode 100644
index 0000000..fae683f
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/integrate_const.hpp
@@ -0,0 +1,195 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate_const.hpp
+
+ [begin_description]
+ Constant integration of ODEs, meaning that the state of the ODE is observed on constant time intervals.
+ The routines makes full use of adaptive and dense-output methods.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2015 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/integrate/check_adapter.hpp>
+#include <boost/numeric/odeint/integrate/detail/integrate_const.hpp>
+#include <boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * Integrates with constant time step dt.
+ */
+template<class Stepper, class System, class State, class Time, class Observer, class StepOverflowChecker>
+size_t integrate_const(
+        Stepper stepper, System system, State &start_state,
+        Time start_time, Time end_time, Time dt,
+        Observer observer, StepOverflowChecker checker
+) {
+    typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category;
+    // we want to get as fast as possible to the end
+    // no overflow checks needed
+    if (boost::is_same<null_observer, Observer>::value) {
+        return detail::integrate_adaptive(
+                stepper, system, start_state,
+                start_time, end_time, dt,
+                observer, stepper_category());
+    }
+    else {
+        // unwrap references
+        typedef typename odeint::unwrap_reference< Stepper >::type stepper_type;
+        typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+        typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type;
+
+        return detail::integrate_const(checked_stepper<stepper_type, checker_type>(stepper, checker),
+                                       system, start_state,
+                                       start_time, end_time, dt,
+                                       checked_observer<observer_type, checker_type>(observer, checker),
+                                       stepper_category());
+    }
+}
+
+/**
+* \brief Second version to solve the forwarding problem,
+* can be called with Boost.Range as start_state.
+*/
+template<class Stepper, class System, class State, class Time, class Observer, class StepOverflowChecker >
+size_t integrate_const(
+        Stepper stepper, System system, const State &start_state,
+        Time start_time, Time end_time, Time dt,
+        Observer observer, StepOverflowChecker checker
+) {
+    typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category;
+    // we want to get as fast as possible to the end
+
+    if (boost::is_same<null_observer, Observer>::value) {
+        return detail::integrate_adaptive(
+                stepper, system, start_state,
+                start_time, end_time, dt,
+                observer, stepper_category());
+    }
+    else {
+        typedef typename odeint::unwrap_reference< Stepper >::type stepper_type;
+        typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+        typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type;
+
+        return detail::integrate_const(checked_stepper<stepper_type, checker_type>(stepper, checker),
+                                       system, start_state,
+                                       start_time, end_time, dt,
+                                       checked_observer<observer_type, checker_type>(observer, checker),
+                                       stepper_category());
+    }
+}
+
+
+/**
+* \brief integrate_const without step overflow checker
+*/
+template<class Stepper, class System, class State, class Time, class Observer>
+size_t integrate_const(
+        Stepper stepper, System system, State &start_state,
+        Time start_time, Time end_time, Time dt, Observer observer)
+{
+    typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category;
+    return detail::integrate_const(stepper, system, start_state,
+                                   start_time, end_time, dt, observer, stepper_category());
+}
+
+/**
+* \brief Second version to solve the forwarding problem,
+* can be called with Boost.Range as start_state.
+*/
+template<class Stepper, class System, class State, class Time, class Observer>
+size_t integrate_const(
+        Stepper stepper, System system, const State &start_state,
+        Time start_time, Time end_time, Time dt, Observer observer
+) {
+    typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category;
+    return detail::integrate_const(stepper, system, start_state,
+                                   start_time, end_time, dt, observer, stepper_category());
+}
+
+
+/**
+* \brief integrate_const without observer calls
+*/
+template<class Stepper, class System, class State, class Time>
+size_t integrate_const(
+        Stepper stepper, System system, State &start_state,
+        Time start_time, Time end_time, Time dt
+) {
+    return integrate_const(stepper, system, start_state, start_time, end_time, dt, null_observer());
+}
+
+/**
+* \brief Second version to solve the forwarding problem,
+* can be called with Boost.Range as start_state.
+*/
+template<class Stepper, class System, class State, class Time>
+size_t integrate_const(
+        Stepper stepper, System system, const State &start_state,
+        Time start_time, Time end_time, Time dt
+) {
+    return integrate_const(stepper, system, start_state, start_time, end_time, dt, null_observer());
+}
+
+
+
+
+
+
+/********* DOXYGEN *********/
+/**
+ * \fn integrate_const( Stepper stepper , System system , State &start_state , Time start_time ,
+ *                      Time end_time , Time dt , Observer observer , StepOverflowChecker checker )
+ * \brief Integrates the ODE with constant step size.
+ *
+ * Integrates the ODE defined by system using the given stepper.
+ * This method ensures that the observer is called at constant intervals dt.
+ * If the Stepper is a normal stepper without step size control, dt is also
+ * used for the numerical scheme. If a ControlledStepper is provided, the
+ * algorithm might reduce the step size to meet the error bounds, but it is
+ * ensured that the observer is always called at equidistant time points
+ * t0 + n*dt. If a DenseOutputStepper is used, the step size also may vary
+ * and the dense output is used to call the observer at equidistant time
+ * points.
+ * If a max_step_checker is provided as StepOverflowChecker, a
+ * no_progress_error is thrown if too many steps (default: 500) are performed
+ * without progress, i.e. in between observer calls. If no checker is provided,
+ * no such overflow check is performed.
+ *
+ * \param stepper The stepper to be used for numerical integration.
+ * \param system Function/Functor defining the rhs of the ODE.
+ * \param start_state The initial condition x0.
+ * \param start_time The initial time t0.
+ * \param end_time The final integration time tend.
+ * \param dt The time step between observer calls, _not_ necessarily the
+ * time step of the integration.
+ * \param observer [optional] Function/Functor called at equidistant time intervals.
+ * \param checker [optional] Functor to check for step count overflows, if no
+ * checker is provided, no exception is thrown.
+ * \return The number of steps performed.
+ */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/integrate_n_steps.hpp b/include/boost/numeric/odeint/integrate/integrate_n_steps.hpp
new file mode 100644
index 0000000..5cc8aa0
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/integrate_n_steps.hpp
@@ -0,0 +1,180 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate_n_steps.hpp
+
+ [begin_description]
+ Integration of n steps with constant time size. Adaptive and dense-output methods are fully supported.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2015 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp>
+#include <boost/numeric/odeint/integrate/check_adapter.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * Integrates n steps
+ *
+ * the two overloads are needed in order to solve the forwarding problem
+ */
+template< class Stepper , class System , class State , class Time , class Observer , class StepOverflowChecker >
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer , StepOverflowChecker checker )
+{
+    // unwrap references
+    typedef typename odeint::unwrap_reference< Stepper >::type stepper_type;
+    typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+    typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type;
+    typedef typename stepper_type::stepper_category stepper_category;
+
+    return detail::integrate_n_steps(
+                checked_stepper<stepper_type, checker_type>(stepper, checker),
+                system , start_state ,
+                start_time , dt , num_of_steps ,
+                checked_observer<observer_type, checker_type>(observer, checker),
+                stepper_category() );
+}
+
+/**
+ * \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time , class Observer , class StepOverflowChecker >
+Time integrate_n_steps(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer , StepOverflowChecker checker )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type stepper_type;
+    typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+    typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type;
+    typedef typename stepper_type::stepper_category stepper_category;
+
+    return detail::integrate_n_steps(
+            checked_stepper<stepper_type, checker_type>(stepper, checker),
+            system , start_state ,
+            start_time , dt , num_of_steps ,
+            checked_observer<observer_type, checker_type>(observer, checker),
+            stepper_category() );
+}
+
+
+/**
+* \brief The same function as above, but without checker.
+*/
+template< class Stepper , class System , class State , class Time , class Observer >
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps , Observer observer )
+{
+    typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category;
+
+    return detail::integrate_n_steps(
+            stepper , system , start_state ,
+            start_time , dt , num_of_steps ,
+            observer , stepper_category() );
+}
+
+/**
+* \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+*/
+template< class Stepper , class System , class State , class Time , class Observer >
+Time integrate_n_steps(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps , Observer observer )
+{
+    typedef typename odeint::unwrap_reference<Stepper>::type::stepper_category stepper_category;
+
+    return detail::integrate_n_steps(
+            stepper , system , start_state ,
+            start_time , dt , num_of_steps ,
+            observer , stepper_category() );
+}
+
+/**
+ * \brief The same function as above, but without observer calls.
+ */
+template< class Stepper , class System , class State , class Time >
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps )
+{
+    return integrate_n_steps(stepper, system, start_state, start_time,
+                             dt, num_of_steps, null_observer());
+}
+
+/**
+ * \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time >
+Time integrate_n_steps(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps )
+{
+    return integrate_n_steps(stepper, system, start_state, start_time,
+                             dt, num_of_steps, null_observer());
+}
+
+
+
+/************* DOXYGEN *************/
+    /**
+     * \fn Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer )
+     * \brief Integrates the ODE with constant step size.
+     *
+     * This function is similar to integrate_const. The observer is called at
+     * equidistant time intervals t0 + n*dt.
+     * If the Stepper is a normal stepper without step size control, dt is also
+     * used for the numerical scheme. If a ControlledStepper is provided, the 
+     * algorithm might reduce the step size to meet the error bounds, but it is 
+     * ensured that the observer is always called at equidistant time points
+     * t0 + n*dt. If a DenseOutputStepper is used, the step size also may vary
+     * and the dense output is used to call the observer at equidistant time
+     * points. The final integration time is always t0 + num_of_steps*dt.
+     * If a max_step_checker is provided as StepOverflowChecker, a
+     * no_progress_errror is thrown if too many steps (default: 500) are
+     * performed without progress, i.e. in between observer calls. If no
+     * checker is provided, no such overflow check is performed.
+
+     *
+     * \param stepper The stepper to be used for numerical integration.
+     * \param system Function/Functor defining the rhs of the ODE.
+     * \param start_state The initial condition x0.
+     * \param start_time The initial time t0.
+     * \param dt The time step between observer calls, _not_ necessarily the 
+     * time step of the integration.
+     * \param num_of_steps Number of steps to be performed
+     * \param observer Function/Functor called at equidistant time intervals.
+     * \param checker [optional] Functor to check for step count overflows, if no
+     * checker is provided, no exception is thrown.
+     * \return The number of steps performed.
+     */
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/integrate_times.hpp b/include/boost/numeric/odeint/integrate/integrate_times.hpp
new file mode 100644
index 0000000..79fba4f
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/integrate_times.hpp
@@ -0,0 +1,222 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate_times.hpp
+
+ [begin_description]
+ Integration of ODEs with observation at user defined points
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2015 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/range.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/integrate/check_adapter.hpp>
+#include <boost/numeric/odeint/integrate/detail/integrate_times.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * \brief Integrates while calling the observer at the time points given by sequence [times_start, time_end)
+ * the two overloads are needed in order to solve the forwarding problem
+ */
+template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer , class StepOverflowChecker >
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        TimeIterator times_start , TimeIterator times_end , Time dt ,
+        Observer observer , StepOverflowChecker checker )
+{
+    // unwrap references
+    typedef typename odeint::unwrap_reference< Stepper >::type stepper_type;
+    typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+    typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type;
+    typedef typename stepper_type::stepper_category stepper_category;
+
+    // pass on checked stepper and observer
+    // checked_stepper/observer use references internally, so passing by value is fine
+    return detail::integrate_times(
+            checked_stepper<stepper_type, checker_type>(stepper, checker) ,
+            system , start_state ,
+            times_start , times_end , dt ,
+            checked_observer<observer_type, checker_type>(observer, checker),
+            stepper_category() );
+}
+
+/**
+ * \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer , class StepOverflowChecker >
+size_t integrate_times(
+        Stepper stepper , System system , const State &start_state ,
+        TimeIterator times_start , TimeIterator times_end , Time dt ,
+        Observer observer , StepOverflowChecker checker )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type stepper_type;
+    typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+    typedef typename odeint::unwrap_reference< StepOverflowChecker >::type checker_type;
+    typedef typename stepper_type::stepper_category stepper_category;
+
+    stepper_type &st = stepper;
+    observer_type &obs = observer;
+    checker_type &chk = checker;
+
+    return detail::integrate_times(
+            checked_stepper<stepper_type, checker_type>(stepper, checker) ,
+            system , start_state ,
+            times_start , times_end , dt ,
+            checked_observer<observer_type, checker_type>(observer, checker),
+            stepper_category() );
+}
+
+/**
+ * \brief The same function as above, but with the observation times given as range.
+ */
+template< class Stepper , class System , class State , class TimeRange , class Time , class Observer , class StepOverflowChecker >
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        const TimeRange &times , Time dt ,
+        Observer observer , StepOverflowChecker checker )
+{
+    return integrate_times(
+            stepper , system , start_state ,
+            boost::begin( times ) , boost::end( times ) , dt , observer , checker );
+}
+
+/**
+ * \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class TimeRange , class Time , class Observer , class StepOverflowChecker >
+size_t integrate_times(
+        Stepper stepper , System system , const State &start_state ,
+        const TimeRange &times , Time dt ,
+        Observer observer , StepOverflowChecker checker )
+{
+    return integrate_times(
+            stepper , system , start_state ,
+            boost::begin( times ) , boost::end( times ) , dt , observer , checker );
+}
+
+
+
+
+/*
+* The same functions as above, but without a StepOverflowChecker
+*/
+template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        TimeIterator times_start , TimeIterator times_end , Time dt ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    // simply don't use checked_* adapters
+    return detail::integrate_times(
+            stepper , system , start_state ,
+            times_start , times_end , dt ,
+            observer , stepper_category() );
+}
+
+/**
+* \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+*/
+template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , const State &start_state ,
+        TimeIterator times_start , TimeIterator times_end , Time dt ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    return detail::integrate_times(
+            stepper , system , start_state ,
+            times_start , times_end , dt ,
+            observer , stepper_category() );
+}
+
+/**
+* \brief The same function as above, but with the observation times given as range.
+*/
+template< class Stepper , class System , class State , class TimeRange , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        const TimeRange &times , Time dt ,
+        Observer observer )
+{
+    return integrate_times(
+            stepper , system , start_state ,
+            boost::begin( times ) , boost::end( times ) , dt , observer );
+}
+
+/**
+* \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+*/
+template< class Stepper , class System , class State , class TimeRange , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , const State &start_state ,
+        const TimeRange &times , Time dt ,
+        Observer observer )
+{
+    return integrate_times(
+            stepper , system , start_state ,
+            boost::begin( times ) , boost::end( times ) , dt , observer);
+}
+
+
+/********* DOXYGEN ***********/
+
+    /**
+     * \fn size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer )
+     * \brief Integrates the ODE with observer calls at given time points.
+     *
+     * Integrates the ODE given by system using the given stepper. This function
+     * does observer calls at the subsequent time points given by the range 
+     * times_start, times_end. If the stepper has not step size control, the 
+     * step size might be reduced occasionally to ensure observer calls exactly
+     * at the time points from the given sequence. If the stepper is a 
+     * ControlledStepper, the step size is adjusted to meet the error bounds, 
+     * but also might be reduced occasionally to ensure correct observer calls.
+     * If a DenseOutputStepper is provided, the dense output functionality is
+     * used to call the observer at the given times. The end time of the 
+     * integration is always *(end_time-1).
+     * If a max_step_checker is provided as StepOverflowChecker, a
+     * no_progress_error is thrown if too many steps (default: 500) are
+     * performed without progress, i.e. in between observer calls. If no
+     * checker is provided, no such overflow check is performed.
+     *
+     * \param stepper The stepper to be used for numerical integration.
+     * \param system Function/Functor defining the rhs of the ODE.
+     * \param start_state The initial condition x0.
+     * \param times_start Iterator to the start time
+     * \param times_end Iterator to the end time
+     * \param dt The time step between observer calls, _not_ necessarily the 
+     * time step of the integration.
+     * \param observer Function/Functor called at equidistant time intervals.
+     * \param checker [optional] Functor to check for step count overflows, if no
+     * checker is provided, no exception is thrown.
+     * \return The number of steps performed.
+     */
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/max_step_checker.hpp b/include/boost/numeric/odeint/integrate/max_step_checker.hpp
new file mode 100644
index 0000000..654c95b
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/max_step_checker.hpp
@@ -0,0 +1,114 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/max_step_checker.hpp
+
+ [begin_description]
+ Throws exception if too many steps are performed.
+ [end_description]
+
+ Copyright 2015 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_MAX_STEP_CHECKER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_MAX_STEP_CHECKER_HPP_INCLUDED
+
+#include <stdexcept>
+#include <cstdio>
+
+#include <boost/throw_exception.hpp>
+#include <boost/numeric/odeint/util/odeint_error.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/**
+ * \brief A class for performing overflow checks on the step count in integrate functions.
+ *
+ * Provide an instance of this class to integrate functions if you want to throw a runtime error if
+ * too many steps are performed without progress during the integrate routine.
+ */
+class max_step_checker
+{
+public:
+
+protected:
+    const int m_max_steps;
+    int m_steps;
+
+public:
+    /**
+     * \brief Construct the max_step_checker.
+     * max_steps is the maximal number of iterations allowed before runtime_error is thrown.
+     */
+    max_step_checker(const int max_steps = 500)
+        : m_max_steps(max_steps)
+    {
+        reset();
+    }
+
+    /**
+     * \brief Resets the max_step_checker by setting the internal counter to 0.
+     */
+    void reset()
+    {
+        m_steps = 0;
+    }
+
+    /**
+     * \brief Increases the counter and performs the iteration check
+     */
+    void operator()(void)
+    {
+        if( m_steps++ >= m_max_steps )
+        {
+            char error_msg[200];
+            std::sprintf(error_msg, "Max number of iterations exceeded (%d).", m_max_steps);
+            BOOST_THROW_EXCEPTION( no_progress_error(error_msg) );
+        }
+    }
+};
+
+
+/**
+ * \brief A class for performing overflow checks on the failed step count in step size adjustments.
+ *
+ * Used internally within the dense output stepper and integrate routines.
+ */
+class failed_step_checker : public max_step_checker
+{
+
+public:
+    /**
+     * \brief Construct the failed_step_checker.
+     * max_steps is the maximal number of iterations allowed before runtime_error is thrown.
+     */
+    failed_step_checker(const int max_steps = 500)
+            : max_step_checker(max_steps)
+    {}
+
+    /**
+     * \brief Increases the counter and performs the iteration check
+     */
+    void operator()(void)
+    {
+        if( m_steps++ >= m_max_steps )
+        {
+            char error_msg[200];
+            std::sprintf(error_msg, "Max number of iterations exceeded (%d). A new step size was not found.", m_max_steps);
+            BOOST_THROW_EXCEPTION( step_adjustment_error(error_msg) );
+        }
+    }
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif
diff --git a/include/boost/numeric/odeint/integrate/null_observer.hpp b/include/boost/numeric/odeint/integrate/null_observer.hpp
new file mode 100644
index 0000000..82b86b4
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/null_observer.hpp
@@ -0,0 +1,38 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/null_observer.hpp
+
+ [begin_description]
+ null_observer
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+struct null_observer
+{
+    template< class State , class Time >
+    void operator()( const State& /* x */ , Time /* t */ ) const
+    {
+
+    }
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/integrate/observer_collection.hpp b/include/boost/numeric/odeint/integrate/observer_collection.hpp
new file mode 100644
index 0000000..f8c9af8
--- /dev/null
+++ b/include/boost/numeric/odeint/integrate/observer_collection.hpp
@@ -0,0 +1,56 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/observer_collection.hpp
+
+ [begin_description]
+ Collection of observers, which are all called during the evolution of the ODE.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED
+
+#include <vector>
+
+#include <boost/function.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class State , class Time >
+class observer_collection
+{
+public:
+
+    typedef boost::function< void( const State& , const Time& ) > observer_type;
+    typedef std::vector< observer_type > collection_type;
+
+    void operator()( const State& x , Time t )
+    {
+        for( size_t i=0 ; i<m_observers.size() ; ++i )
+            m_observers[i]( x , t );
+    }
+
+    collection_type& observers( void ) { return m_observers; }
+    const collection_type& observers( void ) const { return m_observers; }
+
+private:
+
+    collection_type m_observers;
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/adaptive_iterator.hpp b/include/boost/numeric/odeint/iterator/adaptive_iterator.hpp
new file mode 100644
index 0000000..e8313e7
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/adaptive_iterator.hpp
@@ -0,0 +1,183 @@
+
+/*
+ [auto_generated]
+ boost/numeric/odeint/iterator/adaptive_iterator.hpp
+
+ [begin_description]
+ Iterator for iterating throught the solution of an ODE with adaptive step size. The dereferenced types containes also the time.
+ [end_description]
+
+ Copyright 2012-2013 Karsten Ahnert
+ Copyright 2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_ITERATOR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_ITERATOR_HPP_INCLUDED
+
+#include <boost/numeric/odeint/util/stepper_traits.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+    /* use the adaptive_iterator_impl with the right tags */
+    template< class Stepper , class System , class State
+#ifndef DOXYGEN_SKIP
+        , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type
+#endif
+    >
+    class adaptive_iterator : public adaptive_iterator_impl<
+            adaptive_iterator< Stepper , System , State , StepperTag > ,
+            Stepper , System , State , detail::ode_state_iterator_tag , StepperTag
+        >
+    {
+        typedef typename traits::time_type< Stepper >::type time_type;
+        typedef adaptive_iterator< Stepper , System , State , StepperTag > iterator_type;
+
+    public:
+        adaptive_iterator( Stepper stepper , System sys , State &s , time_type t_start , time_type t_end , time_type dt )
+            : adaptive_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt )
+        {}
+
+        adaptive_iterator( Stepper stepper , System sys , State &s )
+            : adaptive_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s )
+        {}
+    };
+
+
+
+
+    template< class Stepper , class System , class State >
+    adaptive_iterator< Stepper , System , State > make_adaptive_iterator_begin(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return adaptive_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt );
+    }
+
+
+    template< class Stepper , class System , class State >
+    adaptive_iterator< Stepper , System , State > make_adaptive_iterator_end(
+        Stepper stepper ,
+        System system , 
+        State &x )
+    {
+        return adaptive_iterator< Stepper , System , State >( stepper , system , x );
+    }
+
+
+    template< class Stepper , class System , class State >
+    std::pair< adaptive_iterator< Stepper , System , State > , adaptive_iterator< Stepper , System , State > >
+    make_adaptive_range(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return std::make_pair(
+            adaptive_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ) ,
+            adaptive_iterator< Stepper , System , State >( stepper , system , x )
+            );
+    }
+
+    /**
+     * \class adaptive_iterator
+     *
+     * \brief ODE Iterator with adaptive step size. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an iterator representing the solution of an ODE from t_start
+     * to t_end evaluated at steps with an adaptive step size dt.
+     * After each iteration the iterator dereferences to the state x at the next
+     * time t+dt where dt is controlled by the stepper.
+     * This iterator can be used with ControlledSteppers and
+     * DenseOutputSteppers and it always makes use of the all the given steppers
+     * capabilities. A for_each over such an iterator range behaves similar to
+     * the integrate_adaptive routine.
+     *
+     * adaptive_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     * \tparam State The state type of the ODE.
+     */
+
+
+
+
+
+
+    /**
+     * \fn make_adaptive_iterator_begin( Stepper stepper , System system , State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function for adaptive_iterator. Constructs a begin iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state.
+     * \param t_start The initial time.
+     * \param t_end The end time, at which the iteration should stop.
+     * \param dt The initial time step.
+     * \returns The adaptive iterator.
+     */
+
+
+    /**
+     * \fn make_adaptive_iterator_end( Stepper stepper , System system , State &x )
+     * \brief Factory function for adaptive_iterator. Constructs a end iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state.
+     * \returns The adaptive iterator.
+     */
+
+
+    /**
+     * \fn make_adaptive_range( Stepper stepper , System system , State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function to construct a single pass range of adaptive iterators. A range is here a pair of adaptive_iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state.
+     * \param t_start The initial time.
+     * \param t_end The end time, at which the iteration should stop.
+     * \param dt The initial time step.
+     * \returns The adaptive range.
+     */
+
+
+
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_ITERATOR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/adaptive_time_iterator.hpp b/include/boost/numeric/odeint/iterator/adaptive_time_iterator.hpp
new file mode 100644
index 0000000..f70d34a
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/adaptive_time_iterator.hpp
@@ -0,0 +1,175 @@
+
+/*
+ [auto_generated]
+ boost/numeric/odeint/iterator/adaptive_time_iterator.hpp
+
+ [begin_description]
+ Iterator for iterating throught the solution of an ODE with adaptive step size. The dereferenced types containes also the time.
+ [end_description]
+
+ Copyright 2012-2013 Karsten Ahnert
+ Copyright 2012-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_TIME_ITERATOR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_TIME_ITERATOR_HPP_INCLUDED
+
+
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/util/stepper_traits.hpp>
+#include <boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+    /* use the adaptive_iterator_impl with the right tags */
+    template< class Stepper , class System , class State
+#ifndef DOXYGEN_SKIP
+        , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type
+#endif
+    >
+    class adaptive_time_iterator : public adaptive_iterator_impl<
+            adaptive_time_iterator< Stepper , System , State , StepperTag > ,
+            Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag
+        >
+    {
+        typedef typename traits::time_type< Stepper >::type time_type;
+        typedef adaptive_time_iterator< Stepper , System , State , StepperTag > iterator_type;
+
+    public:
+        adaptive_time_iterator( Stepper stepper , System sys , State &s , time_type t_start , time_type t_end , time_type dt )
+            : adaptive_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt )
+        {}
+
+        adaptive_time_iterator( Stepper stepper , System sys , State &s )
+            : adaptive_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s )
+        {}
+    };
+
+
+
+
+    template< class Stepper , class System , class State >
+    adaptive_time_iterator< Stepper , System , State > make_adaptive_time_iterator_begin(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return adaptive_time_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt );
+    }
+
+    template< class Stepper , class System , class State >
+    adaptive_time_iterator< Stepper , System , State > make_adaptive_time_iterator_end(
+        Stepper stepper ,
+        System system , 
+        State &x )
+    {
+        return adaptive_time_iterator< Stepper , System , State >( stepper , system , x );
+    }
+
+
+    template< class Stepper , class System , class State >
+    std::pair< adaptive_time_iterator< Stepper , System , State > , adaptive_time_iterator< Stepper , System , State > >
+    make_adaptive_time_range(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return std::make_pair(
+            adaptive_time_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ) ,
+            adaptive_time_iterator< Stepper , System , State >( stepper , system , x ) );
+    }
+
+
+
+    /**
+     * \class adaptive_time_iterator
+     *
+     * \brief ODE Iterator with adaptive step size. The value type of this iterator is a std::pair containing state and time.
+     *
+     * Implements an iterator representing the solution of an ODE from t_start
+     * to t_end evaluated at steps with an adaptive step size dt.
+     * After each iteration the iterator dereferences to a pair containing state
+     * and time at the next time point t+dt where dt is controlled by the stepper.
+     * This iterator can be used with ControlledSteppers and
+     * DenseOutputSteppers and it always makes use of the all the given steppers
+     * capabilities. A for_each over such an iterator range behaves similar to
+     * the integrate_adaptive routine.
+     *
+     * adaptive_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is a std::pair of  state and time of the stepper.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     * \tparam State The state type of the ODE.
+     */
+
+
+
+    /**
+     * \fn make_adaptive_time_iterator_begin( Stepper stepper , System system , State &x ,
+         typename traits::time_type< Stepper >::type t_start ,
+         typename traits::time_type< Stepper >::type t_end ,
+         typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function for adaptive_time_iterator. Constructs a begin iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. adaptive_time_iterator stores a reference of s and changes its value during the iteration.
+     * \param t_start The initial time.
+     * \param t_end The end time, at which the iteration should stop.
+     * \param dt The initial time step.
+     * \returns The adaptive time iterator.
+     */
+
+
+    /**
+     * \fn make_adaptive_time_iterator_end( Stepper stepper , System system , State &x )
+     * \brief Factory function for adaptive_time_iterator. Constructs a end iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. adaptive_time_iterator stores a reference of s and changes its value during the iteration.
+     * \returns The adaptive time iterator.
+     */
+
+
+    /**
+     * \fn make_adaptive_time_range( Stepper stepper , System system , State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function to construct a single pass range of adaptive time iterators. A range is here a pair of adaptive_time_iterators.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. adaptive_time_iterator stores a reference of s and changes its value during the iteration.
+     * \param t_start The initial time.
+     * \param t_end The end time, at which the iteration should stop.
+     * \param dt The initial time step.
+     * \returns The adaptive time range.
+     */
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_ADAPTIVE_TIME_ITERATOR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/const_step_iterator.hpp b/include/boost/numeric/odeint/iterator/const_step_iterator.hpp
new file mode 100644
index 0000000..fb1bbb1
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/const_step_iterator.hpp
@@ -0,0 +1,180 @@
+
+/*
+ [auto_generated]
+ boost/numeric/odeint/iterator/const_step_iterator.hpp
+
+ [begin_description]
+ Iterator for iterating through the solution of an ODE with constant step size.
+ [end_description]
+
+ Copyright 2012-2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_ODE_ITERATOR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_ODE_ITERATOR_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/stepper_traits.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+#include <boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    /* use the const_step_iterator_impl with the right tags */
+    template< class Stepper , class System , class State
+#ifndef DOXYGEN_SKIP
+    , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type
+#endif
+    >
+    class const_step_iterator : public const_step_iterator_impl<
+            const_step_iterator< Stepper , System , State , StepperTag > ,
+            Stepper , System , State , detail::ode_state_iterator_tag , StepperTag
+        >
+    {
+        typedef typename traits::time_type< Stepper >::type time_type;
+        typedef const_step_iterator< Stepper , System , State , StepperTag > iterator_type;
+
+    public:
+        const_step_iterator( Stepper stepper , System sys , State &s , time_type t_start , time_type t_end , time_type dt )
+            : const_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt )
+        {}
+
+        const_step_iterator( Stepper stepper , System sys , State &s )
+            : const_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s )
+        {}
+    };
+
+    /* make functions */
+
+    template< class Stepper , class System , class State >
+    const_step_iterator< Stepper , System, State > make_const_step_iterator_begin(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return const_step_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt );
+    }
+
+    template< class Stepper , class System , class State >
+    const_step_iterator< Stepper , System , State > make_const_step_iterator_end(
+        Stepper stepper ,
+        System system , 
+        State &x )
+    {
+        return const_step_iterator< Stepper , System , State >( stepper , system , x );
+    }
+
+    template< class Stepper , class System , class State >
+    std::pair< const_step_iterator< Stepper , System , State > , const_step_iterator< Stepper , System , State > >
+    make_const_step_range(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return std::make_pair(
+            const_step_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ) ,
+            const_step_iterator< Stepper , System , State >( stepper , system , x )
+            );
+    }
+
+
+
+    /**
+     * \class const_step_iterator
+     *
+     * \brief ODE Iterator with constant step size. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an iterator representing the solution of an ODE from t_start
+     * to t_end evaluated at steps with constant step size dt.
+     * After each iteration the iterator dereferences to the state x at the next
+     * time t+dt.
+     * This iterator can be used with Steppers and
+     * DenseOutputSteppers and it always makes use of the all the given steppers
+     * capabilities. A for_each over such an iterator range behaves similar to
+     * the integrate_const routine.
+     *
+     * const_step_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     * \tparam State The state type of the ODE.
+     */
+
+
+    /**
+     * \fn make_const_step_iterator_begin(
+        Stepper stepper ,
+        System system ,
+        State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function for const_step_iterator. Constructs a begin iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \param t_start The initial time.
+     * \param t_end The end time, at which the iteration should stop.
+     * \param dt The initial time step.
+     * \returns The const step iterator.
+     */
+
+
+    /**
+     * \fn make_const_step_iterator_end( Stepper stepper , System system , State &x )
+     * \brief Factory function for const_step_iterator. Constructs a end iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \returns The const_step_iterator.
+     */
+
+
+    /**
+     * \fn make_const_step_range( Stepper stepper , System system , State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function to construct a single pass range of const step iterators. A range is here a pair
+     * of const_step_iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator store a reference of s and changes its value during the iteration.
+     * \param t_start The initial time.
+     * \param t_end The end time, at which the iteration should stop.
+     * \param dt The initial time step.
+     * \returns The const step range.
+     */
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+//#include <boost/numeric/odeint/iterator/impl/const_step_iterator_dense_output_impl.hpp>
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_ODE_ITERATOR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/const_step_time_iterator.hpp b/include/boost/numeric/odeint/iterator/const_step_time_iterator.hpp
new file mode 100644
index 0000000..94ec5dd
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/const_step_time_iterator.hpp
@@ -0,0 +1,173 @@
+
+/*
+ [auto_generated]
+ boost/numeric/odeint/iterator/const_step_time_iterator.hpp
+
+ [begin_description]
+ Iterator for iterating throught the solution of an ODE with constant step size. The dereferences types containes also the time.
+ [end_description]
+
+ Copyright 2012-2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_TIME_ITERATOR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_TIME_ITERATOR_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/util/stepper_traits.hpp>
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+#include <boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+    /* use the const_step_iterator_impl with the right tags */
+    template< class Stepper , class System , class State
+#ifndef DOXYGEN_SKIP
+        , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type
+#endif
+    >
+    class const_step_time_iterator : public const_step_iterator_impl<
+            const_step_time_iterator< Stepper , System , State , StepperTag > ,
+            Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag
+        >
+    {
+        typedef typename traits::time_type< Stepper >::type time_type;
+        typedef const_step_time_iterator< Stepper , System , State , StepperTag > iterator_type;
+
+    public:
+        const_step_time_iterator( Stepper stepper , System sys , State &s , time_type t_start , time_type t_end , time_type dt )
+            : const_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt )
+        {}
+
+        const_step_time_iterator( Stepper stepper , System sys , State &s )
+            : const_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s )
+        {}
+    };
+
+    template< class Stepper , class System , class State >
+    const_step_time_iterator< Stepper , System , State > make_const_step_time_iterator_begin(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return const_step_time_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt );
+    }
+
+    template< class Stepper , class System , class State >
+    const_step_time_iterator< Stepper , System , State > make_const_step_time_iterator_end(
+        Stepper stepper ,
+        System system , 
+        State &x )
+    {
+        return const_step_time_iterator< Stepper , System , State >( stepper , system , x );
+    }
+
+
+    template< class Stepper , class System , class State >
+    std::pair< const_step_time_iterator< Stepper , System , State > , const_step_time_iterator< Stepper , System , State > >
+    make_const_step_time_range(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return std::make_pair(
+            const_step_time_iterator< Stepper , System , State >( stepper , system , x , t_start , t_end , dt ) ,
+            const_step_time_iterator< Stepper , System , State >( stepper , system , x ) );
+    }
+
+    /**
+     * \class const_step_time_iterator
+     *
+     * \brief ODE Iterator with constant step size. The value type of this iterator is a std::pair containing state and time.
+     *
+     * Implements an iterator representing the solution of an ODE from t_start
+     * to t_end evaluated at steps with constant step size dt.
+     * After each iteration the iterator dereferences to a pair containing
+     * state and time at the next time point t+dt..
+     * This iterator can be used with Steppers and
+     * DenseOutputSteppers and it always makes use of the all the given steppers
+     * capabilities. A for_each over such an iterator range behaves similar to
+     * the integrate_const routine.
+     *
+     * const_step_time_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is a pair with the state type and time type of the stepper.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     * \tparam State The state type of the ODE.
+     */
+
+
+    /**
+     * \fn make_const_step_time_iterator_begin( Stepper stepper , System system , State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function for const_step_time_iterator. Constructs a begin iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_time_iterator stores a reference of s and changes its value during the iteration.
+     * \param t_start The initial time.
+     * \param t_end The end time, at which the iteration should stop.
+     * \param dt The initial time step.
+     * \returns The const step time iterator.
+     */
+
+
+    /**
+     * \fn make_const_step_time_iterator_end( Stepper stepper , System system , State &x )
+     * \brief Factory function for const_step_time_iterator. Constructs a end iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_time_iterator store a reference of s and changes its value during the iteration.
+     * \returns The const step time iterator.
+     */
+
+
+    /**
+     * \fn make_const_step_time_range( Stepper stepper , System system , State &x ,
+        typename traits::time_type< Stepper >::type t_start ,
+        typename traits::time_type< Stepper >::type t_end ,
+        typename traits::time_type< Stepper >::type dt)
+     *
+     * \brief Factory function to construct a single pass range of const_step_time_iterator. A range is here a pair of const_step_time_iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_time_iterator stores a reference of s and changes its value during the iteration.
+     * \param t The initial time.
+     * \param t_end The end time, at which the iteration should stop.
+     * \param dt The initial time step.
+     * \returns The const step time range.
+     */
+
+
+
+
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_CONST_STEP_TIME_ITERATOR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp b/include/boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp
new file mode 100644
index 0000000..5960e18
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp
@@ -0,0 +1,199 @@
+
+/*
+ [auto_generated]
+ boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp
+
+ [begin_description]
+ Base class for const_step_iterator and adaptive_iterator.
+ [end_description]
+
+ Copyright 2012-2013 Karsten Ahnert
+ Copyright 2012-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ODE_ITERATOR_BASE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ODE_ITERATOR_BASE_HPP_INCLUDED
+
+#include <boost/iterator/iterator_facade.hpp>
+
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+    struct ode_state_iterator_tag {};
+    struct ode_state_time_iterator_tag {};
+
+    template< class Iterator , class Stepper , class System , class State , typename Tag >
+    class ode_iterator_base;
+
+
+    /* Specialization for the state iterator that has only state_type as its value_type */
+    template< class Iterator , class Stepper , class System , class State >
+    class ode_iterator_base< Iterator , Stepper , System , State , ode_state_iterator_tag >
+        : public boost::iterator_facade
+          <
+              Iterator ,
+              typename traits::state_type< Stepper >::type const ,
+              boost::single_pass_traversal_tag
+          >
+    {
+    private:
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef typename unwrapped_stepper_type::time_type time_type;
+        typedef typename unwrapped_stepper_type::value_type ode_value_type;
+
+    public:
+   
+        ode_iterator_base( stepper_type stepper , system_type sys , time_type t , time_type dt )
+            : m_stepper( stepper ) , m_system( sys ) ,
+              m_t( t ) , m_dt( dt ) , m_at_end( false )
+        { }
+
+        ode_iterator_base( stepper_type stepper , system_type sys )
+            : m_stepper( stepper ) , m_system( sys ) ,
+              m_t() , m_dt() , m_at_end( true )
+        { }
+
+        // this function is only for testing
+        bool same( const ode_iterator_base &iter ) const
+        {
+            return (
+                //( static_cast<Iterator>(*this).get_state() ==
+                //  static_cast<Iterator>(iter).get_state ) &&
+                ( m_t == iter.m_t ) && 
+                ( m_dt == iter.m_dt ) &&
+                ( m_at_end == iter.m_at_end )
+                );
+        }
+
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        bool equal( ode_iterator_base const& other ) const
+        {
+            if( m_at_end == other.m_at_end )
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        const state_type& dereference() const
+        {
+            return static_cast<const Iterator*>(this)->get_state();
+        }
+
+    protected:
+
+        stepper_type m_stepper;
+        system_type m_system;
+        time_type m_t;
+        time_type m_dt;
+        bool m_at_end;
+    };
+
+
+
+    /* Specialization for the state-time iterator that has pair<state_type,time_type> as its value_type */
+
+    template< class Iterator , class Stepper , class System , class State >
+    class ode_iterator_base< Iterator , Stepper , System , State , ode_state_time_iterator_tag >
+        : public boost::iterator_facade
+          <
+              Iterator ,
+              std::pair< const State , const typename traits::time_type< Stepper >::type > ,
+              boost::single_pass_traversal_tag ,
+              std::pair< const State& , const typename traits::time_type< Stepper >::type& >
+          >
+    {
+    private:
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef typename unwrapped_stepper_type::time_type time_type;
+        typedef typename unwrapped_stepper_type::value_type ode_value_type;
+
+    public:
+
+        ode_iterator_base( stepper_type stepper , system_type sys ,
+                           time_type t , time_type dt )
+            : m_stepper( stepper ) , m_system( sys ) ,
+              m_t( t ) , m_dt( dt ) , m_at_end( false )
+        { }
+
+        ode_iterator_base( stepper_type stepper , system_type sys )
+            : m_stepper( stepper ) , m_system( sys ) , m_at_end( true )
+        { }
+
+        bool same( ode_iterator_base const& iter )
+        {
+            return (
+                //( static_cast<Iterator>(*this).get_state() ==
+                //  static_cast<Iterator>(iter).get_state ) &&
+                ( m_t == iter.m_t ) &&
+                ( m_dt == iter.m_dt ) &&
+                ( m_at_end == iter.m_at_end )
+                );
+        }
+
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        bool equal( ode_iterator_base const& other ) const
+        {
+            if( m_at_end == other.m_at_end )
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        std::pair< const state_type& , const time_type& > dereference() const
+        {
+            return std::pair< const state_type & , const time_type & >(
+                    static_cast<const Iterator*>(this)->get_state() , m_t );
+        }
+
+        stepper_type m_stepper;
+        system_type m_system;
+        time_type m_t;
+        time_type m_dt;
+        bool m_at_end;
+
+    };
+
+
+
+} // namespace detail
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ODE_ITERATOR_BASE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp b/include/boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp
new file mode 100644
index 0000000..e5b4b3c
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp
@@ -0,0 +1,253 @@
+/*
+ [auto_generated]
+  boost/numeric/odeint/iterator/detail/adaptive_iterator_impl.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2009-2012 Karsten Ahnert
+  Copyright 2009-2012 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ADAPTIVE_ITERATOR_IMPL_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ADAPTIVE_ITERATOR_IMPL_HPP_DEFINED
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    template< class Iterator , class Stepper , class System , class State , typename Tag , typename StepperTag >
+    class adaptive_iterator_impl;
+
+    /*
+     * Specilization for controlled steppers
+     */
+    /**
+     * \brief ODE Iterator with adaptive step size control. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an ODE iterator with adaptive step size control. Uses controlled steppers. adaptive_iterator is a model
+     * of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     */
+    template< class Iterator , class Stepper , class System , class State , typename Tag >
+    class adaptive_iterator_impl< Iterator , Stepper , System , State , Tag , controlled_stepper_tag >
+        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
+    {
+    private:
+
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef typename traits::time_type< stepper_type >::type time_type;
+        typedef typename traits::value_type< stepper_type >::type ode_value_type;
+        #ifndef DOXYGEN_SKIP
+        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
+        #endif
+
+    public:
+
+        /**
+         * \brief Constructs an adaptive_iterator. This constructor should be used to construct the begin iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. adaptive_iterator stores a reference of s and changes its value during the iteration.
+         * \param t The initial time.
+         * \param t_end The end time, at which the iteration should stop.
+         * \param dt The initial time step.
+         */
+        adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt )
+            : base_type( stepper , sys , t , dt ) , m_t_end( t_end ) , m_state( &s )
+        {
+            if( detail::less_with_sign( this->m_t_end , this->m_t , this->m_dt ) )
+                this->m_at_end = true;
+        }
+
+        /**
+         * \brief Constructs an adaptive_iterator. This constructor should be used to construct the end iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. adaptive_iterator store a reference of s and changes its value during the iteration.
+         */
+        adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
+            : base_type( stepper , sys ) , m_state( &s ) { }
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        void increment()
+        {
+            if( detail::less_with_sign( this->m_t , this->m_t_end , this->m_dt) )
+            {
+                if( detail::less_with_sign( this->m_t_end ,
+                                            static_cast<time_type>(this->m_t + this->m_dt) ,
+                                            this->m_dt ) )
+                {
+                    this->m_dt = this->m_t_end - this->m_t;
+                }
+                unwrapped_stepper_type &stepper = this->m_stepper;
+                const size_t max_attempts = 1000;
+                size_t trials = 0;
+                controlled_step_result res = success;
+                do
+                {
+                    res = stepper.try_step( this->m_system , *( this->m_state ) , this->m_t , this->m_dt );
+                    ++trials;
+                }
+                while( ( res == fail ) && ( trials < max_attempts ) );
+                if( trials == max_attempts )
+                {
+                    BOOST_THROW_EXCEPTION( std::overflow_error( "Adaptive iterator : Maximal number of iterations reached. A step size could not be found." ));
+                }
+            } else {
+                this->m_at_end = true;
+            }
+        }
+    public:
+        const state_type& get_state() const
+        {
+            return *this->m_state;
+        }
+
+    private:
+        time_type m_t_end;
+        state_type* m_state;
+    };
+
+
+
+    /*
+     * Specilization for dense outputer steppers
+     */
+    /**
+     * \brief ODE Iterator with adaptive step size control. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an ODE iterator with adaptive step size control. Uses dense-output steppers. adaptive_iterator is a model
+     * of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     */
+    template< class Iterator , class Stepper , class System , class State , typename Tag >
+    class adaptive_iterator_impl< Iterator , Stepper , System , State , Tag , dense_output_stepper_tag >
+        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
+    {
+    private:
+
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef typename traits::time_type< stepper_type >::type time_type;
+        typedef typename traits::value_type< stepper_type >::type ode_value_type;
+        #ifndef DOXYGEN_SKIP
+        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
+        #endif
+
+
+   public:
+
+
+        /**
+         * \brief Constructs an adaptive_iterator. This constructor should be used to construct the begin iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state.
+         * \param t The initial time.
+         * \param t_end The end time, at which the iteration should stop.
+         * \param dt The initial time step.
+         */
+        adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt )
+            : base_type( stepper , sys , t , dt ) , m_t_end( t_end )
+        {
+            if( detail::less_eq_with_sign( this->m_t , this->m_t_end , this->m_dt ) )
+            {
+                unwrapped_stepper_type &st = this->m_stepper;
+                st.initialize( s , this->m_t , this->m_dt );
+            } else {
+                this->m_at_end = true;
+            }
+        }
+
+        /**
+         * \brief Constructs an adaptive_iterator. This constructor should be used to construct the end iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state.
+         */
+        adaptive_iterator_impl( stepper_type stepper , system_type sys , state_type& /* s */ )
+            : base_type( stepper , sys ) { }
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        void increment()
+        {
+            unwrapped_stepper_type &stepper = this->m_stepper;
+            if( detail::less_with_sign( this->m_t ,
+                                        this->m_t_end ,
+                                        stepper.current_time_step() ) )
+            {
+                if( detail::less_with_sign( this->m_t_end ,
+                                            static_cast<time_type>(this->m_t + stepper.current_time_step()) ,
+                                            stepper.current_time_step() ) )
+                {
+                    // make stpper to end exactly at t_end
+                    stepper.initialize( stepper.current_state() , stepper.current_time() ,
+                                        static_cast<time_type>(this->m_t_end-this->m_t) );
+                }
+                stepper.do_step( this->m_system );
+                this->m_t = stepper.current_time();
+            } else { // we have reached t_end
+                this->m_at_end = true;
+            }
+        }
+
+    public:
+        const state_type& get_state() const
+        {
+            const unwrapped_stepper_type &stepper = this->m_stepper;
+            return stepper.current_state();
+        }
+
+    private:
+        time_type m_t_end;
+    };
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_ADAPTIVE_ITERATOR_IMPL_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp b/include/boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp
new file mode 100644
index 0000000..e23474c
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp
@@ -0,0 +1,228 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/iterator/detail/const_step_iterator_impl.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2013 Karsten Ahnert
+  Copyright 2013 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_CONST_STEP_ITERATOR_IMPL_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_CONST_STEP_ITERATOR_IMPL_HPP_DEFINED
+
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    template< class Iterator , class Stepper , class System , class State , typename Tag , class StepperTag >
+    class const_step_iterator_impl;
+
+
+    /*
+     * Specilization for steppers and error steppers
+     */
+    template< class Iterator , class Stepper , class System , class State , typename Tag >
+    class const_step_iterator_impl< Iterator , Stepper , System , State , Tag , stepper_tag >
+        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
+    {
+    private:
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef typename traits::time_type< stepper_type >::type time_type;
+        typedef typename traits::value_type< stepper_type >::type ode_value_type;
+        #ifndef DOXYGEN_SKIP
+        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
+        #endif
+
+    public:
+   
+        /**
+         * \brief Constructs a const_step_iterator. This constructor should be used to construct the begin iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+         * \param t The initial time.
+         * \param t_end The end time, at which the iteration should stop.
+         * \param dt The initial time step.
+         */
+        const_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt )
+            : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_t_end( t_end ) , m_state( &s ) , m_step( 0 )
+        {
+            if( detail::less_with_sign( this->m_t_end , this->m_t , this->m_dt ) )
+                this->m_at_end = true;
+        }
+
+        /**
+         * \brief Constructs a const_step_iterator. This constructor should be used to construct the end iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+         */
+        const_step_iterator_impl( stepper_type stepper , system_type sys , state_type& /* s */ )
+            : base_type( stepper , sys ) { }
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        void increment()
+        {
+            if( detail::less_eq_with_sign( static_cast<time_type>(this->m_t+this->m_dt) ,
+                                           this->m_t_end , this->m_dt ) )
+            {
+                unwrapped_stepper_type &stepper = this->m_stepper;
+                stepper.do_step( this->m_system , *this->m_state , this->m_t , this->m_dt );
+                // use integer to compute current time to reduce roundoff errors
+                this->m_step++;
+                this->m_t = this->m_t_start + static_cast< typename unit_value_type<time_type>::type >(this->m_step)*this->m_dt;
+            } else {
+                this->m_at_end = true;
+            }
+        }
+
+    public:
+        const state_type& get_state() const
+        {
+            return *m_state;
+        }
+
+    private:
+        time_type m_t_start;
+        time_type m_t_end;
+        state_type* m_state;
+        size_t m_step;
+
+    };
+
+
+
+    /*
+     * Specilization for dense output stepper
+     */
+    /**
+     * \brief ODE Iterator with constant step size. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an ODE iterator solving the ODE with constant steps. Uses dense-output steppers.
+     * const_step_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     */
+    template< class Iterator , class Stepper , class System , class State , typename Tag >
+    class const_step_iterator_impl< Iterator , Stepper , System , State , Tag , dense_output_stepper_tag >
+        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
+    {
+    private:
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef typename traits::time_type< stepper_type >::type time_type;
+        typedef typename traits::value_type< stepper_type >::type ode_value_type;
+        #ifndef DOXYGEN_SKIP
+        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
+        #endif
+
+    public:
+
+        /**
+         * \brief Constructs a const_step_iterator. This constructor should be used to construct the begin iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+         * \param t The initial time.
+         * \param t_end The end time, at which the iteration should stop.
+         * \param dt The initial time step.
+         */
+        const_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s , time_type t , time_type t_end , time_type dt )
+            : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_t_end( t_end ) , m_state( &s ) , m_step( 0 )
+        {
+            if( detail::less_eq_with_sign( this->m_t , this->m_t_end , this->m_dt ) )
+            {
+                unwrapped_stepper_type &st = this->m_stepper;
+                st.initialize( * ( this->m_state ) , this->m_t , this->m_dt );
+            } else {
+                this->m_at_end = true;
+            }
+        }
+
+        /**
+         * \brief Constructs a const_step_iterator. This constructor should be used to construct the end iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+         */
+        const_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
+            : base_type( stepper , sys ) , m_state( &s )
+        {
+        }
+
+
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        void increment( void )
+        {
+            if( detail::less_eq_with_sign( static_cast<time_type>(this->m_t+this->m_dt) ,
+                                           this->m_t_end , this->m_dt ) )
+            {
+                unwrapped_stepper_type &stepper = this->m_stepper;
+                // use integer to compute current time to reduce roundoff errors
+                this->m_step++;
+                this->m_t = this->m_t_start + static_cast< typename unit_value_type<time_type>::type >(this->m_step)*this->m_dt;
+                while( detail::less_with_sign( stepper.current_time() , this->m_t ,
+                       stepper.current_time_step() ) )
+                {
+                    stepper.do_step( this->m_system );
+                }
+                stepper.calc_state( this->m_t , *( this->m_state ) );
+            } else {
+                this->m_at_end = true;
+            }
+        }
+
+    public:
+        const state_type& get_state() const
+        {
+            return *m_state;
+        }
+
+    private:
+        time_type m_t_start;
+        time_type m_t_end;
+        state_type* m_state;
+        size_t m_step;
+    };
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_CONST_STEP_ITERATOR_IMPL_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp b/include/boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp
new file mode 100644
index 0000000..7dd167f
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp
@@ -0,0 +1,239 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/iterator/detail/n_step_iterator_impl.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2009-2013 Karsten Ahnert
+  Copyright 2009-2013 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_N_STEP_ITERATOR_IMPL_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_N_STEP_ITERATOR_IMPL_HPP_DEFINED
+
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    template< class Iterator , class Stepper , class System , class State , typename Tag , class StepperTag >
+    class n_step_iterator_impl;
+
+
+    /*
+     * Specilization for steppers and error steppers
+     */
+    /**
+     * \brief ODE Iterator performing exactly n steps with constant step size. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an ODE iterator solving the ODE with constant step size. Uses steppers fulfilling the Stepper concept.
+     * n_step_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     */
+    template< class Iterator , class Stepper , class System , class State , typename Tag >
+    class n_step_iterator_impl< Iterator , Stepper , System , State , Tag , stepper_tag >
+        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
+    {
+    private:
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef typename traits::time_type< stepper_type >::type time_type;
+        typedef typename traits::value_type< stepper_type >::type ode_value_type;
+        #ifndef DOXYGEN_SKIP
+        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
+        #endif
+
+    public:
+   
+        /**
+         * \brief Constructs a n_step_iterator. This constructor should be used to construct the begin iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+         * \param t The initial time.
+         * \param dt The initial time step.
+         * \param num_of_steps the number of steps to be executed.
+         */
+        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s ,
+                              time_type t , time_type dt , size_t num_of_steps )
+            : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_state( &s ) ,
+              m_steps(num_of_steps) , m_step( 0 )
+        { }
+
+        /**
+         * \brief Constructs a const_step_iterator. This constructor should be used to construct the end iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+         */
+        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
+            : base_type( stepper , sys ) , m_state( &s ) { }
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        void increment()
+        {
+            if( this->m_step < this->m_steps )
+            {
+                unwrapped_stepper_type &stepper = this->m_stepper;
+                stepper.do_step( this->m_system , *this->m_state , this->m_t , this->m_dt );
+                // use integer to compute current time to reduce roundoff errors
+                this->m_step++;
+                this->m_t = this->m_t_start + static_cast< typename unit_value_type<time_type>::type >(this->m_step)*this->m_dt;
+            } else {
+                this->m_at_end = true;
+
+            }
+        }
+
+    public:
+        const state_type& get_state() const
+        {
+            return *m_state;
+        }
+
+
+    private:
+        time_type m_t_start;
+        time_type m_t_end;
+        state_type* m_state;
+        size_t m_steps;
+        size_t m_step;
+
+    };
+
+
+
+
+    /*
+     * Specilization for dense output stepper
+     */
+    /**
+     * \brief ODE Iterator with step-size control and dense output.
+     *
+     * Implements an ODE iterator solving the ODE with constant steps. Uses dense-output steppers.
+     * n_step_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     */
+    template< class Iterator , class Stepper , class System , class State , typename Tag >
+    class n_step_iterator_impl< Iterator , Stepper , System , State , Tag , dense_output_stepper_tag >
+        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
+    {
+    private:
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef typename traits::time_type< stepper_type >::type time_type;
+        typedef typename traits::value_type< stepper_type >::type ode_value_type;
+        #ifndef DOXYGEN_SKIP
+        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
+        #endif
+
+    public:
+
+        /**
+         * \brief Constructs a const_step_iterator. This constructor should be used to construct the begin iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+         * \param t The initial time.
+         * \param dt The initial time step.
+         * \param num_of_steps the number of steps to be executed.
+         */
+        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s ,
+                              time_type t , time_type dt , size_t num_of_steps )
+            : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_state( &s ) ,
+              m_steps( num_of_steps ) , m_step( 0 )
+        {
+            unwrapped_stepper_type &st = this->m_stepper;
+            st.initialize( * ( this->m_state ) , this->m_t , this->m_dt );
+        }
+
+        /**
+         * \brief Constructs a const_step_iterator. This constructor should be used to construct the end iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+         */
+        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
+            : base_type( stepper , sys ) , m_state( &s )
+        {
+        }
+
+
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        void increment( void )
+        {
+            if( this->m_step < this->m_steps )
+            {
+                unwrapped_stepper_type &stepper = this->m_stepper;
+                // use integer to compute current time to reduce roundoff errors
+                this->m_step++;
+                this->m_t = this->m_t_start + static_cast< typename unit_value_type<time_type>::type >(this->m_step)*this->m_dt;
+                while( detail::less_with_sign( stepper.current_time() , this->m_t ,
+                       stepper.current_time_step() ) )
+                {
+                    stepper.do_step( this->m_system );
+                }
+                stepper.calc_state( this->m_t , *( this->m_state ) );
+            } else {
+                this->m_at_end = true;
+            }
+        }
+
+    public:
+        const state_type& get_state() const
+        {
+            return *m_state;
+        }
+
+
+    private:
+        time_type m_t_start;
+        time_type m_t_end;
+        state_type* m_state;
+        size_t m_steps;
+        size_t m_step;
+    };
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_N_STEP_ITERATOR_IMPL_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp b/include/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp
new file mode 100644
index 0000000..7a2b48d
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp
@@ -0,0 +1,371 @@
+/*
+ [auto_generated]
+  boost/numeric/odeint/iterator/detail/times_iterator_impl.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2009-2013 Karsten Ahnert
+  Copyright 2009-2013 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_TIMES_ITERATOR_IMPL_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_TIMES_ITERATOR_IMPL_HPP_DEFINED
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    template< class Iterator , class Stepper , class System , class State , class TimeIterator ,
+              typename Tag , typename StepperTag >
+    class times_iterator_impl;
+
+    /*
+     * Specilization for basic steppers
+     */
+    /**
+     * \brief ODE Iterator with constant step size.
+     *
+     * Implements an ODE iterator with observer calls at predefined times.
+     * Uses controlled steppers. times_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     */
+    template< class Iterator , class Stepper , class System , class State , class TimeIterator , typename Tag >
+    class times_iterator_impl< Iterator , Stepper , System , State , TimeIterator , Tag , stepper_tag >
+        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
+    {
+    private:
+
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef TimeIterator time_iterator_type;
+        typedef typename traits::time_type< stepper_type >::type time_type;
+        typedef typename traits::value_type< stepper_type >::type ode_value_type;
+        #ifndef DOXYGEN_SKIP
+        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
+        #endif
+
+    public:
+
+        /**
+         * \brief Constructs a times_iterator. This constructor should be used to construct the begin iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. adaptive_iterator stores a reference of s and changes its value during the iteration.
+         * \param t_start Iterator to the begin of a sequence of time values.
+         * \param t_end Iterator to the begin of a sequence of time values.
+         * \param dt The (initial) time step.
+         */
+        times_iterator_impl( stepper_type stepper , system_type sys , state_type &s ,
+                             time_iterator_type t_start , time_iterator_type t_end , time_type dt )
+            : base_type( stepper , sys , *t_start , dt ) ,
+              m_t_start( t_start ) , m_t_end( t_end ) , m_state( &s )
+        {
+            if( t_start == t_end )
+                this->m_at_end = true;
+        }
+
+        /**
+         * \brief Constructs an adaptive_iterator. This constructor should be used to construct the end iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. adaptive_iterator store a reference of s and changes its value during the iteration.
+         */
+        times_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
+            : base_type( stepper , sys ) , m_state( &s ) { }
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        void increment()
+        {
+            unwrapped_stepper_type &stepper = this->m_stepper;
+            if( ++m_t_start != m_t_end )
+            {
+                while( detail::less_with_sign( this->m_t , static_cast<time_type>(*m_t_start) , this->m_dt ) )
+                {
+                    const time_type current_dt = detail::min_abs( this->m_dt , static_cast<time_type>(*m_t_start) - this->m_t );
+                    stepper.do_step( this->m_system , *( this->m_state ) , this->m_t , current_dt );
+                    this->m_t += current_dt;
+                }
+
+            } else {
+                this->m_at_end = true;
+            }
+         }
+
+    public:
+        const state_type& get_state() const
+        {
+            return *m_state;
+        }
+
+    private:
+        time_iterator_type m_t_start;
+        time_iterator_type m_t_end;
+        state_type* m_state;
+    };
+
+
+
+    /*
+     * Specilization for controlled steppers
+     */
+    /**
+     * \brief ODE Iterator with adaptive step size control. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an ODE iterator with observer calls at predefined times.
+     * Uses controlled steppers. times_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     */
+    template< class Iterator , class Stepper , class System , class State , class TimeIterator , typename Tag >
+    class times_iterator_impl< Iterator , Stepper , System , State , TimeIterator , Tag , controlled_stepper_tag >
+        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
+    {
+    private:
+
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef TimeIterator time_iterator_type;
+        typedef typename traits::time_type< stepper_type >::type time_type;
+        typedef typename traits::value_type< stepper_type >::type ode_value_type;
+        #ifndef DOXYGEN_SKIP
+        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
+        #endif
+
+    public:
+
+        /**
+         * \brief Constructs a times_iterator. This constructor should be used to construct the begin iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. adaptive_iterator stores a reference of s and changes its value during the iteration.
+         * \param t_start Iterator to the begin of a sequence of time values.
+         * \param t_end Iterator to the begin of a sequence of time values.
+         * \param dt The (initial) time step.
+         */
+        times_iterator_impl( stepper_type stepper , system_type sys , state_type &s ,
+                             time_iterator_type t_start , time_iterator_type t_end , time_type dt )
+            : base_type( stepper , sys , *t_start , dt ) ,
+              m_t_start( t_start ) , m_t_end( t_end ) , m_state( &s )
+        {
+            if( t_start == t_end )
+                this->m_at_end = true;
+        }
+
+        /**
+         * \brief Constructs an adaptive_iterator. This constructor should be used to construct the end iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state. adaptive_iterator store a reference of s and changes its value during the iteration.
+         */
+        times_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
+            : base_type( stepper , sys ) , m_state( &s ) { }
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        void increment()
+        {
+            if( ++m_t_start != m_t_end )
+            {
+                while( detail::less_with_sign( this->m_t , static_cast<time_type>(*m_t_start) , this->m_dt ) )
+                {
+                    if( detail::less_with_sign( static_cast<time_type>(*m_t_start) - this->m_t , this->m_dt , this->m_dt ) )
+                    {
+                        // we want to end exactly at the time point
+                        time_type current_dt = static_cast<time_type>(*m_t_start) - this->m_t;
+                        step_loop( current_dt );
+                    } else {
+                        step_loop( this->m_dt );
+                    }
+                }
+
+            } else {
+                this->m_at_end = true;
+            }
+        }
+
+    private:
+        void step_loop( time_type &dt )
+        {
+            unwrapped_stepper_type &stepper = this->m_stepper;
+            const size_t max_attempts = 1000;
+            size_t trials = 0;
+            controlled_step_result res = success;
+            do
+            {
+                res = stepper.try_step( this->m_system , *( this->m_state ) , this->m_t , dt );
+                ++trials;
+            }
+            while( ( res == fail ) && ( trials < max_attempts ) );
+            if( trials == max_attempts )
+            {
+                BOOST_THROW_EXCEPTION( std::overflow_error( "Adaptive iterator : Maximal number of iterations reached. A step size could not be found." ) );
+            }
+        }
+
+    public:
+        const state_type& get_state() const
+        {
+            return *m_state;
+        }
+
+
+    private:
+        time_iterator_type m_t_start;
+        time_iterator_type m_t_end;
+        state_type* m_state;
+    };
+
+
+    /*
+     * Specilization for dense outputer steppers
+     */
+    /**
+     * \brief ODE Iterator with step size control and dense output.
+     * Implements an ODE iterator with adaptive step size control. Uses dense-output steppers.
+     * times_iterator is a model of single-pass iterator.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     */
+    template< class Iterator , class Stepper , class System , class State , class TimeIterator , typename Tag >
+    class times_iterator_impl< Iterator , Stepper , System , State , TimeIterator , Tag , dense_output_stepper_tag >
+        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
+    {
+    private:
+
+
+        typedef Stepper stepper_type;
+        typedef System system_type;
+        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
+        typedef State state_type;
+        typedef TimeIterator time_iterator_type;
+        typedef typename traits::time_type< stepper_type >::type time_type;
+        typedef typename traits::value_type< stepper_type >::type ode_value_type;
+        #ifndef DOXYGEN_SKIP
+        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
+        #endif
+
+
+   public:
+
+
+        /**
+         * \brief Constructs a times_iterator. This constructor should be used to construct the begin iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state.
+         * \param t_start Iterator to the begin of a sequence of time values.
+         * \param t_end Iterator to the begin of a sequence of time values.
+         * \param dt The (initial) time step.
+         */
+        times_iterator_impl( stepper_type stepper , system_type sys , state_type &s ,
+                             time_iterator_type t_start , time_iterator_type t_end , time_type dt )
+            : base_type( stepper , sys , *t_start , dt ) ,
+              m_t_start( t_start ) , m_t_end( t_end ) , m_final_time( *(t_end-1) ) ,
+              m_state( &s )
+        {
+            if( t_start != t_end )
+            {
+                unwrapped_stepper_type &st = this->m_stepper;
+                st.initialize( *( this->m_state ) , this->m_t , this->m_dt );
+            } else {
+                this->m_at_end = true;
+            }
+        }
+
+        /**
+         * \brief Constructs a times_iterator. This constructor should be used to construct the end iterator.
+         *
+         * \param stepper The stepper to use during the iteration.
+         * \param sys The system function (ODE) to solve.
+         * \param s The initial state.
+         */
+        times_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
+            : base_type( stepper , sys ) , m_state( &s ) { }
+
+    protected:
+
+        friend class boost::iterator_core_access;
+
+        void increment()
+        {
+            unwrapped_stepper_type &st = this->m_stepper;
+            if( ++m_t_start != m_t_end )
+            {
+                this->m_t = static_cast<time_type>(*m_t_start);
+                while( detail::less_with_sign( st.current_time() , this->m_t , this->m_dt ) )
+                {
+                    // make sure we don't go beyond the last point
+                    if( detail::less_with_sign( m_final_time-st.current_time() , st.current_time_step() , st.current_time_step() ) )
+                    {
+                        st.initialize( st.current_state() , st.current_time() , m_final_time-st.current_time() );
+                    }
+                    st.do_step( this->m_system );
+                }
+                st.calc_state( this->m_t , *( this->m_state ) );
+            } else {
+                this->m_at_end = true;
+            }
+        }
+
+    public:
+        const state_type& get_state() const
+        {
+            return *m_state;
+        }
+
+
+    private:
+        time_iterator_type m_t_start;
+        time_iterator_type m_t_end;
+        time_type m_final_time;
+        state_type* m_state;
+    };
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_TIMES_ITERATOR_IMPL_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/iterator/integrate/detail/functors.hpp b/include/boost/numeric/odeint/iterator/integrate/detail/functors.hpp
new file mode 100644
index 0000000..b239217
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/detail/functors.hpp
@@ -0,0 +1,70 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/functors.hpp
+
+ [begin_description]
+ some functors for the iterator based integrate routines
+ [end_description]
+
+ Copyright 2009-2013 Karsten Ahnert
+ Copyright 2009-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_FUNCTORS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_FUNCTORS_HPP_INCLUDED
+
+#include <utility>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+
+template< class Observer >
+struct obs_caller {
+
+    size_t &m_n;
+    Observer m_obs;
+
+    obs_caller( size_t &m , Observer &obs ) : m_n(m) , m_obs( obs ) {}
+
+    template< class State , class Time >
+    void operator()( std::pair< const State & , const Time & > x )
+    {
+        typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+        observer_type &obs = m_obs;
+        obs( x.first , x.second );
+        m_n++;
+    }
+};
+
+template< class Observer , class Time >
+struct obs_caller_time {
+
+    Time &m_t;
+    Observer m_obs;
+
+    obs_caller_time( Time &t , Observer &obs ) : m_t(t) , m_obs( obs ) {}
+
+    template< class State >
+    void operator()( std::pair< const State & , const Time & > x )
+    {
+        typedef typename odeint::unwrap_reference< Observer >::type observer_type;
+        observer_type &obs = m_obs;
+        obs( x.first , x.second );
+        m_t = x.second;
+    }
+};
+
+} // namespace detail
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_FUNCTORS_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp b/include/boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp
new file mode 100644
index 0000000..ccbbf49
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp
@@ -0,0 +1,121 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp
+
+ [begin_description]
+ Default Integrate adaptive implementation.
+ [end_description]
+
+ Copyright 2009-2011 Karsten Ahnert
+ Copyright 2009-2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED
+
+#include <stdexcept>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp>
+#include <boost/numeric/odeint/iterator/adaptive_time_iterator.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/functors.hpp>
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+// forward declaration
+template< class Stepper , class System , class State , class Time , class Observer>
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , stepper_tag );
+
+/*
+ * integrate_adaptive for simple stepper is basically an integrate_const + some last step
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , stepper_tag
+)
+{
+    size_t steps = detail::integrate_const( stepper , system , start_state , start_time ,
+                                            end_time , dt , observer , stepper_tag() );
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    typename odeint::unwrap_reference< Stepper >::type &st = stepper;
+
+    Time end = start_time + dt*steps;
+    if( less_with_sign( end , end_time , dt ) )
+    {   //make a last step to end exactly at end_time
+        st.do_step( system , start_state , end , end_time - end );
+        steps++;
+        obs( start_state , end_time );
+    }
+    return steps;
+}
+
+
+/*
+ * classical integrate adaptive
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time &start_time , Time end_time , Time &dt ,
+        Observer observer , controlled_stepper_tag
+)
+{
+    size_t obs_calls = 0;
+
+    boost::for_each( make_adaptive_time_range( stepper , system , start_state ,
+                                               start_time , end_time , dt ) ,
+                     obs_caller< Observer >( obs_calls , observer ) );
+
+    return obs_calls-1;
+}
+
+
+/*
+ * integrate adaptive for dense output steppers
+ *
+ * step size control is used if the stepper supports it
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , dense_output_stepper_tag )
+{
+    size_t obs_calls = 0;
+
+    boost::for_each( make_adaptive_time_range( stepper , system , start_state ,
+                                               start_time , end_time , dt ) ,
+                     obs_caller< Observer >( obs_calls , observer ) );
+
+    return obs_calls-1;
+}
+
+
+
+
+} // namespace detail
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp b/include/boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp
new file mode 100644
index 0000000..1065036
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp
@@ -0,0 +1,111 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/integrate_const.hpp
+
+ [begin_description]
+ integrate const implementation
+ [end_description]
+
+ Copyright 2009-2012 Karsten Ahnert
+ Copyright 2009-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_CONST_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_CONST_HPP_INCLUDED
+
+#include <boost/range/algorithm/for_each.hpp>
+
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+#include <boost/numeric/odeint/iterator/const_step_time_iterator.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/functors.hpp>
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+// forward declaration
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time &start_time , Time end_time , Time &dt ,
+        Observer observer , controlled_stepper_tag
+);
+
+
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , stepper_tag 
+)
+{
+    size_t obs_calls = 0;
+
+    boost::for_each( make_const_step_time_range( stepper , system , start_state ,
+                                                 start_time , end_time , dt ) ,
+                     // should we use traits<Stepper>::state_type here instead of State? NO!
+                     obs_caller< Observer >( obs_calls , observer ) );
+
+    // step integration steps gives step+1 observer calls
+    return obs_calls-1;
+}
+
+
+
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , controlled_stepper_tag 
+)
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+    
+    Time time = start_time;
+    const Time time_step = dt;
+    int step = 0;
+    
+    while( less_eq_with_sign( static_cast<Time>(time+time_step) , end_time , dt ) )
+    {
+        obs( start_state , time );
+        detail::integrate_adaptive( stepper , system , start_state , time , time+time_step , dt ,
+                                    null_observer() , controlled_stepper_tag() );
+        // direct computation of the time avoids error propagation happening when using time += dt
+        // we need clumsy type analysis to get boost units working here
+        ++step;
+        time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * time_step;
+    }
+    obs( start_state , time );
+    
+    return step;
+}
+
+
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer , dense_output_stepper_tag 
+)
+{
+    size_t obs_calls = 0;
+
+    boost::for_each( make_const_step_time_range( stepper , system , start_state ,
+                                                 start_time , end_time , dt ) ,
+                     obs_caller< Observer >( obs_calls , observer ) );
+    return obs_calls-1;
+}
+
+
+} } } }
+
+#endif
diff --git a/include/boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp b/include/boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp
new file mode 100644
index 0000000..f90f887
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp
@@ -0,0 +1,107 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp
+
+ [begin_description]
+ integrate steps implementation
+ [end_description]
+
+ Copyright 2009-2012 Karsten Ahnert
+ Copyright 2009-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED
+
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/functors.hpp>
+#include <boost/numeric/odeint/iterator/n_step_time_iterator.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+// forward declaration
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time &start_time , Time end_time , Time &dt ,
+        Observer observer , controlled_stepper_tag
+);
+
+
+/* basic version */
+template< class Stepper , class System , class State , class Time , class Observer>
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer , stepper_tag )
+{
+    // ToDo: is there a better way to extract the final time?
+    Time t = start_time; // Assignment is only here to avoid warnings.
+    boost::for_each( make_n_step_time_range( stepper , system , start_state ,
+                                             start_time , dt , num_of_steps ) ,
+                     obs_caller_time< Observer , Time >( t , observer ) );
+    return t;
+}
+
+
+/* controlled version */
+template< class Stepper , class System , class State , class Time , class Observer>
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer , controlled_stepper_tag )
+{
+    typename odeint::unwrap_reference< Observer >::type &obs = observer;
+
+    Time time = start_time;
+    Time time_step = dt;
+
+    for( size_t step = 0; step < num_of_steps ; ++step )
+    {
+        obs( start_state , time );
+        detail::integrate_adaptive( stepper , system , start_state , time , static_cast<Time>(time+time_step) , dt ,
+                null_observer() , controlled_stepper_tag() );
+        // direct computation of the time avoids error propagation happening when using time += dt
+        // we need clumsy type analysis to get boost units working here
+        time = start_time + static_cast< typename unit_value_type<Time>::type >(step+1) * time_step;
+    }
+    obs( start_state , time );
+
+    return time;
+}
+
+
+/* dense output version */
+template< class Stepper , class System , class State , class Time , class Observer>
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer , dense_output_stepper_tag )
+{
+    // ToDo: is there a better way to extract the final time?
+    Time t = start_time;  // Assignment is only here to avoid warnings.
+    boost::for_each( make_n_step_time_range( stepper , system , start_state ,
+                                             start_time , dt , num_of_steps ) ,
+                     obs_caller_time< Observer , Time >( t , observer ) );
+    return t;
+}
+
+
+}
+}
+}
+}
+
+#endif /* BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_N_STEPS_HPP_INCLUDED */
diff --git a/include/boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp b/include/boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp
new file mode 100644
index 0000000..bccc7c6
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp
@@ -0,0 +1,67 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/detail/integrate_times.hpp
+
+ [begin_description]
+ Default integrate times implementation.
+ [end_description]
+
+ Copyright 2009-2012 Karsten Ahnert
+ Copyright 2009-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_TIMES_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_TIMES_HPP_INCLUDED
+
+#include <stdexcept>
+
+#include <boost/config.hpp>
+#include <boost/range/algorithm/for_each.hpp>
+
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+#include <boost/numeric/odeint/iterator/times_time_iterator.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/functors.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+
+
+/*
+ * integrate_times for all steppers
+ */
+template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer , class StepperTag >
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        TimeIterator start_time , TimeIterator end_time , Time dt ,
+        Observer observer , StepperTag
+)
+{
+    size_t obs_calls = 0;
+
+    boost::for_each( make_times_time_range( stepper , system , start_state ,
+                                            start_time , end_time , dt ) ,
+                         // should we use traits<Stepper>::state_type here instead of State? NO!
+                     obs_caller< Observer >( obs_calls , observer ) );
+
+        // step integration steps gives step+1 observer calls
+    return obs_calls-1;
+}
+
+
+} // namespace detail
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_INTEGRATE_ADAPTIVE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/integrate/integrate.hpp b/include/boost/numeric/odeint/iterator/integrate/integrate.hpp
new file mode 100644
index 0000000..9d88ef9
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/integrate.hpp
@@ -0,0 +1,111 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate.hpp
+
+ [begin_description]
+ Convenience methods which choose the stepper for the current ODE.
+ [end_description]
+
+ Copyright 2009-2011 Karsten Ahnert
+ Copyright 2009-2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED
+
+#include <boost/utility/enable_if.hpp>
+
+#include <boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp>
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/iterator/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp>
+
+// for has_value_type trait
+#include <boost/numeric/odeint/algebra/detail/extract_value_type.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * ToDo :
+ *
+ * determine type of dxdt for units
+ *
+ */
+template< class System , class State , class Time , class Observer >
+typename boost::enable_if< typename has_value_type<State>::type , size_t >::type
+integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer )
+{
+    typedef controlled_runge_kutta< runge_kutta_dopri5< State , typename State::value_type , State , Time > > stepper_type;
+    return integrate_adaptive( stepper_type() , system , start_state , start_time , end_time , dt , observer );
+}
+
+
+
+/*
+ * the two overloads are needed in order to solve the forwarding problem
+ */
+template< class System , class State , class Time >
+size_t integrate( System system , State &start_state , Time start_time , Time end_time , Time dt )
+{
+    return integrate( system , start_state , start_time , end_time , dt , null_observer() );
+}
+
+
+/**
+ * \fn integrate( System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer )
+ * \brief Integrates the ODE.
+ *
+ * Integrates the ODE given by system from start_time to end_time starting 
+ * with start_state as initial condition and dt as initial time step.
+ * This function uses a dense output dopri5 stepper and performs an adaptive
+ * integration with step size control, thus dt changes during the integration.
+ * This method uses standard error bounds of 1E-6.
+ * After each step, the observer is called.
+ *
+ * \param system The system function to solve, hence the r.h.s. of the 
+ * ordinary differential equation.
+ * \param start_state The initial state.
+ * \param start_time Start time of the integration.
+ * \param end_time End time of the integration.
+ * \param dt Initial step size, will be adjusted during the integration.
+ * \param observer Observer that will be called after each time step.
+ * \return The number of steps performed.
+ */
+
+
+/**
+ * \fn integrate( System system , State &start_state , Time start_time , Time end_time , Time dt )
+ * \brief Integrates the ODE without observer calls.
+ *
+ * Integrates the ODE given by system from start_time to end_time starting 
+ * with start_state as initial condition and dt as initial time step.
+ * This function uses a dense output dopri5 stepper and performs an adaptive
+ * integration with step size control, thus dt changes during the integration.
+ * This method uses standard error bounds of 1E-6.
+ * No observer is called.
+ *
+ * \param system The system function to solve, hence the r.h.s. of the 
+ * ordinary differential equation.
+ * \param start_state The initial state.
+ * \param start_time Start time of the integration.
+ * \param end_time End time of the integration.
+ * \param dt Initial step size, will be adjusted during the integration.
+ * \return The number of steps performed.
+ */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp b/include/boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp
new file mode 100644
index 0000000..3229a00
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp
@@ -0,0 +1,129 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate_adaptive.hpp
+
+ [begin_description]
+ Adaptive integration of ODEs.
+ [end_description]
+
+ Copyright 2009-2011 Karsten Ahnert
+ Copyright 2009-2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * the two overloads are needed in order to solve the forwarding problem
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    return detail::integrate_adaptive(
+            stepper , system , start_state ,
+            start_time , end_time , dt ,
+            observer , stepper_category() );
+
+    /*
+     * Suggestion for a new extendable version:
+     *
+     * integrator_adaptive< Stepper , System, State , Time , Observer , typename Stepper::stepper_category > integrator;
+     * return integrator.run( stepper , system , start_state , start_time , end_time , dt , observer );
+     */
+}
+
+/**
+ * \brief Second version to solve the forwarding problem,
+ * can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_adaptive(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    return detail::integrate_adaptive(
+            stepper , system , start_state ,
+            start_time , end_time , dt ,
+            observer , stepper_category() );
+}
+
+
+
+
+/**
+ * \brief integrate_adaptive without an observer.
+ */
+template< class Stepper , class System , class State , class Time >
+size_t integrate_adaptive(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt )
+{
+    return integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , null_observer() );
+}
+
+/**
+ * \brief Second version to solve the forwarding problem,
+ * can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time >
+size_t integrate_adaptive(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time end_time , Time dt )
+{
+    return integrate_adaptive( stepper , system , start_state , start_time , end_time , dt , null_observer() );
+}
+
+
+/************* DOXYGEN ************/
+
+    /** 
+     * \fn integrate_adaptive( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer )
+     * \brief Integrates the ODE with adaptive step size.
+     * 
+     * This function integrates the ODE given by system with the given stepper.
+     * The observer is called after each step. If the stepper has no error 
+     * control, the step size remains constant and the observer is called at
+     * equidistant time points t0+n*dt. If the stepper is a ControlledStepper,
+     * the step size is adjusted and the observer is called in non-equidistant
+     * intervals.
+     *
+     * \param stepper The stepper to be used for numerical integration.
+     * \param system Function/Functor defining the rhs of the ODE.
+     * \param start_state The initial condition x0.
+     * \param start_time The initial time t0.
+     * \param end_time The final integration time tend.
+     * \param dt The time step between observer calls, _not_ necessarily the 
+     * time step of the integration.
+     * \param observer Function/Functor called at equidistant time intervals.
+     * \return The number of steps performed.
+     */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_ADAPTIVE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/integrate/integrate_const.hpp b/include/boost/numeric/odeint/iterator/integrate/integrate_const.hpp
new file mode 100644
index 0000000..ffcea6c
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/integrate_const.hpp
@@ -0,0 +1,158 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate_const.hpp
+
+ [begin_description]
+ Constant integration of ODEs, meaning that the state of the ODE is observed on constant time intervals.
+ The routines makes full use of adaptive and dense-output methods.
+ [end_description]
+
+ Copyright 2009-2011 Karsten Ahnert
+ Copyright 2009-2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+
+
+/*
+ * Integrates with constant time step dt.
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer
+)
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    // we want to get as fast as possible to the end
+    if( boost::is_same< null_observer , Observer >::value )
+    {
+        return detail::integrate_adaptive(
+                stepper , system , start_state ,
+                start_time , end_time  , dt ,
+                observer , stepper_category() );
+    }
+    else
+    {
+        return detail::integrate_const( stepper , system , start_state , 
+                                        start_time , end_time , dt ,
+                                        observer , stepper_category() );
+      }
+}
+
+/**
+ * \brief Second version to solve the forwarding problem, 
+ * can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+size_t integrate_const(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time end_time , Time dt ,
+        Observer observer
+)
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    // we want to get as fast as possible to the end
+    if( boost::is_same< null_observer , Observer >::value )
+    {
+        return detail::integrate_adaptive(
+                stepper , system , start_state ,
+                start_time , end_time  , dt ,
+                observer , stepper_category() );
+    }
+    else
+    {
+        return detail::integrate_const( stepper , system , start_state , 
+                                        start_time , end_time , dt ,
+                                        observer , stepper_category() );
+    }
+}
+
+
+
+
+
+/**
+ * \brief integrate_const without observer calls
+ */
+template< class Stepper , class System , class State , class Time >
+size_t integrate_const(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time end_time , Time dt
+)
+{
+    return integrate_const( stepper , system , start_state , start_time , end_time , dt , null_observer() );
+}
+
+/**
+ * \brief Second version to solve the forwarding problem,
+ * can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time >
+size_t integrate_const(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time end_time , Time dt
+)
+{
+    return integrate_const( stepper , system , start_state , start_time , end_time , dt , null_observer() );
+}
+
+
+
+
+
+
+/********* DOXYGEN *********/
+    /**
+     * \fn integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer )
+     * \brief Integrates the ODE with constant step size.
+     *
+     * Integrates the ODE defined by system using the given stepper.
+     * This method ensures that the observer is called at constant intervals dt.
+     * If the Stepper is a normal stepper without step size control, dt is also
+     * used for the numerical scheme. If a ControlledStepper is provided, the 
+     * algorithm might reduce the step size to meet the error bounds, but it is 
+     * ensured that the observer is always called at equidistant time points
+     * t0 + n*dt. If a DenseOutputStepper is used, the step size also may vary
+     * and the dense output is used to call the observer at equidistant time
+     * points.
+     *
+     * \param stepper The stepper to be used for numerical integration.
+     * \param system Function/Functor defining the rhs of the ODE.
+     * \param start_state The initial condition x0.
+     * \param start_time The initial time t0.
+     * \param end_time The final integration time tend.
+     * \param dt The time step between observer calls, _not_ necessarily the 
+     * time step of the integration.
+     * \param observer Function/Functor called at equidistant time intervals.
+     * \return The number of steps performed.
+     */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/integrate/integrate_n_steps.hpp b/include/boost/numeric/odeint/iterator/integrate/integrate_n_steps.hpp
new file mode 100644
index 0000000..8f30c77
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/integrate_n_steps.hpp
@@ -0,0 +1,125 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate_n_steps.hpp
+
+ [begin_description]
+ Integration of n steps with constant time size. Adaptive and dense-output methods are fully supported.
+ [end_description]
+
+ Copyright 2009-2011 Karsten Ahnert
+ Copyright 2009-2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * Integrates n steps
+ *
+ * the two overloads are needed in order to solve the forwarding problem
+ */
+template< class Stepper , class System , class State , class Time , class Observer>
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    return detail::integrate_n_steps(
+                stepper , system , start_state ,
+                start_time , dt , num_of_steps ,
+                observer , stepper_category() );
+}
+
+/**
+ * \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time , class Observer >
+Time integrate_n_steps(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    return detail::integrate_n_steps(
+                 stepper , system , start_state ,
+                 start_time , dt , num_of_steps ,
+                 observer , stepper_category() );
+}
+
+
+/**
+ * \brief The same function as above, but without observer calls.
+ */
+template< class Stepper , class System , class State , class Time >
+Time integrate_n_steps(
+        Stepper stepper , System system , State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps )
+{
+    return integrate_n_steps( stepper , system , start_state , start_time , dt , num_of_steps , null_observer() );
+}
+
+/**
+ * \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class Time >
+Time integrate_n_steps(
+        Stepper stepper , System system , const State &start_state ,
+        Time start_time , Time dt , size_t num_of_steps )
+{
+    return integrate_n_steps( stepper , system , start_state , start_time , dt , num_of_steps , null_observer() );
+}
+
+
+
+/************* DOXYGEN *************/
+    /**
+     * \fn Time integrate_n_steps( Stepper stepper , System system , State &start_state , Time start_time , Time dt , size_t num_of_steps , Observer observer )
+     * \brief Integrates the ODE with constant step size.
+     *
+     * This function is similar to integrate_const. The observer is called at
+     * equidistant time intervals t0 + n*dt.
+     * If the Stepper is a normal stepper without step size control, dt is also
+     * used for the numerical scheme. If a ControlledStepper is provided, the 
+     * algorithm might reduce the step size to meet the error bounds, but it is 
+     * ensured that the observer is always called at equidistant time points
+     * t0 + n*dt. If a DenseOutputStepper is used, the step size also may vary
+     * and the dense output is used to call the observer at equidistant time
+     * points. The final integration time is always t0 + num_of_steps*dt.
+     *
+     * \param stepper The stepper to be used for numerical integration.
+     * \param system Function/Functor defining the rhs of the ODE.
+     * \param start_state The initial condition x0.
+     * \param start_time The initial time t0.
+     * \param dt The time step between observer calls, _not_ necessarily the 
+     * time step of the integration.
+     * \param num_of_steps Number of steps to be performed
+     * \param observer Function/Functor called at equidistant time intervals.
+     * \return The number of steps performed.
+     */
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_N_STEPS_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/integrate/integrate_times.hpp b/include/boost/numeric/odeint/iterator/integrate/integrate_times.hpp
new file mode 100644
index 0000000..1bbd836
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/integrate_times.hpp
@@ -0,0 +1,133 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/integrate_times.hpp
+
+ [begin_description]
+ Integration of ODEs with observation at user defined points
+ [end_description]
+
+ Copyright 2009-2011 Karsten Ahnert
+ Copyright 2009-2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/range.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/integrate/null_observer.hpp>
+#include <boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * the two overloads are needed in order to solve the forwarding problem
+ */
+template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        TimeIterator times_start , TimeIterator times_end , Time dt ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    return detail::integrate_times(
+            stepper , system , start_state ,
+            times_start , times_end , dt ,
+            observer , stepper_category() );
+}
+
+/**
+ * \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class TimeIterator , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , const State &start_state ,
+        TimeIterator times_start , TimeIterator times_end , Time dt ,
+        Observer observer )
+{
+    typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
+    return detail::integrate_times(
+            stepper , system , start_state ,
+            times_start , times_end , dt ,
+            observer , stepper_category() );
+}
+
+/**
+ * \brief The same function as above, but without observer calls.
+ */
+template< class Stepper , class System , class State , class TimeRange , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , State &start_state ,
+        const TimeRange &times , Time dt ,
+        Observer observer )
+{
+    return integrate_times(
+            stepper , system , start_state ,
+            boost::begin( times ) , boost::end( times ) , dt , observer );
+}
+
+/**
+ * \brief Solves the forwarding problem, can be called with Boost.Range as start_state.
+ */
+template< class Stepper , class System , class State , class TimeRange , class Time , class Observer >
+size_t integrate_times(
+        Stepper stepper , System system , const State &start_state ,
+        const TimeRange &times , Time dt ,
+        Observer observer )
+{
+    return integrate_times(
+            stepper , system , start_state ,
+            boost::begin( times ) , boost::end( times ) , dt , observer );
+}
+
+
+
+
+/********* DOXYGEN ***********/
+
+    /**
+     * \fn size_t integrate_times( Stepper stepper , System system , State &start_state , TimeIterator times_start , TimeIterator times_end , Time dt , Observer observer )
+     * \brief Integrates the ODE with observer calls at given time points.
+     *
+     * Integrates the ODE given by system using the given stepper. This function
+     * does observer calls at the subsequent time points given by the range 
+     * times_start, times_end. If the stepper has not step size control, the 
+     * step size might be reduced occasionally to ensure observer calls exactly
+     * at the time points from the given sequence. If the stepper is a 
+     * ControlledStepper, the step size is adjusted to meet the error bounds, 
+     * but also might be reduced occasionally to ensure correct observer calls.
+     * If a DenseOutputStepper is provided, the dense output functionality is
+     * used to call the observer at the given times. The end time of the 
+     * integration is always *(end_time-1).
+     *
+     * \param stepper The stepper to be used for numerical integration.
+     * \param system Function/Functor defining the rhs of the ODE.
+     * \param start_state The initial condition x0.
+     * \param times_start Iterator to the start time
+     * \param times_end Iterator to the end time
+     * \param dt The time step between observer calls, _not_ necessarily the 
+     * time step of the integration.
+     * \param observer Function/Functor called at equidistant time intervals.
+     * \return The number of steps performed.
+     */
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_TIMES_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/integrate/null_observer.hpp b/include/boost/numeric/odeint/iterator/integrate/null_observer.hpp
new file mode 100644
index 0000000..4d9a070
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/null_observer.hpp
@@ -0,0 +1,38 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/null_observer.hpp
+
+ [begin_description]
+ null_observer
+ [end_description]
+
+ Copyright 2009-2011 Karsten Ahnert
+ Copyright 2009-2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+struct null_observer
+{
+    template< class State , class Time >
+    void operator()( const State& /* x */ , Time /* t */ ) const
+    {
+
+    }
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/integrate/observer_collection.hpp b/include/boost/numeric/odeint/iterator/integrate/observer_collection.hpp
new file mode 100644
index 0000000..26101a3
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/integrate/observer_collection.hpp
@@ -0,0 +1,56 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/integrate/observer_collection.hpp
+
+ [begin_description]
+ Collection of observers, which are all called during the evolution of the ODE.
+ [end_description]
+
+ Copyright 2009-2011 Karsten Ahnert
+ Copyright 2009-2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED
+
+#include <vector>
+
+#include <boost/function.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class State , class Time >
+class observer_collection
+{
+public:
+
+    typedef boost::function< void( const State& , const Time& ) > observer_type;
+    typedef std::vector< observer_type > collection_type;
+
+    void operator()( const State& x , Time t )
+    {
+        for( size_t i=0 ; i<m_observers.size() ; ++i )
+            m_observers[i]( x , t );
+    }
+
+    collection_type& observers( void ) { return m_observers; }
+    const collection_type& observers( void ) const { return m_observers; }
+
+private:
+
+    collection_type m_observers;
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_OBSERVER_COLLECTION_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/n_step_iterator.hpp b/include/boost/numeric/odeint/iterator/n_step_iterator.hpp
new file mode 100644
index 0000000..195e981
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/n_step_iterator.hpp
@@ -0,0 +1,168 @@
+
+/*
+ [auto_generated]
+ boost/numeric/odeint/iterator/n_step_iterator.hpp
+
+ [begin_description]
+ Iterator for iterating through the solution of an ODE with constant step size performing exactly n steps.
+ [end_description]
+
+ Copyright 2009-2013 Karsten Ahnert
+ Copyright 2009-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_N_STEP_ITERATOR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_N_STEP_ITERATOR_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/stepper_traits.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+#include <boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    /* use the n_step_iterator_impl with the right tags */
+    template< class Stepper , class System , class State
+#ifndef DOXYGEN_SKIP
+     , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type
+#endif
+     >
+    class n_step_iterator : public n_step_iterator_impl<
+            n_step_iterator< Stepper , System , State , StepperTag > ,
+            Stepper , System , State , detail::ode_state_iterator_tag , StepperTag
+        >
+    {
+        typedef typename traits::time_type< Stepper >::type time_type;
+        typedef n_step_iterator< Stepper , System , State , StepperTag > iterator_type;
+
+    public:
+        n_step_iterator( Stepper stepper , System sys , State &s , time_type t , time_type dt , size_t num_of_steps )
+            : n_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s , t , dt , num_of_steps )
+        {}
+
+        n_step_iterator( Stepper stepper , System sys , State &s )
+            : n_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s )
+        {}
+    };
+
+    /* make functions */
+
+    template< class Stepper , class System , class State >
+    n_step_iterator< Stepper , System, State > make_n_step_iterator_begin(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t ,
+        typename traits::time_type< Stepper >::type dt ,
+        size_t num_of_steps )
+    {
+        return n_step_iterator< Stepper , System , State >( stepper , system , x , t , dt , num_of_steps );
+    }
+
+    template< class Stepper , class System , class State >
+    n_step_iterator< Stepper , System , State > make_n_step_iterator_end(
+        Stepper stepper ,
+        System system , 
+        State &x )
+    {
+        return n_step_iterator< Stepper , System , State >( stepper , system , x );
+    }
+
+    template< class Stepper , class System , class State >
+    std::pair< n_step_iterator< Stepper , System , State > , n_step_iterator< Stepper , System , State > >
+    make_n_step_range(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t ,
+        typename traits::time_type< Stepper >::type dt ,
+        size_t num_of_steps )
+    {
+        return std::make_pair(
+            n_step_iterator< Stepper , System , State >( stepper , system , x , t , dt , num_of_steps ) ,
+            n_step_iterator< Stepper , System , State >( stepper , system , x )
+            );
+    }
+
+
+    /**
+     * \class n_step_iterator
+     *
+     * \brief ODE Iterator with constant step size. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an iterator representing the solution of an ODE starting from t
+     * with n steps and a constant step size dt.
+     * After each iteration the iterator dereferences to the state x at the next
+     * time t+dt.
+     * This iterator can be used with Steppers and
+     * DenseOutputSteppers and it always makes use of the all the given steppers
+     * capabilities. A for_each over such an iterator range behaves similar to
+     * the integrate_n_steps routine.
+     *
+     * n_step_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     * \tparam State The state type of the ODE.
+     */
+
+
+    /**
+     * \fn make_n_step_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps )
+     *
+     * \brief Factory function for n_step_iterator. Constructs a begin iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \param t The initial time.
+     * \param dt The initial time step.
+     * \param num_of_steps The number of steps to be executed.
+     * \returns The n-step iterator.
+     */
+
+
+    /**
+     * \fn make_n_step_iterator_end( Stepper stepper , System system , State &x )
+     * \brief Factory function for n_step_iterator. Constructs an end iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \returns The const_step_iterator.
+     */
+
+
+    /**
+     * \fn make_n_step_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , , size_t num_of_steps )
+     *
+     * \brief Factory function to construct a single pass range of n-step iterators. A range is here a pair
+     * of n_step_iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator store a reference of s and changes its value during the iteration.
+     * \param t The initial time.
+     * \param dt The initial time step.
+     * \param num_of_steps The number of steps to be executed.
+     * \returns The n-step range.
+     */
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_CONST_N_STEP_ITERATOR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/n_step_time_iterator.hpp b/include/boost/numeric/odeint/iterator/n_step_time_iterator.hpp
new file mode 100644
index 0000000..8ed17de
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/n_step_time_iterator.hpp
@@ -0,0 +1,169 @@
+
+/*
+ [auto_generated]
+ boost/numeric/odeint/iterator/n_step_time_iterator.hpp
+
+ [begin_description]
+ Iterator for iterating through the solution of an ODE with constant step size performing exactly n steps.
+ The dereferenced type contains also the time.
+ [end_description]
+
+ Copyright 2009-2013 Karsten Ahnert
+ Copyright 2009-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_N_STEP_TIME_ITERATOR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_N_STEP_TIME_ITERATOR_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/stepper_traits.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+#include <boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    /* use the n_step_iterator_impl with the right tags */
+    template< class Stepper , class System , class State
+#ifndef DOXYGEN_SKIP
+        , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type
+#endif
+    >
+    class n_step_time_iterator : public n_step_iterator_impl<
+            n_step_time_iterator< Stepper , System , State , StepperTag > ,
+            Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag
+        >
+    {
+        typedef typename traits::time_type< Stepper >::type time_type;
+        typedef n_step_time_iterator< Stepper , System , State , StepperTag > iterator_type;
+
+    public:
+        n_step_time_iterator( Stepper stepper , System sys , State &s , time_type t , time_type dt , size_t num_of_steps )
+            : n_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s , t , dt , num_of_steps )
+        {}
+
+        n_step_time_iterator( Stepper stepper , System sys , State &s )
+            : n_step_iterator_impl< iterator_type , Stepper , System , State , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s )
+        {}
+    };
+
+    /* make functions */
+
+    template< class Stepper , class System , class State >
+    n_step_time_iterator< Stepper , System, State > make_n_step_time_iterator_begin(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t ,
+        typename traits::time_type< Stepper >::type dt ,
+        size_t num_of_steps )
+    {
+        return n_step_time_iterator< Stepper , System , State >( stepper , system , x , t , dt , num_of_steps );
+    }
+
+    template< class Stepper , class System , class State >
+    n_step_time_iterator< Stepper , System , State > make_n_step_time_iterator_end(
+        Stepper stepper ,
+        System system , 
+        State &x )
+    {
+        return n_step_time_iterator< Stepper , System , State >( stepper , system , x );
+    }
+
+    template< class Stepper , class System , class State >
+    std::pair< n_step_time_iterator< Stepper , System , State > , n_step_time_iterator< Stepper , System , State > >
+    make_n_step_time_range(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        typename traits::time_type< Stepper >::type t ,
+        typename traits::time_type< Stepper >::type dt ,
+        size_t num_of_steps )
+    {
+        return std::make_pair(
+            n_step_time_iterator< Stepper , System , State >( stepper , system , x , t , dt , num_of_steps ) ,
+            n_step_time_iterator< Stepper , System , State >( stepper , system , x )
+            );
+    }
+
+
+    /**
+     * \class n_step_time_iterator
+     *
+     * \brief ODE Iterator with constant step size. The value type of this iterator is a std::pair containing state and time.
+     *
+     * Implements an iterator representing the solution of an ODE starting from t
+     * with n steps and a constant step size dt.
+     * After each iteration the iterator dereferences to a pair of state and time at the next
+     * time t+dt.
+     * This iterator can be used with Steppers and
+     * DenseOutputSteppers and it always makes use of the all the given steppers
+     * capabilities. A for_each over such an iterator range behaves similar to
+     * the integrate_n_steps routine.
+     *
+     * n_step_time_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is pair of state and time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     * \tparam State The state type of the ODE.
+     */
+
+
+    /**
+     * \fn make_n_step_time_iterator_begin( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps )
+     *
+     * \brief Factory function for n_step_time_iterator. Constructs a begin iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \param t The initial time.
+     * \param dt The initial time step.
+     * \param num_of_steps The number of steps to be executed.
+     * \returns The n-step iterator.
+     */
+
+
+    /**
+     * \fn make_n_step_time_iterator_end( Stepper stepper , System system , State &x )
+     * \brief Factory function for n_step_time_iterator. Constructs an end iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \returns The const_step_iterator.
+     */
+
+
+    /**
+     * \fn make_n_step_time_range( Stepper stepper , System system , State &x , typename traits::time_type< Stepper >::type t , typename traits::time_type< Stepper >::type dt , size_t num_of_steps )
+     *
+     * \brief Factory function to construct a single pass range of n-step iterators. A range is here a pair
+     * of n_step_time_iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator store a reference of s and changes its value during the iteration.
+     * \param t The initial time.
+     * \param dt The initial time step.
+     * \param num_of_steps The number of steps to be executed.
+     * \returns The n-step range.
+     */
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_CONST_N_STEP_TIME_ITERATOR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/times_iterator.hpp b/include/boost/numeric/odeint/iterator/times_iterator.hpp
new file mode 100644
index 0000000..e6c9b85
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/times_iterator.hpp
@@ -0,0 +1,189 @@
+
+/*
+ [auto_generated]
+ boost/numeric/odeint/iterator/times_iterator.hpp
+
+ [begin_description]
+ Iterator for iterating through the solution of an ODE with oscillator calls at times from a given sequence.
+ [end_description]
+
+ Copyright 2009-2013 Karsten Ahnert
+ Copyright 2009-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_ITERATOR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_ITERATOR_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/stepper_traits.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+#include <boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    /* use the times_iterator_impl with the right tags */
+    template< class Stepper , class System , class State , class TimeIterator
+#ifndef DOXYGEN_SKIP
+        , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type
+#endif
+    >
+    class times_iterator : public times_iterator_impl<
+            times_iterator< Stepper , System , State , TimeIterator , StepperTag > ,
+            Stepper , System , State , TimeIterator , detail::ode_state_iterator_tag , StepperTag
+        >
+    {
+        typedef typename traits::time_type< Stepper >::type time_type;
+        typedef times_iterator< Stepper , System , State , TimeIterator , StepperTag > iterator_type;
+
+    public:
+        times_iterator( Stepper stepper , System sys , State &s ,
+                        TimeIterator t_start , TimeIterator t_end , time_type dt )
+            : times_iterator_impl< iterator_type , Stepper , System , State , TimeIterator, detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt )
+        {}
+
+        times_iterator( Stepper stepper , System sys , State &s )
+            : times_iterator_impl< iterator_type , Stepper , System , State , TimeIterator , detail::ode_state_iterator_tag , StepperTag >( stepper , sys , s )
+        {}
+    };
+
+    /* make functions */
+
+    template< class Stepper , class System , class State , class TimeIterator >
+    times_iterator< Stepper , System, State , TimeIterator > make_times_iterator_begin(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        TimeIterator t_start ,
+        TimeIterator t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return times_iterator< Stepper , System , State , TimeIterator >( stepper , system , x , t_start , t_end , dt );
+    }
+
+    // ToDo: requires to specifically provide the TimeIterator template parameter, can this be improved?
+    template< class TimeIterator , class Stepper , class System , class State >
+    times_iterator< Stepper , System , State , TimeIterator > make_times_iterator_end(
+        Stepper stepper ,
+        System system , 
+        State &x )
+        //TimeIterator t_end )
+    {
+        return times_iterator< Stepper , System , State , TimeIterator >( stepper , system , x );
+    }
+
+    template< class Stepper , class System , class State , class TimeIterator >
+    std::pair< times_iterator< Stepper , System , State , TimeIterator > ,
+               times_iterator< Stepper , System , State , TimeIterator > >
+    make_times_range(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        TimeIterator t_start ,
+        TimeIterator t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return std::make_pair(
+            times_iterator< Stepper , System , State , TimeIterator >( stepper , system , x , t_start , t_end , dt ) ,
+            times_iterator< Stepper , System , State , TimeIterator >( stepper , system , x )
+            );
+    }
+
+
+    /**
+     * \class times_iterator
+     *
+     * \brief ODE Iterator with given evaluation points. The value type of this iterator is the state type of the stepper.
+     *
+     * Implements an iterator representing the solution of an ODE from *t_start
+     * to *t_end evaluated at time points given by the sequence t_start to t_end.
+     * t_start and t_end are iterators representing a sequence of time points
+     * where the solution of the ODE should be evaluated.
+     * After each iteration the iterator dereferences to the state x at the next
+     * time *t_start++ until t_end is reached.
+     * This iterator can be used with Steppers, ControlledSteppers and
+     * DenseOutputSteppers and it always makes use of the all the given steppers
+     * capabilities. A for_each over such an iterator range behaves similar to
+     * the integrate_times routine.
+     *
+     * times_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     * \tparam State The state type of the ODE.
+     * \tparam TimeIterator The iterator type for the sequence of time points.
+     */
+
+
+
+    /**
+     * \fn make_times_iterator_begin( Stepper stepper ,
+        System system ,
+        State &x ,
+        TimeIterator t_start ,
+        TimeIterator t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function for times_iterator. Constructs a begin iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \param t_start Begin iterator of the sequence of evaluation time points.
+     * \param t_end End iterator of the sequence of evaluation time points.
+     * \param dt The initial time step.
+     * \returns The times iterator.
+     */
+
+
+    /**
+     * \fn make_times_iterator_end( Stepper stepper , System system , State &x )
+     * \brief Factory function for times_iterator. Constructs an end iterator.
+     *
+     * \tparam TimesIterator The iterator type of the time sequence, must be specifically provided.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \returns The times iterator.
+     *
+     * This function needs the TimeIterator type specifically defined as a
+     * template parameter.
+     */
+
+
+    /**
+     * \fn make_times_range( Stepper stepper , System system , State &x ,
+        TimeIterator t_start ,
+        TimeIterator t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function to construct a single pass range of times iterators. A range is here a pair
+     * of times_iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator store a reference of s and changes its value during the iteration.
+     * \param t_start Begin iterator of the sequence of evaluation time points.
+     * \param t_end End iterator of the sequence of evaluation time points.
+     * \param dt The initial time step.
+     * \returns The times iterator range.
+     */
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_ITERATOR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/iterator/times_time_iterator.hpp b/include/boost/numeric/odeint/iterator/times_time_iterator.hpp
new file mode 100644
index 0000000..94fd9a3
--- /dev/null
+++ b/include/boost/numeric/odeint/iterator/times_time_iterator.hpp
@@ -0,0 +1,193 @@
+
+/*
+ [auto_generated]
+ boost/numeric/odeint/iterator/times_time_iterator.hpp
+
+ [begin_description]
+ Iterator for iterating through the solution of an ODE with oscillator calls at times from a given sequence.
+ The dereferenced type contains also the time.
+ [end_description]
+
+ Copyright 2009-2013 Karsten Ahnert
+ Copyright 2009-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_TIME_ITERATOR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_TIME_ITERATOR_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/stepper_traits.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
+#include <boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+    /* use the times_iterator_impl with the right tags */
+    template< class Stepper , class System , class State , class TimeIterator
+#ifndef DOXYGEN_SKIP
+        , class StepperTag = typename base_tag< typename traits::stepper_category< Stepper >::type >::type
+#endif
+    >
+    class times_time_iterator : public times_iterator_impl<
+            times_time_iterator< Stepper , System , State , TimeIterator , StepperTag > ,
+            Stepper , System , State , TimeIterator , detail::ode_state_time_iterator_tag , StepperTag
+        >
+    {
+        typedef typename traits::time_type< Stepper >::type time_type;
+        typedef times_time_iterator< Stepper , System , State , TimeIterator , StepperTag > iterator_type;
+
+    public:
+        times_time_iterator( Stepper stepper , System sys , State &s ,
+                        TimeIterator t_start , TimeIterator t_end , time_type dt )
+            : times_iterator_impl< iterator_type , Stepper , System , State , TimeIterator, detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s , t_start , t_end , dt )
+        {}
+
+        times_time_iterator( Stepper stepper , System sys , State &s )
+            : times_iterator_impl< iterator_type , Stepper , System , State , TimeIterator , detail::ode_state_time_iterator_tag , StepperTag >( stepper , sys , s )
+        {}
+    };
+
+    /* make functions */
+
+    template< class Stepper , class System , class State , class TimeIterator >
+    times_time_iterator< Stepper , System, State , TimeIterator > make_times_time_iterator_begin(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        TimeIterator t_start ,
+        TimeIterator t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return times_time_iterator< Stepper , System , State , TimeIterator >( stepper , system , x , t_start , t_end , dt );
+    }
+
+    // ToDo: requires to specifically provide the TimeIterator template parameter, can this be improved?
+    template< class TimeIterator , class Stepper , class System , class State >
+    times_time_iterator< Stepper , System , State , TimeIterator > make_times_time_iterator_end(
+        Stepper stepper ,
+        System system , 
+        State &x )
+        //TimeIterator t_end )
+    {
+        return times_time_iterator< Stepper , System , State , TimeIterator >( stepper , system , x );
+    }
+
+    template< class Stepper , class System , class State , class TimeIterator >
+    std::pair< times_time_iterator< Stepper , System , State , TimeIterator > ,
+               times_time_iterator< Stepper , System , State , TimeIterator > >
+    make_times_time_range(
+        Stepper stepper ,
+        System system , 
+        State &x ,
+        TimeIterator t_start ,
+        TimeIterator t_end ,
+        typename traits::time_type< Stepper >::type dt )
+    {
+        return std::make_pair(
+            times_time_iterator< Stepper , System , State , TimeIterator >( stepper , system , x , t_start , t_end , dt ) ,
+            times_time_iterator< Stepper , System , State , TimeIterator >( stepper , system , x )
+            );
+    }
+
+
+
+
+
+    /**
+     * \class times_time_iterator
+     *
+     * \brief ODE Iterator with given evaluation points. The value type of this iterator is a std::pair containing state and time.
+     *
+     * Implements an iterator representing the solution of an ODE from *t_start
+     * to *t_end evaluated at time points given by the sequence t_start to t_end.
+     * t_start and t_end are iterators representing a sequence of time points
+     * where the solution of the ODE should be evaluated.
+     * After each iteration the iterator dereferences to a pair with the state
+     * and the time at the next evaluation point *t_start++ until t_end is reached.
+     * This iterator can be used with Steppers, ControlledSteppers and
+     * DenseOutputSteppers and it always makes use of the all the given steppers
+     * capabilities. A for_each over such an iterator range behaves similar to
+     * the integrate_times routine.
+     *
+     * times_time_iterator is a model of single-pass iterator.
+     *
+     * The value type of this iterator is a pair of state and time type.
+     *
+     * \tparam Stepper The stepper type which should be used during the iteration.
+     * \tparam System The type of the system function (ODE) which should be solved.
+     * \tparam State The state type of the ODE.
+     * \tparam TimeIterator The iterator type for the sequence of time points.
+     */
+
+
+
+    /**
+     * \fn make_times_time_iterator_begin( Stepper stepper ,
+        System system ,
+        State &x ,
+        TimeIterator t_start ,
+        TimeIterator t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function for times_time_iterator. Constructs a begin iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \param t_start Begin iterator of the sequence of evaluation time points.
+     * \param t_end End iterator of the sequence of evaluation time points.
+     * \param dt The initial time step.
+     * \returns The times_time iterator.
+     */
+
+
+    /**
+     * \fn make_times_time_iterator_end( Stepper stepper , System system , State &x )
+     * \brief Factory function for times_time_iterator. Constructs an end iterator.
+     *
+     * \tparam TimesIterator The iterator type of the time sequence, must be specifically provided.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
+     * \returns The times_time iterator.
+     *
+     * This function needs the TimeIterator type specifically defined as a
+     * template parameter.
+     */
+
+
+    /**
+     * \fn make_times_time_range( Stepper stepper , System system , State &x ,
+        TimeIterator t_start ,
+        TimeIterator t_end ,
+        typename traits::time_type< Stepper >::type dt )
+     *
+     * \brief Factory function to construct a single pass range of times_time iterators. A range is here a pair
+     * of times_iterator.
+     *
+     * \param stepper The stepper to use during the iteration.
+     * \param system The system function (ODE) to solve.
+     * \param x The initial state. const_step_iterator store a reference of s and changes its value during the iteration.
+     * \param t_start Begin iterator of the sequence of evaluation time points.
+     * \param t_end End iterator of the sequence of evaluation time points.
+     * \param dt The initial time step.
+     * \returns The times_time iterator range.
+     */
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_ITERATOR_TIMES_TIME_ITERATOR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/adams_bashforth.hpp b/include/boost/numeric/odeint/stepper/adams_bashforth.hpp
new file mode 100644
index 0000000..5ff1e83
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/adams_bashforth.hpp
@@ -0,0 +1,420 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/adams_bashforth.hpp
+
+ [begin_description]
+ Implementaton of the Adam-Bashforth method a multistep method used for the predictor step in the
+ Adams-Bashforth-Moulton method.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2012 Christoph Koke
+ Copyright 2013 Pascal Germroth
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_HPP_INCLUDED
+
+#include <boost/static_assert.hpp>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta4.hpp>
+#include <boost/numeric/odeint/stepper/extrapolation_stepper.hpp>
+
+#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
+
+#include <boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp>
+#include <boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp>
+#include <boost/numeric/odeint/stepper/detail/rotating_buffer.hpp>
+
+#include <boost/mpl/arithmetic.hpp>
+#include <boost/mpl/min_max.hpp>
+#include <boost/mpl/equal_to.hpp>
+
+namespace mpl = boost::mpl;
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+    using mpl::int_;
+
+    /* if N >= 4, returns the smallest even number > N, otherwise returns 4 */
+    template < int N >
+    struct order_helper
+        : mpl::max< typename mpl::eval_if<
+                        mpl::equal_to< mpl::modulus< int_< N >, int_< 2 > >,
+                                       int_< 0 > >,
+                        int_< N >, int_< N + 1 > >::type,
+                    int_< 4 > >::type
+    { };
+
+template<
+size_t Steps ,
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer ,
+class InitializingStepper = extrapolation_stepper< order_helper<Steps>::value, 
+                                                   State, Value, Deriv, Time,
+                                                   Algebra, Operations, Resizer >
+>
+class adams_bashforth : public algebra_stepper_base< Algebra , Operations >
+{
+
+#ifndef DOXYGEN_SKIP
+    BOOST_STATIC_ASSERT(( Steps > 0 ));
+    BOOST_STATIC_ASSERT(( Steps < 9 ));
+#endif
+
+public :
+
+    typedef State state_type;
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef Time time_type;
+    typedef Resizer resizer_type;
+    typedef stepper_tag stepper_category;
+
+    typedef InitializingStepper initializing_stepper_type;
+
+    typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
+    typedef typename algebra_stepper_base_type::algebra_type algebra_type;
+    typedef typename algebra_stepper_base_type::operations_type operations_type;
+#ifndef DOXYGEN_SKIP
+    typedef adams_bashforth< Steps , State , Value , Deriv , Time , Algebra , Operations , Resizer , InitializingStepper > stepper_type;
+#endif
+    static const size_t steps = Steps;
+
+
+
+    typedef unsigned short order_type;
+    static const order_type order_value = steps;
+
+    typedef detail::rotating_buffer< wrapped_deriv_type , steps > step_storage_type;
+
+
+    
+    order_type order( void ) const { return order_value; }
+
+    adams_bashforth( const algebra_type &algebra = algebra_type() )
+    : algebra_stepper_base_type( algebra ) ,
+      m_step_storage() , m_resizer() , m_coefficients() ,
+      m_steps_initialized( 0 ) , m_initializing_stepper()
+    { }
+
+
+
+    /*
+     * Version 1 : do_step( system , x , t , dt );
+     *
+     * solves the forwarding problem
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , StateInOut &x , time_type t , time_type dt )
+    {
+        do_step( system , x , t , x , dt );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , const StateInOut &x , time_type t , time_type dt )
+    {
+        do_step( system , x , t , x , dt );
+    }
+
+
+
+    /*
+     * Version 2 : do_step( system , in , t , out , dt );
+     *
+     * solves the forwarding problem
+     */
+
+    template< class System , class StateIn , class StateOut >
+    void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+    {
+        do_step_impl( system , in , t , out , dt );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateOut.
+     */
+    template< class System , class StateIn , class StateOut >
+    void do_step( System system , const StateIn &in , time_type t , const StateOut &out , time_type dt )
+    {
+        do_step_impl( system , in , t , out , dt );
+    }
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_impl( x );
+    }
+
+    const step_storage_type& step_storage( void ) const
+    {
+        return m_step_storage;
+    }
+
+    step_storage_type& step_storage( void )
+    {
+        return m_step_storage;
+    }
+
+    template< class ExplicitStepper , class System , class StateIn >
+    void initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt )
+    {
+        typename odeint::unwrap_reference< ExplicitStepper >::type &stepper = explicit_stepper;
+        typename odeint::unwrap_reference< System >::type &sys = system;
+
+        m_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
+
+        for( size_t i=0 ; i+1<steps ; ++i )
+        {
+            if( i != 0 ) m_step_storage.rotate();
+            sys( x , m_step_storage[0].m_v , t );
+            stepper.do_step_dxdt_impl( system, x, m_step_storage[0].m_v, t,
+                                       dt );
+            t += dt;
+        }
+        m_steps_initialized = steps;
+    }
+
+    template< class System , class StateIn >
+    void initialize( System system , StateIn &x , time_type &t , time_type dt )
+    {
+        initialize( detail::ref( m_initializing_stepper ) , system , x , t , dt );
+    }
+
+    void reset( void )
+    {
+        m_steps_initialized = 0;
+    }
+
+    bool is_initialized( void ) const
+    {
+        return m_steps_initialized >= ( steps - 1 );
+    }
+
+    const initializing_stepper_type& initializing_stepper( void ) const { return m_initializing_stepper; }
+
+    initializing_stepper_type& initializing_stepper( void ) { return m_initializing_stepper; }
+
+private:
+
+    template< class System , class StateIn , class StateOut >
+    void do_step_impl( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        if( m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) ) )
+        {
+            m_steps_initialized = 0;
+        }
+
+        if( m_steps_initialized + 1 < steps )
+        {
+            if( m_steps_initialized != 0 ) m_step_storage.rotate();
+            sys( in , m_step_storage[0].m_v , t );
+            m_initializing_stepper.do_step_dxdt_impl(
+                system, in, m_step_storage[0].m_v, t, out, dt );
+            ++m_steps_initialized;
+        }
+        else
+        {
+            m_step_storage.rotate();
+            sys( in , m_step_storage[0].m_v , t );
+            detail::adams_bashforth_call_algebra< steps , algebra_type , operations_type >()( this->m_algebra , in , out , m_step_storage , m_coefficients , dt );
+        }
+    }
+
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized( false );
+        for( size_t i=0 ; i<steps ; ++i )
+        {
+            resized |= adjust_size_by_resizeability( m_step_storage[i] , x , typename is_resizeable<deriv_type>::type() );
+        }
+        return resized;
+    }
+
+    step_storage_type m_step_storage;
+    resizer_type m_resizer;
+    detail::adams_bashforth_coefficients< value_type , steps > m_coefficients;
+    size_t m_steps_initialized;
+    initializing_stepper_type m_initializing_stepper;
+
+};
+
+
+/***** DOXYGEN *****/
+
+/**
+ * \class adams_bashforth
+ * \brief The Adams-Bashforth multistep algorithm.
+ *
+ * The Adams-Bashforth method is a multi-step algorithm with configurable step
+ * number. The step number is specified as template parameter Steps and it 
+ * then uses the result from the previous Steps steps. See also
+ * <a href="http://en.wikipedia.org/wiki/Linear_multistep_method">en.wikipedia.org/wiki/Linear_multistep_method</a>.
+ * Currently, a maximum of Steps=8 is supported.
+ * The method is explicit and fulfills the Stepper concept. Step size control
+ * or continuous output are not provided.
+ * 
+ * This class derives from algebra_base and inherits its interface via
+ * CRTP (current recurring template pattern). For more details see
+ * algebra_stepper_base.
+ *
+ * \tparam Steps The number of steps (maximal 8).
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ * \tparam InitializingStepper The stepper for the first two steps.
+ */
+
+    /**
+     * \fn adams_bashforth::adams_bashforth( const algebra_type &algebra )
+     * \brief Constructs the adams_bashforth class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor. 
+     * \param algebra A copy of algebra is made and stored.
+     */
+
+    /**
+     * \fn order_type adams_bashforth::order( void ) const
+     * \brief Returns the order of the algorithm, which is equal to the number of steps.
+     * \return order of the method.
+     */
+
+    /**
+     * \fn void adams_bashforth::do_step( System system , StateInOut &x , time_type t , time_type dt )
+     * \brief This method performs one step. It transforms the result in-place.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn void adams_bashforth::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn void adams_bashforth::adjust_size( const StateType &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+
+    /**
+     * \fn const step_storage_type& adams_bashforth::step_storage( void ) const
+     * \brief Returns the storage of intermediate results.
+     * \return The storage of intermediate results.
+     */
+
+    /**
+     * \fn step_storage_type& adams_bashforth::step_storage( void )
+     * \brief Returns the storage of intermediate results.
+     * \return The storage of intermediate results.
+     */
+
+    /**
+     * \fn void adams_bashforth::initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt )
+     * \brief Initialized the stepper. Does Steps-1 steps with the explicit_stepper to fill the buffer.
+     * \param explicit_stepper the stepper used to fill the buffer of previous step results
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn void adams_bashforth::initialize( System system , StateIn &x , time_type &t , time_type dt )
+     * \brief Initialized the stepper. Does Steps-1 steps with an internal instance of InitializingStepper to fill the buffer.
+     * \note The state x and time t are updated to the values after Steps-1 initial steps.
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \param x The initial state of the ODE which should be solved, updated in this method.
+     * \param t The initial value of the time, updated in this method.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn void adams_bashforth::reset( void )
+     * \brief Resets the internal buffer of the stepper.
+     */
+
+    /**
+     * \fn bool adams_bashforth::is_initialized( void ) const
+     * \brief Returns true if the stepper has been initialized.
+     * \return bool true if stepper is initialized, false otherwise
+     */
+
+    /**
+     * \fn const initializing_stepper_type& adams_bashforth::initializing_stepper( void ) const
+     * \brief Returns the internal initializing stepper instance.
+     * \return initializing_stepper
+     */
+
+    /**
+     * \fn const initializing_stepper_type& adams_bashforth::initializing_stepper( void ) const
+     * \brief Returns the internal initializing stepper instance.
+     * \return initializing_stepper
+     */
+
+    /**
+     * \fn initializing_stepper_type& adams_bashforth::initializing_stepper( void )
+     * \brief Returns the internal initializing stepper instance.
+     * \return initializing_stepper
+     */
+
+} // odeint
+} // numeric
+} // boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp b/include/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp
new file mode 100644
index 0000000..f3edce1
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp
@@ -0,0 +1,314 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp
+
+ [begin_description]
+ Implementation of the Adams-Bashforth-Moulton method, a predictor-corrector multistep method.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/numeric/odeint/stepper/adams_bashforth.hpp>
+#include <boost/numeric/odeint/stepper/adams_moulton.hpp>
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template<
+size_t Steps ,
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer,
+class InitializingStepper = runge_kutta4< State , Value , Deriv , Time , Algebra , Operations, Resizer >
+>
+class adams_bashforth_moulton
+{
+
+#ifndef DOXYGEN_SKIP
+    BOOST_STATIC_ASSERT(( Steps > 0 ));
+    BOOST_STATIC_ASSERT(( Steps < 9 ));
+#endif
+
+public :
+
+    typedef State state_type;
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef Time time_type;
+    typedef Algebra algebra_type;
+    typedef Operations operations_type;
+    typedef Resizer resizer_type;
+    typedef stepper_tag stepper_category;
+    typedef InitializingStepper initializing_stepper_type;
+
+    static const size_t steps = Steps;
+#ifndef DOXYGEN_SKIP
+    typedef adams_bashforth< steps , state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type, initializing_stepper_type > adams_bashforth_type;
+    typedef adams_moulton< steps , state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type > adams_moulton_type;
+    typedef adams_bashforth_moulton< steps , state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type , initializing_stepper_type> stepper_type;
+#endif //DOXYGEN_SKIP
+    typedef unsigned short order_type;
+    static const order_type order_value = steps;
+
+    /** \brief Constructs the adams_bashforth class. */
+    adams_bashforth_moulton( void )
+    : m_adams_bashforth() , m_adams_moulton( m_adams_bashforth.algebra() )
+    , m_x() , m_resizer()
+    { }
+
+    adams_bashforth_moulton( const algebra_type &algebra )
+    : m_adams_bashforth( algebra ) , m_adams_moulton( m_adams_bashforth.algebra() )
+    , m_x() , m_resizer()    
+    { }
+
+    order_type order( void ) const { return order_value; }
+
+    template< class System , class StateInOut >
+    void do_step( System system , StateInOut &x , time_type t , time_type dt )
+    {
+        do_step_impl1( system , x , t , dt );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , const StateInOut &x , time_type t , time_type dt )
+    {
+        do_step_impl1( system , x , t , dt );
+    }
+
+    template< class System , class StateIn , class StateOut >
+    void do_step( System system , const StateIn &in , time_type t , const StateOut &out , time_type dt )
+    {
+        do_step_impl2( system , in , t , out , dt );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateOut.
+     */
+    template< class System , class StateIn , class StateOut >
+    void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+    {
+        do_step_impl2( system , in ,t , out , dt );
+    }
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        m_adams_bashforth.adjust_size( x );
+        m_adams_moulton.adjust_size( x );
+        resize_impl( x );
+    }
+
+
+    template< class ExplicitStepper , class System , class StateIn >
+    void initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt )
+    {
+        m_adams_bashforth.initialize( explicit_stepper , system , x , t , dt );
+    }
+
+
+    template< class System , class StateIn >
+    void initialize( System system , StateIn &x , time_type &t , time_type dt )
+    {
+        m_adams_bashforth.initialize( system , x , t , dt );
+    }
+
+
+    void reset(void)
+    {
+        m_adams_bashforth.reset();
+    }
+
+
+
+private:
+    
+    template< typename System , typename StateInOut >
+    void do_step_impl1( System system , StateInOut &x , time_type t , time_type dt )
+    {
+        if( m_adams_bashforth.is_initialized() )
+        {
+            m_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
+            m_adams_bashforth.do_step( system , x , t , m_x.m_v , dt );
+            m_adams_moulton.do_step( system , x , m_x.m_v , t+dt , x , dt , m_adams_bashforth.step_storage() );
+        }
+        else
+        {
+            m_adams_bashforth.do_step( system , x , t , dt );
+        }
+    }
+    
+    template< typename System , typename StateIn , typename StateInOut >
+    void do_step_impl2( System system , StateIn const &in , time_type t , StateInOut & out , time_type dt )
+    {
+        if( m_adams_bashforth.is_initialized() )
+        {
+            m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );        
+            m_adams_bashforth.do_step( system , in , t , m_x.m_v , dt );
+            m_adams_moulton.do_step( system , in , m_x.m_v , t+dt , out , dt , m_adams_bashforth.step_storage() );
+        }
+        else
+        {
+            m_adams_bashforth.do_step( system , in , t , out , dt );
+        }
+    }
+
+    
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_x , x , typename is_resizeable< state_type >::type() );
+    }
+
+    adams_bashforth_type m_adams_bashforth;
+    adams_moulton_type m_adams_moulton;
+    wrapped_state_type m_x;
+    resizer_type m_resizer;
+};
+
+
+/********* DOXYGEN ********/
+
+/**
+ * \class adams_bashforth_moulton
+ * \brief The Adams-Bashforth-Moulton multistep algorithm.
+ *
+ * The Adams-Bashforth method is a multi-step predictor-corrector algorithm 
+ * with configurable step number. The step number is specified as template 
+ * parameter Steps and it then uses the result from the previous Steps steps. 
+ * See also
+ * <a href="http://en.wikipedia.org/wiki/Linear_multistep_method">en.wikipedia.org/wiki/Linear_multistep_method</a>.
+ * Currently, a maximum of Steps=8 is supported.
+ * The method is explicit and fulfills the Stepper concept. Step size control
+ * or continuous output are not provided.
+ * 
+ * This class derives from algebra_base and inherits its interface via
+ * CRTP (current recurring template pattern). For more details see
+ * algebra_stepper_base.
+ *
+ * \tparam Steps The number of steps (maximal 8).
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ * \tparam InitializingStepper The stepper for the first two steps.
+ */
+
+    /**
+     * \fn adams_bashforth_moulton::adams_bashforth_moulton( const algebra_type &algebra )
+     * \brief Constructs the adams_bashforth class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor. 
+     * \param algebra A copy of algebra is made and stored.
+     */
+
+    /**
+     * \fn adams_bashforth_moulton::order( void ) const
+     * \brief Returns the order of the algorithm, which is equal to the number of steps+1.
+     * \return order of the method.
+     */
+
+    /**
+     * \fn adams_bashforth_moulton::do_step( System system , StateInOut &x , time_type t , time_type dt )
+     * \brief This method performs one step. It transforms the result in-place.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+
+    /**
+     * \fn adams_bashforth_moulton::do_step( System system , const StateIn &in , time_type t , const StateOut &out , time_type dt )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn adams_bashforth_moulton::adjust_size( const StateType &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+    /**
+     * \fn adams_bashforth_moulton::initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt )
+     * \brief Initialized the stepper. Does Steps-1 steps with the explicit_stepper to fill the buffer.
+     * \note The state x and time t are updated to the values after Steps-1 initial steps.
+     * \param explicit_stepper the stepper used to fill the buffer of previous step results
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \param x The initial state of the ODE which should be solved, updated after in this method.
+     * \param t The initial time, updated in this method.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn adams_bashforth_moulton::initialize( System system , StateIn &x , time_type &t , time_type dt )
+     * \brief Initialized the stepper. Does Steps-1 steps using the standard initializing stepper 
+     * of the underlying adams_bashforth stepper.
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn adams_bashforth_moulton::reset( void )
+     * \brief Resets the internal buffers of the stepper.
+     */
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_BASHFORTH_MOULTON_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/adams_moulton.hpp b/include/boost/numeric/odeint/stepper/adams_moulton.hpp
new file mode 100644
index 0000000..05b4277
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/adams_moulton.hpp
@@ -0,0 +1,201 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/adams_moulton.hpp
+
+ [begin_description]
+ Implementation of the Adams-Moulton method. This is method is not a real stepper, it is more a helper class
+ which computes the corrector step in the Adams-Bashforth-Moulton method.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_MOULTON_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_MOULTON_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta4_classic.hpp>
+
+#include <boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp>
+#include <boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp>
+#include <boost/numeric/odeint/stepper/detail/rotating_buffer.hpp>
+
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * Static implicit Adams-Moulton multistep-solver without step size control and without dense output.
+ */
+template<
+size_t Steps ,
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+class adams_moulton
+{
+private:
+
+
+public :
+
+    typedef State state_type;
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef Time time_type;
+    typedef Algebra algebra_type;
+    typedef Operations operations_type;
+    typedef Resizer resizer_type;
+    typedef stepper_tag stepper_category;
+
+    typedef adams_moulton< Steps , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_type;
+
+    static const size_t steps = Steps;
+
+    typedef unsigned short order_type;
+    static const order_type order_value = steps + 1;
+
+    typedef detail::rotating_buffer< wrapped_deriv_type , steps > step_storage_type;
+
+    adams_moulton( )
+    : m_coefficients() , m_dxdt() , m_resizer() ,
+      m_algebra_instance() , m_algebra( m_algebra_instance )
+    { }
+
+    adams_moulton( algebra_type &algebra )
+    : m_coefficients() , m_dxdt() , m_resizer() ,
+      m_algebra_instance() , m_algebra( algebra )
+    { }
+
+    adams_moulton& operator=( const adams_moulton &stepper )
+    {
+        m_dxdt = stepper.m_dxdt;
+        m_resizer = stepper.m_resizer;
+        m_algebra = stepper.m_algebra;
+        return *this;
+    }
+
+    order_type order( void ) const { return order_value; }
+
+
+    /*
+     * Version 1 : do_step( system , x , t , dt , buf );
+     *
+     * solves the forwarding problem
+     */
+    template< class System , class StateInOut , class StateIn , class ABBuf >
+    void do_step( System system , StateInOut &x , StateIn const & pred , time_type t , time_type dt , const ABBuf &buf )
+    {
+        do_step( system , x , pred , t , x , dt , buf );
+    }
+
+    template< class System , class StateInOut , class StateIn , class ABBuf >
+    void do_step( System system , const StateInOut &x , StateIn const & pred , time_type t , time_type dt , const ABBuf &buf )
+    {
+        do_step( system , x , pred , t , x , dt , buf );
+    }
+
+
+
+    /*
+     * Version 2 : do_step( system , in , t , out , dt , buf );
+     *
+     * solves the forwarding problem
+     */
+    template< class System , class StateIn , class PredIn , class StateOut , class ABBuf >
+    void do_step( System system , const StateIn &in , const PredIn &pred , time_type t , StateOut &out , time_type dt , const ABBuf &buf )
+    {
+        do_step_impl( system , in , pred , t , out , dt , buf );
+    }
+
+    template< class System , class StateIn , class PredIn , class StateOut , class ABBuf >
+    void do_step( System system , const StateIn &in , const PredIn &pred , time_type t , const StateOut &out , time_type dt , const ABBuf &buf )
+    {
+        do_step_impl( system , in , pred , t , out , dt , buf );
+    }
+
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_impl( x );
+    }
+
+    algebra_type& algebra()
+    {   return m_algebra; }
+
+    const algebra_type& algebra() const
+    {   return m_algebra; }
+
+
+private:
+
+
+    template< class System , class StateIn , class PredIn , class StateOut , class ABBuf >
+    void do_step_impl( System system , const StateIn &in , const PredIn &pred , time_type t , StateOut &out , time_type dt , const ABBuf &buf )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
+        sys( pred , m_dxdt.m_v , t );
+        detail::adams_moulton_call_algebra< steps , algebra_type , operations_type >()( m_algebra , in , out , m_dxdt.m_v , buf , m_coefficients , dt );
+    }
+
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+    }
+
+
+    const detail::adams_moulton_coefficients< value_type , steps > m_coefficients;
+    wrapped_deriv_type m_dxdt;
+    resizer_type m_resizer;
+
+protected:
+
+    algebra_type m_algebra_instance;
+    algebra_type &m_algebra;
+};
+
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_MOULTON_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp b/include/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp
new file mode 100644
index 0000000..3b014f8
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp
@@ -0,0 +1,91 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp
+
+ [begin_description]
+ Base class for all steppers with an algebra and operations.
+ [end_description]
+
+ Copyright 2012-2013 Karsten Ahnert
+ Copyright 2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_ALGEBRA_STEPPER_BASE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_ALGEBRA_STEPPER_BASE_HPP_INCLUDED
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class Algebra , class Operations >
+class algebra_stepper_base
+{
+public:
+
+    typedef Algebra algebra_type;
+    typedef Operations operations_type;
+
+    algebra_stepper_base( const algebra_type &algebra = algebra_type() )
+    : m_algebra( algebra ) { }
+
+    algebra_type& algebra()
+    {
+        return m_algebra;
+    }
+
+    const algebra_type& algebra() const
+    {
+        return m_algebra;
+    }
+
+protected:
+
+    algebra_type m_algebra;
+};
+
+
+/******* DOXYGEN *******/
+
+/**
+ * \class algebra_stepper_base
+ * \brief Base class for all steppers with algebra and operations.
+ *
+ * This class serves a base class for all steppers with algebra and operations. It holds the
+ * algebra and provides access to the algebra.  The operations are not instantiated, since they are 
+ * static classes inside the operations class.
+ *
+ * \tparam Algebra The type of the algebra. Must fulfill the Algebra Concept, at least partially to work
+ * with the stepper.
+ * \tparam Operations The type of the operations. Must fulfill the Operations Concept, at least partially 
+ * to work with the stepper.
+ */
+
+    /**
+     * \fn algebra_stepper_base::algebra_stepper_base( const algebra_type &algebra = algebra_type() )
+     * \brief Constructs a algebra_stepper_base and creates the algebra. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra The algebra_stepper_base stores and uses a copy of algebra.
+     */
+
+    /**
+     * \fn algebra_type& algebra_stepper_base::algebra()
+     * \return A reference to the algebra which is held by this class.
+     */
+
+    /**
+     * \fn const algebra_type& algebra_stepper_base::algebra() const
+     * \return A const reference to the algebra which is held by this class.
+     */
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_ALGEBRA_STEPPER_BASE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp b/include/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
new file mode 100644
index 0000000..08009dc
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
@@ -0,0 +1,588 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
+
+ [begin_description]
+ Base class for all explicit Runge Kutta stepper which are also error steppers.
+ [end_description]
+
+ Copyright 2010-2013 Karsten Ahnert
+ Copyright 2010-2012 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * base class for explicit stepper and error steppers
+ * models the stepper AND the error stepper concept
+ *
+ * this class provides the following do_step variants:
+    * do_step( sys , x , t , dt )
+    * do_step( sys , x , dxdt , t , dt )
+    * do_step( sys , in , t , out , dt )
+    * do_step( sys , in , dxdt , t , out , dt )
+    * do_step( sys , x , t , dt , xerr )
+    * do_step( sys , x , dxdt , t , dt , xerr )
+    * do_step( sys , in , t , out , dt , xerr )
+    * do_step( sys , in , dxdt , t , out , dt , xerr )
+ */
+template<
+class Stepper ,
+unsigned short Order ,
+unsigned short StepperOrder ,
+unsigned short ErrorOrder ,
+class State ,
+class Value ,
+class Deriv ,
+class Time ,
+class Algebra ,
+class Operations ,
+class Resizer
+>
+class explicit_error_stepper_base : public algebra_stepper_base< Algebra , Operations >
+{
+public:
+
+    typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
+    typedef typename algebra_stepper_base_type::algebra_type algebra_type;
+
+
+    typedef State state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef Time time_type;
+    typedef Resizer resizer_type;
+    typedef Stepper stepper_type;
+    typedef explicit_error_stepper_tag stepper_category;
+    #ifndef DOXYGEN_SKIP
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef explicit_error_stepper_base< Stepper , Order , StepperOrder , ErrorOrder ,
+            State , Value , Deriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
+    #endif
+
+    typedef unsigned short order_type;
+    static const order_type order_value = Order;
+    static const order_type stepper_order_value = StepperOrder;
+    static const order_type error_order_value = ErrorOrder;
+
+
+    explicit_error_stepper_base( const algebra_type &algebra = algebra_type() )
+    : algebra_stepper_base_type( algebra )
+    { }
+
+    order_type order( void ) const
+    {
+        return order_value;
+    }
+
+    order_type stepper_order( void ) const
+    {
+        return stepper_order_value;
+    }
+
+    order_type error_order( void ) const
+    {
+        return error_order_value;
+    }
+
+
+
+    /*
+     * Version 1 : do_step( sys , x , t , dt )
+     *
+     * the two overloads are needed in order to solve the forwarding problem
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , StateInOut &x , time_type t , time_type dt )
+    {
+        do_step_v1( system , x , t , dt );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , const StateInOut &x , time_type t , time_type dt )
+    {
+        do_step_v1( system , x , t , dt );
+    }
+
+
+
+    /*
+     * Version 2 : do_step( sys , x , dxdt , t , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     *
+     * the disable is needed to avoid ambiguous overloads if state_type = time_type
+     */
+    template< class System , class StateInOut , class DerivIn >
+    typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
+    do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
+    {
+        this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
+    }
+
+
+    /*
+     * named Version 2: do_step_dxdt_impl( sys , in , dxdt , t , dt )
+     *
+     * this version is needed when this stepper is used for initializing 
+     * multistep stepper like adams-bashforth. Hence we provide an explicitely
+     * named version that is not disabled. Meant for internal use only.
+     */
+    template < class System, class StateInOut, class DerivIn >
+    void do_step_dxdt_impl( System system, StateInOut &x, const DerivIn &dxdt,
+                            time_type t, time_type dt )
+    {
+        this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
+    }
+
+
+
+    /*
+     * Version 3 : do_step( sys , in , t , out , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     *
+     * the disable is needed to avoid ambiguous overloads if state_type = time_type
+     */
+    template< class System , class StateIn , class StateOut >
+    typename boost::disable_if< boost::is_same< StateIn , time_type > , void >::type
+    do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_resizer.adjust_size( in , detail::bind( &internal_stepper_base_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
+        sys( in , m_dxdt.m_v ,t );
+        this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , dt );
+    }
+
+    /*
+     * Version 4 :do_step( sys , in , dxdt , t , out , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     *
+     * the disable is needed to avoid ambiguous overloads if state_type = time_type
+     */
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
+    do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+    {
+        this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
+    }
+    
+    /*
+     * named Version 4: do_step_dxdt_impl( sys , in , dxdt , t , out, dt )
+     *
+     * this version is needed when this stepper is used for initializing 
+     * multistep stepper like adams-bashforth. Hence we provide an explicitely
+     * named version that is not disabled. Meant for internal use only.
+     */
+    template < class System, class StateIn, class DerivIn, class StateOut >
+    void do_step_dxdt_impl( System system, const StateIn &in,
+                            const DerivIn &dxdt, time_type t, StateOut &out,
+                            time_type dt )
+    {
+        this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
+    }
+
+    /*
+     * Version  5 :do_step( sys , x , t , dt , xerr )
+     *
+     * the two overloads are needed in order to solve the forwarding problem
+     */
+    template< class System , class StateInOut , class Err >
+    void do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
+    {
+        do_step_v5( system , x , t , dt , xerr );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
+     */
+    template< class System , class StateInOut , class Err >
+    void do_step( System system , const StateInOut &x , time_type t , time_type dt , Err &xerr )
+    {
+        do_step_v5( system , x , t , dt , xerr );
+    }
+
+
+    /*
+     * Version 6 :do_step( sys , x , dxdt , t , dt , xerr )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     *
+     * the disable is needed to avoid ambiguous overloads if state_type = time_type
+     */
+    template< class System , class StateInOut , class DerivIn , class Err >
+    typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
+    do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt , Err &xerr )
+    {
+        this->stepper().do_step_impl( system , x , dxdt , t , x , dt , xerr );
+    }
+
+
+    /*
+     * Version 7 : do_step( sys , in , t , out , dt , xerr )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    template< class System , class StateIn , class StateOut , class Err >
+    void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_resizer.adjust_size( in , detail::bind( &internal_stepper_base_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
+        sys( in , m_dxdt.m_v ,t );
+        this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , dt , xerr );
+    }
+
+
+    /*
+     * Version 8 : do_step( sys , in , dxdt , t , out , dt , xerr )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    template< class System , class StateIn , class DerivIn , class StateOut , class Err >
+    void do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
+    {
+        this->stepper().do_step_impl( system , in , dxdt , t , out , dt , xerr );
+    }
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_impl( x );
+    }
+
+
+
+private:
+
+    template< class System , class StateInOut >
+    void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl<StateInOut> , detail::ref( *this ) , detail::_1 ) );
+        sys( x , m_dxdt.m_v , t );
+        this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt );
+    }
+
+    template< class System , class StateInOut , class Err >
+    void do_step_v5( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl<StateInOut> , detail::ref( *this ) , detail::_1 ) );
+        sys( x , m_dxdt.m_v ,t );
+        this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt , xerr );
+    }
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+    }
+
+    stepper_type& stepper( void )
+    {
+        return *static_cast< stepper_type* >( this );
+    }
+
+    const stepper_type& stepper( void ) const
+    {
+        return *static_cast< const stepper_type* >( this );
+    }
+
+
+    resizer_type m_resizer;
+
+protected:
+
+    wrapped_deriv_type m_dxdt;
+};
+
+
+
+
+/******** DOXYGEN *******/
+
+/**
+ * \class explicit_error_stepper_base
+ * \brief Base class for explicit steppers with error estimation. This class can used with 
+ * controlled steppers for step size control.
+ *
+ * This class serves as the base class for all explicit steppers with algebra and operations. In contrast to
+ * explicit_stepper_base it also estimates the error and can be used in a controlled stepper to provide
+ * step size control.
+ *
+ * \note This stepper provides `do_step` methods with and without error estimation. It has therefore three orders,
+ * one for the order of a step if the error is not estimated. The other two orders are the orders of the step and 
+ * the error step if the error estimation is performed.
+ *
+ * explicit_error_stepper_base  is used as the interface in a CRTP (currently recurring template
+ * pattern). In order to work correctly the parent class needs to have a method
+ * `do_step_impl( system , in , dxdt_in , t , out , dt , xerr )`. 
+ * explicit_error_stepper_base derives from algebra_stepper_base.
+ *
+ * explicit_error_stepper_base provides several overloaded `do_step` methods, see the list below. Only two of them
+ * are needed to fulfill the Error Stepper concept. The other ones are for convenience and for performance. Some
+ * of them simply update the state out-of-place, while other expect that the first derivative at `t` is passed to the
+ * stepper.
+ *
+ * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Error Stepper concept. The
+ *      state is updated in-place. A type modelling a Boost.Range can be used for x.
+ * - `do_step( sys , x , dxdt , t , dt )` - This method updates the state in-place, but the derivative at the point `t`
+ *      must be explicitly passed in `dxdt`.
+ * - `do_step( sys , in , t , out , dt )` - This method updates the state out-of-place, hence the result of the step
+ *      is stored in `out`.
+ * - `do_step( sys , in , dxdt , t , out , dt )` - This method update the state out-of-place and expects that the
+ *     derivative at the point `t` is explicitly passed in `dxdt`. It is a combination of the two `do_step` methods
+ *     above.
+ * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fulfill the Error Stepper concept. The
+ *     state is updated in-place and an error estimate is calculated. A type modelling a Boost.Range can be used for x.
+ * - `do_step( sys , x , dxdt , t , dt , xerr )` - This method updates the state in-place, but the derivative at the
+ *      point `t` must be passed in `dxdt`. An error estimate is calculated.
+ * - `do_step( sys , in , t , out , dt , xerr )` - This method updates the state out-of-place and estimates the error
+ *      during the step.
+ * - `do_step( sys , in , dxdt , t , out , dt , xerr )` - This methods updates the state out-of-place and estimates
+ *      the error during the step. Furthermore, the derivative at `t` must be passed in `dxdt`.
+ *
+ * \note The system is always passed as value, which might result in poor performance if it contains data. In this
+ *      case it can be used with `boost::ref` or `std::ref`, for example `stepper.do_step( boost::ref( sys ) , x , t , dt );`
+ *
+ * \note The time `t` is not advanced by the stepper. This has to done manually, or by the appropriate `integrate`
+ *      routines or `iterator`s.
+ *
+ * \tparam Stepper The stepper on which this class should work. It is used via CRTP, hence explicit_stepper_base
+ * provides the interface for the Stepper.
+ * \tparam Order The order of a stepper if the stepper is used without error estimation.
+ * \tparam StepperOrder The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have 
+ * the same value.
+ * \tparam ErrorOrder The order of the error step if the stepper is used with error estimation.
+ * \tparam State The state type for the stepper.
+ * \tparam Value The value type for the stepper. This should be a floating point type, like float,
+ * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
+ * the State can be a `vector< complex< double > >` in this case the Value must be double.
+ * The default value is double.
+ * \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
+ * state type, only if used with Boost.Units both types differ.
+ * \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
+ * used, this type has usually a unit.
+ * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
+ * \tparam Operations The type for the operations which must fulfill the Operations Concept.
+ * \tparam Resizer The resizer policy class.
+ */
+
+
+    /**
+     * \fn explicit_error_stepper_base::explicit_error_stepper_base( const algebra_type &algebra = algebra_type() )
+     *
+     * \brief Constructs a explicit_error_stepper_base class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+    /**
+     * \fn explicit_error_stepper_base::order( void ) const
+     * \return Returns the order of the stepper if it used without error estimation.
+     */
+
+    /**
+     * \fn explicit_error_stepper_base::stepper_order( void ) const
+     * \return Returns the order of a step if the stepper is used without error estimation.
+     */
+
+    /**
+     * \fn explicit_error_stepper_base::error_order( void ) const
+     * \return Returns the order of an error step if the stepper is used without error estimation.
+     */
+
+    /**
+     * \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
+     * \brief This method performs one step. It transforms the result in-place.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
+     * \brief The method performs one step with the stepper passed by Stepper. Additionally to the other method
+     * the derivative of x is also passed to this method. It is supposed to be used in the following way:
+     *
+     * \code
+     * sys( x , dxdt , t );
+     * stepper.do_step( sys , x , dxdt , t , dt );
+     * \endcode
+     *
+     * The result is updated in place in x. This method is disabled if Time and Deriv are of the same type. In this
+     * case the method could not be distinguished from other `do_step` versions.
+     * 
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     * This method is disabled if StateIn and Time are the same type. In this case the method can not be distinguished from
+     * other `do_step` variants.
+     * \note This method does not solve the forwarding problem. 
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+
+    /**
+     * \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     * Furthermore, the derivative of x at t is passed to the stepper. It is supposed to be used in the following way:
+     *
+     * \code
+     * sys( in , dxdt , t );
+     * stepper.do_step( sys , in , dxdt , t , out , dt );
+     * \endcode
+     *
+     * This method is disabled if DerivIn and Time are of same type.
+     *
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
+     * \brief The method performs one step with the stepper passed by Stepper and estimates the error. The state of the ODE
+     * is updated in-place.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. x is updated by this method.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     * \param xerr The estimation of the error is stored in xerr.
+     */
+
+    /**
+     * \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt , Err &xerr )
+     * \brief The method performs one step with the stepper passed by Stepper. Additionally to the other method
+     * the derivative of x is also passed to this method. It is supposed to be used in the following way:
+     *
+     * \code
+     * sys( x , dxdt , t );
+     * stepper.do_step( sys , x , dxdt , t , dt , xerr );
+     * \endcode
+     *
+     * The result is updated in place in x. This method is disabled if Time and DerivIn are of the same type. In this
+     * case the method could not be distinguished from other `do_step` versions.
+     * 
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     * \param xerr The error estimate is stored in xerr.
+     */
+
+    /**
+     * \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     * Furthermore, the error is estimated.
+     *
+     * \note This method does not solve the forwarding problem. 
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     * \param xerr The error estimate.
+     */
+
+
+    /**
+     * \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     * Furthermore, the derivative of x at t is passed to the stepper and the error is estimated. It is supposed to be used in the following way:
+     *
+     * \code
+     * sys( in , dxdt , t );
+     * stepper.do_step( sys , in , dxdt , t , out , dt );
+     * \endcode
+     *
+     * This method is disabled if DerivIn and Time are of same type.
+     *
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     * \param xerr The error estimate.
+     */
+
+
+    /**
+     * \fn explicit_error_stepper_base::adjust_size( const StateIn &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+} // odeint
+} // numeric
+} // boost
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp b/include/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp
new file mode 100644
index 0000000..b1d751a
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp
@@ -0,0 +1,677 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp
+
+ [begin_description]
+ Base class for all explicit first-same-as-last Runge Kutta steppers.
+ [end_description]
+
+ Copyright 2010-2013 Karsten Ahnert
+ Copyright 2010-2012 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_FSAL_BASE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_FSAL_BASE_HPP_INCLUDED
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/*
+ * base class for explicit stepper and error steppers with the fsal property
+ * models the stepper AND the error stepper fsal concept
+ * 
+ * this class provides the following do_step overloads
+    * do_step( sys , x , t , dt )
+    * do_step( sys , x , dxdt , t , dt )
+    * do_step( sys , in , t , out , dt )
+    * do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )
+    * do_step( sys , x , t , dt , xerr )
+    * do_step( sys , x , dxdt , t , dt , xerr )
+    * do_step( sys , in , t , out , dt , xerr )
+    * do_step( sys , in , dxdt_in , t , out , dxdt_out , dt , xerr )
+ */
+template<
+class Stepper ,
+unsigned short Order ,
+unsigned short StepperOrder ,
+unsigned short ErrorOrder ,
+class State ,
+class Value ,
+class Deriv ,
+class Time ,
+class Algebra ,
+class Operations ,
+class Resizer
+>
+class explicit_error_stepper_fsal_base : public algebra_stepper_base< Algebra , Operations >
+{
+public:
+
+    typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
+    typedef typename algebra_stepper_base_type::algebra_type algebra_type;
+
+    typedef State state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef Time time_type;
+    typedef Resizer resizer_type;
+    typedef Stepper stepper_type;
+    typedef explicit_error_stepper_fsal_tag stepper_category;
+
+    #ifndef DOXYGEN_SKIP
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef explicit_error_stepper_fsal_base< Stepper , Order , StepperOrder , ErrorOrder ,
+            State , Value , Deriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
+    #endif 
+
+
+    typedef unsigned short order_type;
+    static const order_type order_value = Order;
+    static const order_type stepper_order_value = StepperOrder;
+    static const order_type error_order_value = ErrorOrder;
+
+    explicit_error_stepper_fsal_base( const algebra_type &algebra = algebra_type() )
+    : algebra_stepper_base_type( algebra ) , m_first_call( true )
+    { }
+
+    order_type order( void ) const
+    {
+        return order_value;
+    }
+
+    order_type stepper_order( void ) const
+    {
+        return stepper_order_value;
+    }
+
+    order_type error_order( void ) const
+    {
+        return error_order_value;
+    }
+
+
+    /*
+     * version 1 : do_step( sys , x , t , dt )
+     *
+     * the two overloads are needed in order to solve the forwarding problem
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , StateInOut &x , time_type t , time_type dt )
+    {
+        do_step_v1( system , x , t , dt );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , const StateInOut &x , time_type t , time_type dt )
+    {
+        do_step_v1( system , x , t , dt );
+    }
+
+
+    /*
+     * version 2 : do_step( sys , x , dxdt , t , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     *
+     * the disable is needed to avoid ambiguous overloads if state_type = time_type
+     */
+    template< class System , class StateInOut , class DerivInOut >
+    typename boost::disable_if< boost::is_same< StateInOut , time_type > , void >::type
+    do_step( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt )
+    {
+        m_first_call = true;
+        this->stepper().do_step_impl( system , x , dxdt , t , x , dxdt , dt );
+    }
+
+
+    /*
+     * named Version 2: do_step_dxdt_impl( sys , in , dxdt , t , dt )
+     *
+     * this version is needed when this stepper is used for initializing 
+     * multistep stepper like adams-bashforth. Hence we provide an explicitely
+     * named version that is not disabled. Meant for internal use only.
+     */
+    template< class System , class StateInOut , class DerivInOut >
+    void do_step_dxdt_impl( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt )
+    {
+        m_first_call = true;
+        this->stepper().do_step_impl( system , x , dxdt , t , x , dxdt , dt );
+    }
+
+    /*
+     * version 3 : do_step( sys , in , t , out , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not
+     * be used.
+     *
+     * the disable is needed to avoid ambiguous overloads if 
+     * state_type = time_type
+     */
+    template< class System , class StateIn , class StateOut >
+    typename boost::disable_if< boost::is_same< StateIn , time_type > , void >::type
+    do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+    {
+        if( m_resizer.adjust_size( in , detail::bind( &internal_stepper_base_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ) || m_first_call )
+        {
+            initialize( system , in , t );
+        }
+        this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , m_dxdt.m_v , dt );
+    }
+
+
+    /*
+     * version 4 : do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    template< class System, class StateIn, class DerivIn, class StateOut,
+               class DerivOut >
+    void do_step( System system, const StateIn &in, const DerivIn &dxdt_in,
+                  time_type t, StateOut &out, DerivOut &dxdt_out, time_type dt )
+    {
+        m_first_call = true;
+        this->stepper().do_step_impl( system, in, dxdt_in, t, out, dxdt_out,
+                                      dt );
+    }
+
+
+
+
+
+    /*
+     * version 5 : do_step( sys , x , t , dt , xerr )
+     *
+     * the two overloads are needed in order to solve the forwarding problem
+     */
+    template< class System , class StateInOut , class Err >
+    void do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
+    {
+        do_step_v5( system , x , t , dt , xerr );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
+     */
+    template< class System , class StateInOut , class Err >
+    void do_step( System system , const StateInOut &x , time_type t , time_type dt , Err &xerr )
+    {
+        do_step_v5( system , x , t , dt , xerr );
+    }
+
+
+    /*
+     * version 6 : do_step( sys , x , dxdt , t , dt , xerr )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     *
+     * the disable is needed to avoid ambiguous overloads if state_type = time_type
+     */
+    template< class System , class StateInOut , class DerivInOut , class Err >
+    typename boost::disable_if< boost::is_same< StateInOut , time_type > , void >::type
+    do_step( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt , Err &xerr )
+    {
+        m_first_call = true;
+        this->stepper().do_step_impl( system , x , dxdt , t , x , dxdt , dt , xerr );
+    }
+
+
+
+
+    /*
+     * version 7 : do_step( sys , in , t , out , dt , xerr )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    template< class System , class StateIn , class StateOut , class Err >
+    void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
+    {
+        if( m_resizer.adjust_size( in , detail::bind( &internal_stepper_base_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ) || m_first_call )
+        {
+            initialize( system , in , t );
+        }
+        this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , m_dxdt.m_v , dt , xerr );
+    }
+
+
+    /*
+     * version 8 : do_step( sys , in , dxdt_in , t , out , dxdt_out , dt , xerr )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut , class Err >
+    void do_step( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t ,
+            StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr )
+    {
+        m_first_call = true;
+        this->stepper().do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt , xerr );
+    }
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_impl( x );
+    }
+
+    void reset( void )
+    {
+        m_first_call = true;
+    }
+
+    template< class DerivIn >
+    void initialize( const DerivIn &deriv )
+    {
+        boost::numeric::odeint::copy( deriv , m_dxdt.m_v );
+        m_first_call = false;
+    }
+
+    template< class System , class StateIn >
+    void initialize( System system , const StateIn &x , time_type t )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        sys( x , m_dxdt.m_v , t );
+        m_first_call = false;
+    }
+
+    bool is_initialized( void ) const
+    {
+        return ! m_first_call;
+    }
+
+
+
+private:
+
+    template< class System , class StateInOut >
+    void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
+    {
+        if( m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ) || m_first_call )
+        {
+            initialize( system , x , t );
+        }
+        this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , m_dxdt.m_v , dt );
+    }
+
+    template< class System , class StateInOut , class Err >
+    void do_step_v5( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
+    {
+        if( m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ) || m_first_call )
+        {
+            initialize( system , x , t );
+        }
+        this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , m_dxdt.m_v , dt , xerr );
+    }
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+    }
+
+
+    stepper_type& stepper( void )
+    {
+        return *static_cast< stepper_type* >( this );
+    }
+
+    const stepper_type& stepper( void ) const
+    {
+        return *static_cast< const stepper_type* >( this );
+    }
+
+
+    resizer_type m_resizer;
+    bool m_first_call;
+
+protected:
+
+
+    wrapped_deriv_type m_dxdt;
+};
+
+
+/******* DOXYGEN *******/
+
+/**
+ * \class explicit_error_stepper_fsal_base
+ * \brief Base class for explicit steppers with error estimation and stepper fulfilling the FSAL (first-same-as-last)
+ * property. This class can be used with controlled steppers for step size control.
+ *
+ * This class serves as the base class for all explicit steppers with algebra and operations and which fulfill the FSAL
+ * property. In contrast to explicit_stepper_base it also estimates the error and can be used in a controlled stepper
+ * to provide step size control.
+ *
+ * The FSAL property means that the derivative of the system at t+dt is already used in the current step going from
+ * t to t +dt. Therefore, some more do_steps method can be introduced and the controlled steppers can explicitly make use
+ * of this property.
+ *
+ * \note This stepper provides `do_step` methods with and without error estimation. It has therefore three orders,
+ * one for the order of a step if the error is not estimated. The other two orders are the orders of the step and 
+ * the error step if the error estimation is performed.
+ *
+ * explicit_error_stepper_fsal_base  is used as the interface in a CRTP (currently recurring template
+ * pattern). In order to work correctly the parent class needs to have a method
+ * `do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt , xerr )`. 
+ * explicit_error_stepper_fsal_base derives from algebra_stepper_base.
+ *
+ * This class can have an intrinsic state depending on the explicit usage of the `do_step` method. This means that some
+ * `do_step` methods are expected to be called in order. For example the `do_step( sys , x , t , dt , xerr )` will keep track 
+ * of the derivative of `x` which is the internal state. The first call of this method is recognized such that one
+ * does not explicitly initialize the internal state, so it is safe to use this method like
+ *
+ * \code
+ * stepper_type stepper;
+ * stepper.do_step( sys , x , t , dt , xerr );
+ * stepper.do_step( sys , x , t , dt , xerr );
+ * stepper.do_step( sys , x , t , dt , xerr );
+ * \endcode
+ *
+ * But it is unsafe to call this method with different system functions after each other. Do do so, one must initialize the
+ * internal state with the `initialize` method or reset the internal state with the `reset` method.
+ *
+ * explicit_error_stepper_fsal_base provides several overloaded `do_step` methods, see the list below. Only two of them are needed
+ * to fulfill the Error Stepper concept. The other ones are for convenience and for better performance. Some of them
+ * simply update the state out-of-place, while other expect that the first derivative at `t` is passed to the stepper.
+ *
+ * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Error Stepper concept. The
+ *      state is updated in-place. A type modelling a Boost.Range can be used for x.
+ * - `do_step( sys , x , dxdt , t , dt )` - This method updates the state x and the derivative dxdt in-place. It is expected
+ *     that dxdt has the value of the derivative of x at time t.
+ * - `do_step( sys , in , t , out , dt )` - This method updates the state out-of-place, hence the result of the step
+ *      is stored in `out`.
+ * - `do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )` - This method updates the state and the derivative
+ *     out-of-place. It expects that the derivative at the point `t` is explicitly passed in `dxdt_in`.
+ * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fulfill the Error Stepper concept. The
+ *     state is updated in-place and an error estimate is calculated. A type modelling a Boost.Range can be used for x.
+ * - `do_step( sys , x , dxdt , t , dt , xerr )` - This method updates the state and the derivative in-place. It is assumed
+ *      that the dxdt has the value of the derivative of x at time t. An error estimate is calculated.
+ * - `do_step( sys , in , t , out , dt , xerr )` - This method updates the state out-of-place and estimates the error
+ *      during the step.
+ * - `do_step( sys , in , dxdt_in , t , out , dxdt_out , dt , xerr )` - This methods updates the state and the derivative
+ *      out-of-place and estimates the error during the step. It is assumed the dxdt_in is derivative of in at time t.
+ *
+ * \note The system is always passed as value, which might result in poor performance if it contains data. In this
+ *      case it can be used with `boost::ref` or `std::ref`, for example `stepper.do_step( boost::ref( sys ) , x , t , dt );`
+ *
+ * \note The time `t` is not advanced by the stepper. This has to done manually, or by the appropriate `integrate`
+ *      routines or `iterator`s.
+ *
+ * \tparam Stepper The stepper on which this class should work. It is used via CRTP, hence explicit_stepper_base
+ * provides the interface for the Stepper.
+ * \tparam Order The order of a stepper if the stepper is used without error estimation.
+ * \tparam StepperOrder The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have 
+ * the same value.
+ * \tparam ErrorOrder The order of the error step if the stepper is used with error estimation.
+ * \tparam State The state type for the stepper.
+ * \tparam Value The value type for the stepper. This should be a floating point type, like float,
+ * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
+ * the State can be a `vector< complex< double > >` in this case the Value must be double.
+ * The default value is double.
+ * \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
+ * state type, only if used with Boost.Units both types differ.
+ * \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
+ * used, this type has usually a unit.
+ * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
+ * \tparam Operations The type for the operations which must fulfill the Operations Concept.
+ * \tparam Resizer The resizer policy class.
+ */
+
+
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::explicit_error_stepper_fsal_base( const algebra_type &algebra )
+     * \brief Constructs a explicit_stepper_fsal_base class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::order( void ) const
+     * \return Returns the order of the stepper if it used without error estimation.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::stepper_order( void ) const
+     * \return Returns the order of a step if the stepper is used without error estimation.
+     */
+
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::error_order( void ) const
+     * \return Returns the order of an error step if the stepper is used without error estimation.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
+     * \brief This method performs one step. It transforms the result in-place.
+     *
+     * \note This method uses the internal state of the stepper.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::do_step( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt )
+     * \brief The method performs one step with the stepper passed by Stepper. Additionally to the other methods
+     * the derivative of x is also passed to this method. Therefore, dxdt must be evaluated initially:
+     *
+     * \code
+     * ode( x , dxdt , t );
+     * for( ... )
+     * {
+     *     stepper.do_step( ode , x , dxdt , t , dt );
+     *     t += dt;
+     * }
+     * \endcode
+     *
+     * \note This method does NOT use the initial state, since the first derivative is explicitly passed to this method.
+     *
+     * The result is updated in place in x as well as the derivative dxdt. This method is disabled if
+     * Time and StateInOut are of the same type. In this case the method could not be distinguished from other `do_step`
+     * versions.
+     * 
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param dxdt The derivative of x at t. After calling `do_step` dxdt is updated to the new value.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     * This method is disabled if StateIn and Time are the same type. In this case the method can not be distinguished from
+     * other `do_step` variants.
+     *
+     * \note This method uses the internal state of the stepper.
+     *
+     * \note This method does not solve the forwarding problem. 
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::do_step( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     * Furthermore, the derivative of x at t is passed to the stepper and updated by the stepper to its new value at
+     * t+dt.
+     *
+     * \note This method does not solve the forwarding problem.
+     *
+     * \note This method does NOT use the internal state of the stepper.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt_in The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dxdt_out The updated derivative of `out` at `t+dt`.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
+     * \brief The method performs one step with the stepper passed by Stepper and estimates the error. The state of the ODE
+     * is updated in-place.
+     *
+     *
+     * \note This method uses the internal state of the stepper.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. x is updated by this method.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     * \param xerr The estimation of the error is stored in xerr.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::do_step( System system , StateInOut &x , DerivInOut &dxdt , time_type t , time_type dt , Err &xerr )
+     * \brief The method performs one step with the stepper passed by Stepper. Additionally to the other method
+     * the derivative of x is also passed to this method and updated by this method.
+     *
+     * \note This method does NOT use the internal state of the stepper.
+     *
+     * The result is updated in place in x. This method is disabled if Time and Deriv are of the same type. In this
+     * case the method could not be distinguished from other `do_step` versions. This method is disabled if StateInOut and
+     * Time are of the same type.
+     *
+     * \note This method does NOT use the internal state of the stepper.
+     * 
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param dxdt The derivative of x at t. After calling `do_step` this value is updated to the new value at `t+dt`.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     * \param xerr The error estimate is stored in xerr.
+     */
+
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     * Furthermore, the error is estimated.
+     *
+     * \note This method uses the internal state of the stepper.
+     *
+     * \note This method does not solve the forwarding problem. 
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     * \param xerr The error estimate.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::do_step( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr )
+     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
+     * Furthermore, the derivative of x at t is passed to the stepper and the error is estimated.
+     *
+     * \note This method does NOT use the internal state of the stepper.
+     *
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt_in The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dxdt_out The new derivative at `t+dt` is written into this variable.
+     * \param dt The step size.
+     * \param xerr The error estimate.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::adjust_size( const StateIn &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::reset( void )
+     * \brief Resets the internal state of this stepper. After calling this method it is safe to use all
+     * `do_step` method without explicitly initializing the stepper.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::initialize( const DerivIn &deriv )
+     * \brief Initializes the internal state of the stepper.
+     * \param deriv The derivative of x. The next call of `do_step` expects that the derivative of `x` passed to `do_step`
+     *              has the value of `deriv`.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::initialize( System system , const StateIn &x , time_type t )
+     * \brief Initializes the internal state of the stepper.
+     *
+     * This method is equivalent to 
+     * \code
+     * Deriv dxdt;
+     * system( x , dxdt , t );
+     * stepper.initialize( dxdt );
+     * \endcode
+     *
+     * \param system The system function for the next calls of `do_step`.
+     * \param x The current state of the ODE.
+     * \param t The current time of the ODE.
+     */
+
+    /**
+     * \fn explicit_error_stepper_fsal_base::is_initialized( void ) const
+     * \brief Returns if the stepper is already initialized. If the stepper is not initialized, the first 
+     * call of `do_step` will initialize the state of the stepper. If the stepper is already initialized
+     * the system function can not be safely exchanged between consecutive `do_step` calls.
+     */
+
+} // odeint
+} // numeric
+} // boost
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_FSAL_BASE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp b/include/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
new file mode 100644
index 0000000..d81c8c7
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
@@ -0,0 +1,415 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
+
+ [begin_description]
+ Base class for all explicit Runge Kutta steppers.
+ [end_description]
+
+ Copyright 2010-2013 Karsten Ahnert
+ Copyright 2010-2012 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_STEPPER_BASE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_STEPPER_BASE_HPP_INCLUDED
+
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/*
+ * base class for explicit steppers
+ * models the stepper concept
+ *
+ * this class provides the following overloads
+    * do_step( sys , x , t , dt )
+    * do_step( sys , in , t , out , dt )
+    * do_step( sys , x , dxdt_in , t , dt )
+    * do_step( sys , in , dxdt_in , t , out , dt )
+ */
+
+template<
+class Stepper ,
+unsigned short Order ,
+class State ,
+class Value ,
+class Deriv ,
+class Time ,
+class Algebra ,
+class Operations ,
+class Resizer
+>
+class explicit_stepper_base : public algebra_stepper_base< Algebra , Operations >
+{
+public:
+
+    #ifndef DOXYGEN_SKIP
+    typedef explicit_stepper_base< Stepper , Order , State , Value , Deriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
+    #endif // DOXYGEN_SKIP
+
+
+    typedef State state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef Time time_type;
+    typedef Resizer resizer_type;
+    typedef Stepper stepper_type;
+    typedef stepper_tag stepper_category;
+    typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
+    typedef typename algebra_stepper_base_type::algebra_type algebra_type;
+    typedef typename algebra_stepper_base_type::operations_type operations_type;
+    typedef unsigned short order_type;
+
+    #ifndef DOXYGEN_SKIP
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    #endif // DOXYGEN_SKIP
+
+
+    static const order_type order_value = Order;
+
+
+    explicit_stepper_base( const algebra_type &algebra = algebra_type() )
+    : algebra_stepper_base_type( algebra )
+    { }
+
+    /**
+     * \return Returns the order of the stepper.
+     */
+    order_type order( void ) const
+    {
+        return order_value;
+    }
+
+
+    /*
+     * Version 1 : do_step( sys , x , t , dt )
+     *
+     * the two overloads are needed in order to solve the forwarding problem
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , StateInOut &x , time_type t , time_type dt )
+    {
+        do_step_v1( system , x , t , dt );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , const StateInOut &x , time_type t , time_type dt )
+    {
+        do_step_v1( system , x , t , dt );
+    }
+
+    /*
+     * Version 2 : do_step( sys , x , dxdt , t , dt )
+     *
+      * this version does not solve the forwarding problem, boost.range can not be used
+     *
+     * the disable is needed to avoid ambiguous overloads if state_type = time_type
+     */
+    template< class System , class StateInOut , class DerivIn >
+    typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
+    do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
+    {
+        this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
+    }
+
+
+    /*
+     * named Version 2: do_step_dxdt_impl( sys , in , dxdt , t , dt )
+     *
+     * this version is needed when this stepper is used for initializing 
+     * multistep stepper like adams-bashforth. Hence we provide an explicitely
+     * named version that is not disabled. Meant for internal use only.
+     */
+    template < class System, class StateInOut, class DerivIn >
+    void do_step_dxdt_impl( System system, StateInOut &x, const DerivIn &dxdt,
+                            time_type t, time_type dt )
+    {
+        this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
+    }
+
+
+    /*
+     * Version 3 : do_step( sys , in , t , out , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    template< class System , class StateIn , class StateOut >
+    void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_resizer.adjust_size( in , detail::bind( &internal_stepper_base_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
+        sys( in , m_dxdt.m_v ,t );
+        this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , dt );
+    }
+
+
+    /*
+     * Version 4 : do_step( sys , in , dxdt , t , out , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    void do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+    {
+        this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
+    }
+
+
+    /*
+     * named Version 4: do_step_dxdt_impl( sys , in , dxdt , t , out, dt )
+     *
+     * this version is needed when this stepper is used for initializing 
+     * multistep stepper like adams-bashforth. Hence we provide an explicitely
+     * named version. Meant for internal use only.
+     */
+    template < class System, class StateIn, class DerivIn, class StateOut >
+    void do_step_dxdt_impl( System system, const StateIn &in,
+                            const DerivIn &dxdt, time_type t, StateOut &out,
+                            time_type dt )
+    {
+        this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
+    }
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_impl( x );
+    }
+
+private:
+
+    stepper_type& stepper( void )
+    {
+        return *static_cast< stepper_type* >( this );
+    }
+
+    const stepper_type& stepper( void ) const
+    {
+        return *static_cast< const stepper_type* >( this );
+    }
+
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+    }
+
+
+    template< class System , class StateInOut >
+    void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
+        sys( x , m_dxdt.m_v ,t );
+        this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt );
+    }
+
+
+    resizer_type m_resizer;
+
+protected:
+
+    wrapped_deriv_type m_dxdt;
+};
+
+
+/******* DOXYGEN *********/
+
+/**
+ * \class explicit_stepper_base
+ * \brief Base class for explicit steppers without step size control and without dense output.
+ *
+ * This class serves as the base class for all explicit steppers with algebra and operations.
+ * Step size control and error estimation as well as dense output are not provided. explicit_stepper_base 
+ * is used as the interface in a CRTP (currently recurring template pattern). In order to work 
+ * correctly the parent class needs to have a method `do_step_impl( system , in , dxdt_in , t , out , dt )`. 
+ * This is method is used by explicit_stepper_base. explicit_stepper_base derives from
+ * algebra_stepper_base. An example how this class can be used is
+ *
+ * \code
+ * template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resizer >
+ * class custom_euler : public explicit_stepper_base< 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
+ * {
+ *  public:
+ *     
+ *     typedef explicit_stepper_base< 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer > base_type;
+ *
+ *     custom_euler( const Algebra &algebra = Algebra() ) { }
+ * 
+ *     template< class Sys , class StateIn , class DerivIn , class StateOut >
+ *     void do_step_impl( Sys sys , const StateIn &in , const DerivIn &dxdt , Time t , StateOut &out , Time dt )
+ *     {
+ *         m_algebra.for_each3( out , in , dxdt , Operations::scale_sum2< Value , Time >( 1.0 , dt );
+ *     }
+ *
+ *     template< class State >
+ *     void adjust_size( const State &x )
+ *     {
+ *         base_type::adjust_size( x );
+ *     }
+ * };
+ * \endcode
+ *
+ * For the Stepper concept only the `do_step( sys , x , t , dt )` needs to be implemented. But this class
+ * provides additional `do_step` variants since the stepper is explicit. These methods can be used to increase
+ * the performance in some situation, for example if one needs to analyze `dxdt` during each step. In this case 
+ * one can use 
+ *
+ * \code
+ * sys( x , dxdt , t );
+ * stepper.do_step( sys , x , dxdt , t , dt );  // the value of dxdt is used here
+ * t += dt;
+ * \endcode
+ *
+ * In detail explicit_stepper_base provides the following `do_step` variants
+ *   - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Stepper concept. The state is updated in-place.
+ *      A type modelling a Boost.Range can be used for x.
+ *   - `do_step( sys , in , t , out , dt )` - This method updates the state out-of-place, hence the result of the step is stored in `out`.
+ *   - `do_step( sys , x , dxdt , t , dt )` - This method updates the state in-place, but the derivative at the point `t` must be
+ *      explicitly passed in `dxdt`. For an example see the code snippet above.
+ *   - `do_step( sys , in , dxdt , t , out , dt )` - This method update the state out-of-place and expects that the derivative at the point 
+ *     `t` is explicitly passed in `dxdt`. It is a combination of the two `do_step` methods above.
+ *
+ * \note The system is always passed as value, which might result in poor performance if it contains data. In this case it can be used with `boost::ref`
+ * or `std::ref`, for example `stepper.do_step( boost::ref( sys ) , x , t , dt );`
+ *
+ * \note The time `t` is not advanced by the stepper. This has to done manually, or by the appropriate `integrate` routines or `iterator`s.
+ *
+ * \tparam Stepper The stepper on which this class should work. It is used via CRTP, hence explicit_stepper_base
+ * provides the interface for the Stepper.
+ * \tparam Order The order of the stepper.
+ * \tparam State The state type for the stepper.
+ * \tparam Value The value type for the stepper. This should be a floating point type, like float,
+ * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
+ * the State can be a `vector< complex< double > >` in this case the Value must be double.
+ * The default value is double.
+ * \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
+ * state type, only if used with Boost.Units both types differ.
+ * \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
+ * used, this type has usually a unit.
+ * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
+ * \tparam Operations The type for the operations which must fulfill the Operations Concept.
+ * \tparam Resizer The resizer policy class.
+ */
+
+
+    /**
+     * \fn explicit_stepper_base::explicit_stepper_base( const algebra_type &algebra )
+     * \brief Constructs a explicit_stepper_base class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+    /**
+     * \fn explicit_stepper_base::order_type order( void ) const
+     * \return Returns the order of the stepper.
+     */
+
+    /**
+     * \fn explicit_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
+     * \brief This method performs one step. It transforms the result in-place.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+
+    /**
+     * \fn explicit_stepper_base::do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
+
+     * \brief The method performs one step. Additionally to the other method
+     * the derivative of x is also passed to this method. It is supposed to be used in the following way:
+     *
+     * \code
+     * sys( x , dxdt , t );
+     * stepper.do_step( sys , x , dxdt , t , dt );
+     * \endcode
+     *
+     * The result is updated in place in x. This method is disabled if Time and Deriv are of the same type. In this
+     * case the method could not be distinguished from other `do_step` versions.
+     * 
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn void explicit_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+     * \brief The method performs one step. The state of the ODE is updated out-of-place.
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn void explicit_stepper_base::do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+     * \brief The method performs one step. The state of the ODE is updated out-of-place.
+     * Furthermore, the derivative of x at t is passed to the stepper. 
+     * It is supposed to be used in the following way:
+     *
+     * \code
+     * sys( in , dxdt , t );
+     * stepper.do_step( sys , in , dxdt , t , out , dt );
+     * \endcode
+     *
+     * \note This method does not solve the forwarding problem.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn void explicit_stepper_base::adjust_size( const StateIn &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+} // odeint
+} // numeric
+} // boost
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_STEPPER_BASE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp b/include/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp
new file mode 100644
index 0000000..eb09aef
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp
@@ -0,0 +1,431 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp
+
+ [begin_description]
+ Base class for symplectic Runge-Kutta-Nystrom steppers.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_SYMPLECTIC_RKN_STEPPER_BASE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_BASE_SYMPLECTIC_RKN_STEPPER_BASE_HPP_INCLUDED
+
+#include <boost/array.hpp>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+
+#include <boost/numeric/odeint/util/copy.hpp>
+#include <boost/numeric/odeint/util/is_pair.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
+
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template<
+size_t NumOfStages ,
+unsigned short Order ,
+class Coor ,
+class Momentum ,
+class Value ,
+class CoorDeriv ,
+class MomentumDeriv ,
+class Time ,
+class Algebra ,
+class Operations ,
+class Resizer
+>
+class symplectic_nystroem_stepper_base : public algebra_stepper_base< Algebra , Operations >
+{
+
+public:
+
+    typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
+    typedef typename algebra_stepper_base_type::algebra_type algebra_type;
+    typedef typename algebra_stepper_base_type::operations_type operations_type;
+
+    const static size_t num_of_stages = NumOfStages;
+    typedef Coor coor_type;
+    typedef Momentum momentum_type;
+    typedef std::pair< coor_type , momentum_type > state_type;
+    typedef CoorDeriv coor_deriv_type;
+    typedef state_wrapper< coor_deriv_type> wrapped_coor_deriv_type;
+    typedef MomentumDeriv momentum_deriv_type;
+    typedef state_wrapper< momentum_deriv_type > wrapped_momentum_deriv_type;
+    typedef std::pair< coor_deriv_type , momentum_deriv_type > deriv_type;
+    typedef Value value_type;
+    typedef Time time_type;
+    typedef Resizer resizer_type;
+    typedef stepper_tag stepper_category;
+    
+    #ifndef DOXYGEN_SKIP
+    typedef symplectic_nystroem_stepper_base< NumOfStages , Order , Coor , Momentum , Value ,
+            CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
+    #endif 
+    typedef unsigned short order_type;
+
+    static const order_type order_value = Order;
+
+    typedef boost::array< value_type , num_of_stages > coef_type;
+
+    symplectic_nystroem_stepper_base( const coef_type &coef_a , const coef_type &coef_b , const algebra_type &algebra = algebra_type() )
+        : algebra_stepper_base_type( algebra ) , m_coef_a( coef_a ) , m_coef_b( coef_b ) ,
+          m_dqdt_resizer() , m_dpdt_resizer() , m_dqdt() , m_dpdt() 
+    { }
+
+
+    order_type order( void ) const
+    {
+        return order_value;
+    }
+
+    /*
+     * Version 1 : do_step( system , x , t , dt )
+     *
+     * This version does not solve the forwarding problem, boost.range can not be used.
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , const StateInOut &state , time_type t , time_type dt )
+    {
+        typedef typename odeint::unwrap_reference< System >::type system_type;
+        do_step_impl( system , state , t , state , dt , typename is_pair< system_type >::type() );
+    }
+
+    /**
+     * \brief Same function as above. It differs only in a different const specifier in order
+     * to solve the forwarding problem, can be used with Boost.Range.
+     */
+    template< class System , class StateInOut >
+    void do_step( System system , StateInOut &state , time_type t , time_type dt )
+    {
+        typedef typename odeint::unwrap_reference< System >::type system_type;
+        do_step_impl( system , state , t , state , dt , typename is_pair< system_type >::type() );
+    }
+
+
+
+
+    /*
+     * Version 2 : do_step( system , q , p , t , dt );
+     *
+     * For Convenience
+     *
+     * The two overloads are needed in order to solve the forwarding problem.
+     */
+    template< class System , class CoorInOut , class MomentumInOut >
+    void do_step( System system , CoorInOut &q , MomentumInOut &p , time_type t , time_type dt )
+    {
+        do_step( system , std::make_pair( detail::ref( q ) , detail::ref( p ) ) , t , dt );
+    }
+
+    /**
+     * \brief Same function as do_step( system , q , p , t , dt ). It differs only in a different const specifier in order
+     * to solve the forwarding problem, can be called with Boost.Range.
+     */
+    template< class System , class CoorInOut , class MomentumInOut >
+    void do_step( System system , const CoorInOut &q , const MomentumInOut &p , time_type t , time_type dt )
+    {
+        do_step( system , std::make_pair( detail::ref( q ) , detail::ref( p ) ) , t , dt );
+    }
+
+
+
+
+
+    /*
+     * Version 3 : do_step( system , in , t , out , dt )
+     *
+     * The forwarding problem is not solved in this version
+     */
+    template< class System , class StateIn , class StateOut >
+    void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+    {
+        typedef typename odeint::unwrap_reference< System >::type system_type;
+        do_step_impl( system , in , t , out , dt , typename is_pair< system_type >::type() );
+    }
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_dqdt( x );
+        resize_dpdt( x );
+    }
+
+    /** \brief Returns the coefficients a. */
+    const coef_type& coef_a( void ) const { return m_coef_a; }
+
+    /** \brief Returns the coefficients b. */
+    const coef_type& coef_b( void ) const { return m_coef_b; }
+
+private:
+
+    // stepper for systems with function for dq/dt = f(p) and dp/dt = -f(q)
+    template< class System , class StateIn , class StateOut >
+    void do_step_impl( System system , const StateIn &in , time_type /* t */ , StateOut &out , time_type dt , boost::mpl::true_ )
+    {
+        typedef typename odeint::unwrap_reference< System >::type system_type;
+        typedef typename odeint::unwrap_reference< typename system_type::first_type >::type coor_deriv_func_type;
+        typedef typename odeint::unwrap_reference< typename system_type::second_type >::type momentum_deriv_func_type;
+        system_type &sys = system;
+        coor_deriv_func_type &coor_func = sys.first;
+        momentum_deriv_func_type &momentum_func = sys.second;
+
+        typedef typename odeint::unwrap_reference< StateIn >::type state_in_type;
+        typedef typename odeint::unwrap_reference< typename state_in_type::first_type >::type coor_in_type;
+        typedef typename odeint::unwrap_reference< typename state_in_type::second_type >::type momentum_in_type;
+        const state_in_type &state_in = in;
+        const coor_in_type &coor_in = state_in.first;
+        const momentum_in_type &momentum_in = state_in.second;
+
+        typedef typename odeint::unwrap_reference< StateOut >::type state_out_type;
+        typedef typename odeint::unwrap_reference< typename state_out_type::first_type >::type coor_out_type;
+        typedef typename odeint::unwrap_reference< typename state_out_type::second_type >::type momentum_out_type;
+        state_out_type &state_out = out;
+        coor_out_type &coor_out = state_out.first;
+        momentum_out_type &momentum_out = state_out.second;
+
+        m_dqdt_resizer.adjust_size( coor_in , detail::bind( &internal_stepper_base_type::template resize_dqdt< coor_in_type > , detail::ref( *this ) , detail::_1 ) );
+        m_dpdt_resizer.adjust_size( momentum_in , detail::bind( &internal_stepper_base_type::template resize_dpdt< momentum_in_type > , detail::ref( *this ) , detail::_1 ) );
+
+        // ToDo: check sizes?
+
+        for( size_t l=0 ; l<num_of_stages ; ++l )
+        {
+            if( l == 0 )
+            {
+                coor_func( momentum_in , m_dqdt.m_v );
+                this->m_algebra.for_each3( coor_out , coor_in , m_dqdt.m_v ,
+                        typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_a[l] * dt ) );
+                momentum_func( coor_out , m_dpdt.m_v );
+                this->m_algebra.for_each3( momentum_out , momentum_in , m_dpdt.m_v ,
+                        typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_b[l] * dt ) );
+            }
+            else
+            {
+                coor_func( momentum_out , m_dqdt.m_v );
+                this->m_algebra.for_each3( coor_out , coor_out , m_dqdt.m_v ,
+                        typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_a[l] * dt ) );
+                momentum_func( coor_out , m_dpdt.m_v );
+                this->m_algebra.for_each3( momentum_out , momentum_out , m_dpdt.m_v ,
+                        typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_b[l] * dt ) );
+            }
+        }
+    }
+
+
+    // stepper for systems with only function dp /dt = -f(q), dq/dt = p, time not required but still expected for compatibility reasons
+    template< class System , class StateIn , class StateOut >
+    void do_step_impl( System system , const StateIn &in , time_type  /* t */ , StateOut &out , time_type dt , boost::mpl::false_ )
+    {
+        typedef typename odeint::unwrap_reference< System >::type momentum_deriv_func_type;
+        momentum_deriv_func_type &momentum_func = system;
+
+        typedef typename odeint::unwrap_reference< StateIn >::type state_in_type;
+        typedef typename odeint::unwrap_reference< typename state_in_type::first_type >::type coor_in_type;
+        typedef typename odeint::unwrap_reference< typename state_in_type::second_type >::type momentum_in_type;
+        const state_in_type &state_in = in;
+        const coor_in_type &coor_in = state_in.first;
+        const momentum_in_type &momentum_in = state_in.second;
+
+        typedef typename odeint::unwrap_reference< StateOut >::type state_out_type;
+        typedef typename odeint::unwrap_reference< typename state_out_type::first_type >::type coor_out_type;
+        typedef typename odeint::unwrap_reference< typename state_out_type::second_type >::type momentum_out_type;
+        state_out_type &state_out = out;
+        coor_out_type &coor_out = state_out.first;
+        momentum_out_type &momentum_out = state_out.second;
+
+
+        // m_dqdt not required when called with momentum_func only - don't resize
+        // m_dqdt_resizer.adjust_size( coor_in , detail::bind( &internal_stepper_base_type::template resize_dqdt< coor_in_type > , detail::ref( *this ) , detail::_1 ) );
+        m_dpdt_resizer.adjust_size( momentum_in , detail::bind( &internal_stepper_base_type::template resize_dpdt< momentum_in_type > , detail::ref( *this ) , detail::_1 ) );
+
+
+        // ToDo: check sizes?
+
+        // step 0
+        this->m_algebra.for_each3( coor_out  , coor_in , momentum_in ,
+                        typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_a[0] * dt ) );
+        momentum_func( coor_out , m_dpdt.m_v );
+        this->m_algebra.for_each3( momentum_out , momentum_in , m_dpdt.m_v ,
+                                           typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_b[0] * dt ) );
+
+        for( size_t l=1 ; l<num_of_stages ; ++l )
+        {
+            this->m_algebra.for_each3( coor_out , coor_out , momentum_out ,
+                        typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_a[l] * dt ) );
+            momentum_func( coor_out , m_dpdt.m_v );
+            this->m_algebra.for_each3( momentum_out , momentum_out , m_dpdt.m_v ,
+                                       typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , m_coef_b[l] * dt ) );
+        }
+    }
+
+    template< class StateIn >
+    bool resize_dqdt( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dqdt , x , typename is_resizeable<coor_deriv_type>::type() );
+    }
+
+    template< class StateIn >
+    bool resize_dpdt( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dpdt , x , typename is_resizeable<momentum_deriv_type>::type() );
+    }
+
+
+    const coef_type m_coef_a;
+    const coef_type m_coef_b;
+
+    resizer_type m_dqdt_resizer;
+    resizer_type m_dpdt_resizer;
+    wrapped_coor_deriv_type m_dqdt;
+    wrapped_momentum_deriv_type m_dpdt;
+
+};
+
+/********* DOXYGEN *********/
+
+/**
+ * \class symplectic_nystroem_stepper_base
+ * \brief Base class for all symplectic steppers of Nystroem type.
+ *
+ * This class is the base class for the symplectic Runge-Kutta-Nystroem steppers. Symplectic steppers are usually
+ * used to solve Hamiltonian systems and they conserve the phase space volume, see
+ * <a href="http://en.wikipedia.org/wiki/Symplectic_integrator">en.wikipedia.org/wiki/Symplectic_integrator</a>. 
+ * Furthermore, the energy is conserved
+ * in average. In detail this class of steppers can be used to solve separable Hamiltonian systems which can be written
+ * in the form H(q,p) = H1(p) + H2(q). q is usually called the coordinate, while p is the momentum. The equations of motion
+ * are dq/dt = dH1/dp, dp/dt = -dH2/dq.
+ *
+ * ToDo : add formula for solver and explanation of the coefficients
+ * 
+ * symplectic_nystroem_stepper_base uses odeints algebra and operation system. Step size and error estimation are not
+ * provided for this class of solvers. It derives from algebra_stepper_base. Several `do_step` variants are provided:
+ *
+ * - `do_step( sys , x , t , dt )` - The classical `do_step` method. The sys can be either a pair of function objects
+ *    for the coordinate or the momentum part or one function object for the momentum part. `x` is a pair of coordinate
+ *    and momentum. The state is updated in-place.
+ * - `do_step( sys , q , p , t , dt )` - This method is similar to the method above with the difference that the coordinate
+ *    and the momentum are passed explicitly and not packed into a pair.
+ * - `do_step( sys , x_in , t , x_out , dt )` - This method transforms the state out-of-place. `x_in` and `x_out` are here pairs
+ *    of coordinate and momentum.
+ *
+ * \tparam NumOfStages Number of stages.
+ * \tparam Order The order of the stepper.
+ * \tparam Coor The type representing the coordinates q.
+ * \tparam Momentum The type representing the coordinates p.
+ * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
+ * \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
+ * \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
+ * \tparam Time The type representing the time t.
+ * \tparam Algebra The algebra.
+ * \tparam Operations The operations.
+ * \tparam Resizer The resizer policy.
+ */
+
+    /**
+     * \fn symplectic_nystroem_stepper_base::symplectic_nystroem_stepper_base( const coef_type &coef_a , const coef_type &coef_b , const algebra_type &algebra )
+     * \brief Constructs a symplectic_nystroem_stepper_base class. The parameters of the specific Nystroem method and the
+     * algebra have to be passed.
+     * \param coef_a The coefficients a.
+     * \param coef_b The coefficients b.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+    /**
+     * \fn symplectic_nystroem_stepper_base::order( void ) const
+     * \return Returns the order of the stepper.
+     */
+
+    /**
+     * \fn symplectic_nystroem_stepper_base::do_step( System system , const StateInOut &state , time_type t , time_type dt )
+     * \brief This method performs one step. The system can be either a pair of two function object
+     * describing the momentum part and the coordinate part or one function object describing only
+     * the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state
+     * is updated in-place.
+     *
+     * \note boost::ref or std::ref can be used for the system as well as for the state. So, it is correct
+     * to write `stepper.do_step( make_pair( std::ref( fq ) , std::ref( fp ) ) , make_pair( std::ref( q ) , std::ref( p ) ) , t , dt )`.
+     *
+     * \note This method solves the forwarding problem.
+     *
+     * \param system The system, can be represented as a pair of two function object or one function object. See above.
+     * \param state The state of the ODE. It is a pair of Coor and Momentum. The state is updated in-place, therefore, the
+     * new value of the state will be written into this variable.
+     * \param t The time of the ODE. It is not advanced by this method.
+     * \param dt The time step.
+     */
+
+    /**
+     * \fn symplectic_nystroem_stepper_base::do_step( System system , CoorInOut &q , MomentumInOut &p , time_type t , time_type dt )
+     * \brief This method performs one step. The system can be either a pair of two function object
+     * describing the momentum part and the coordinate part or one function object describing only
+     * the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state
+     * is updated in-place.
+     *
+     * \note boost::ref or std::ref can be used for the system. So, it is correct
+     * to write `stepper.do_step( make_pair( std::ref( fq ) , std::ref( fp ) ) , q , p , t , dt )`.
+     *
+     * \note This method solves the forwarding problem.
+     *
+     * \param system The system, can be represented as a pair of two function object or one function object. See above.
+     * \param q The coordinate of the ODE. It is updated in-place. Therefore, the new value of the coordinate will be written
+     * into this variable.
+     * \param p The momentum of the ODE. It is updated in-place. Therefore, the new value of the momentum will be written info
+     * this variable.
+     * \param t The time of the ODE. It is not advanced by this method.
+     * \param dt The time step.
+     */
+
+    /**
+     * \fn symplectic_nystroem_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
+     * \brief This method performs one step. The system can be either a pair of two function object
+     * describing the momentum part and the coordinate part or one function object describing only
+     * the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state
+     * is updated out-of-place.
+     *
+     * \note boost::ref or std::ref can be used for the system. So, it is correct
+     * to write `stepper.do_step( make_pair( std::ref( fq ) , std::ref( fp ) ) , x_in , t , x_out , dt )`.
+     *
+     * \note This method NOT solve the forwarding problem.
+     *
+     * \param system The system, can be represented as a pair of two function object or one function object. See above.
+     * \param in The state of the ODE, which is a pair of coordinate and momentum. The state is updated out-of-place, therefore the 
+     * new value is written into out
+     * \param t The time of the ODE. It is not advanced by this method.
+     * \param out The new state of the ODE.
+     * \param dt The time step.
+     */
+
+    /**
+     * \fn symplectic_nystroem_stepper_base::adjust_size( const StateType &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_SYMPLECTIC_RKN_STEPPER_BASE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/bulirsch_stoer.hpp b/include/boost/numeric/odeint/stepper/bulirsch_stoer.hpp
new file mode 100644
index 0000000..02c3749
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/bulirsch_stoer.hpp
@@ -0,0 +1,642 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/stepper/bulirsch_stoer.hpp
+
+  [begin_description]
+  Implementation of the Burlish-Stoer method. As described in
+  Ernst Hairer, Syvert Paul Norsett, Gerhard Wanner
+  Solving Ordinary Differential Equations I. Nonstiff Problems.
+  Springer Series in Comput. Mathematics, Vol. 8, Springer-Verlag 1987, Second revised edition 1993.
+  [end_description]
+
+  Copyright 2011-2013 Mario Mulansky
+  Copyright 2011-2013 Karsten Ahnert
+  Copyright 2012 Christoph Koke
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_HPP_INCLUDED
+
+
+#include <iostream>
+
+#include <algorithm>
+
+#include <boost/config.hpp> // for min/max guidelines
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/modified_midpoint.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template<
+    class State ,
+    class Value = double ,
+    class Deriv = State ,
+    class Time = Value ,
+    class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+    class Operations = typename operations_dispatcher< State >::operations_type ,
+    class Resizer = initially_resizer
+    >
+class bulirsch_stoer {
+
+public:
+
+    typedef State state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef Time time_type;
+    typedef Algebra algebra_type;
+    typedef Operations operations_type;
+    typedef Resizer resizer_type;
+#ifndef DOXYGEN_SKIP
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef controlled_stepper_tag stepper_category;
+
+    typedef bulirsch_stoer< State , Value , Deriv , Time , Algebra , Operations , Resizer > controlled_error_bs_type;
+
+    typedef typename inverse_time< time_type >::type inv_time_type;
+
+    typedef std::vector< value_type > value_vector;
+    typedef std::vector< time_type > time_vector;
+    typedef std::vector< inv_time_type > inv_time_vector;  //should be 1/time_type for boost.units
+    typedef std::vector< value_vector > value_matrix;
+    typedef std::vector< size_t > int_vector;
+    typedef std::vector< wrapped_state_type > state_table_type;
+#endif //DOXYGEN_SKIP
+    const static size_t m_k_max = 8;
+
+    bulirsch_stoer(
+        value_type eps_abs = 1E-6 , value_type eps_rel = 1E-6 ,
+        value_type factor_x = 1.0 , value_type factor_dxdt = 1.0 ,
+        time_type max_dt = static_cast<time_type>(0))
+        : m_error_checker( eps_abs , eps_rel , factor_x, factor_dxdt ) , m_midpoint() ,
+          m_last_step_rejected( false ) , m_first( true ) ,
+          m_max_dt(max_dt) ,
+          m_interval_sequence( m_k_max+1 ) ,
+          m_coeff( m_k_max+1 ) ,
+          m_cost( m_k_max+1 ) ,
+          m_facmin_table( m_k_max+1 ) ,
+          m_table( m_k_max ) ,
+          STEPFAC1( 0.65 ) , STEPFAC2( 0.94 ) , STEPFAC3( 0.02 ) , STEPFAC4( 4.0 ) , KFAC1( 0.8 ) , KFAC2( 0.9 )
+    {
+        BOOST_USING_STD_MIN();
+        BOOST_USING_STD_MAX();
+        /* initialize sequence of stage numbers and work */
+        for( unsigned short i = 0; i < m_k_max+1; i++ )
+        {
+            m_interval_sequence[i] = 2 * (i+1);
+            if( i == 0 )
+                m_cost[i] = m_interval_sequence[i];
+            else
+                m_cost[i] = m_cost[i-1] + m_interval_sequence[i];
+            m_coeff[i].resize(i);
+            m_facmin_table[i] = pow BOOST_PREVENT_MACRO_SUBSTITUTION( STEPFAC3 , static_cast< value_type >(1) / static_cast< value_type >( 2*i+1 ) );
+            for( size_t k = 0 ; k < i ; ++k  )
+            {
+                const value_type r = static_cast< value_type >( m_interval_sequence[i] ) / static_cast< value_type >( m_interval_sequence[k] );
+                m_coeff[i][k] = 1.0 / ( r*r - static_cast< value_type >( 1.0 ) ); // coefficients for extrapolation
+            }
+        }
+        reset();
+    }
+
+
+    /*
+     * Version 1 : try_step( sys , x , t , dt )
+     *
+     * The overloads are needed to solve the forwarding problem
+     */
+    template< class System , class StateInOut >
+    controlled_step_result try_step( System system , StateInOut &x , time_type &t , time_type &dt )
+    {
+        return try_step_v1( system , x , t, dt );
+    }
+
+    /**
+     * \brief Second version to solve the forwarding problem, can be used with Boost.Range as StateInOut.
+     */
+    template< class System , class StateInOut >
+    controlled_step_result try_step( System system , const StateInOut &x , time_type &t , time_type &dt )
+    {
+        return try_step_v1( system , x , t, dt );
+    }
+
+    /*
+     * Version 2 : try_step( sys , x , dxdt , t , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    template< class System , class StateInOut , class DerivIn >
+    controlled_step_result try_step( System system , StateInOut &x , const DerivIn &dxdt , time_type &t , time_type &dt )
+    {
+        m_xnew_resizer.adjust_size( x , detail::bind( &controlled_error_bs_type::template resize_m_xnew< StateInOut > , detail::ref( *this ) , detail::_1 ) );
+        controlled_step_result res = try_step( system , x , dxdt , t , m_xnew.m_v , dt );
+        if( res == success )
+        {
+            boost::numeric::odeint::copy( m_xnew.m_v , x );
+        }
+        return res;
+    }
+
+    /*
+     * Version 3 : try_step( sys , in , t , out , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    template< class System , class StateIn , class StateOut >
+    typename boost::disable_if< boost::is_same< StateIn , time_type > , controlled_step_result >::type
+    try_step( System system , const StateIn &in , time_type &t , StateOut &out , time_type &dt )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_dxdt_resizer.adjust_size( in , detail::bind( &controlled_error_bs_type::template resize_m_dxdt< StateIn > , detail::ref( *this ) , detail::_1 ) );
+        sys( in , m_dxdt.m_v , t );
+        return try_step( system , in , m_dxdt.m_v , t , out , dt );
+    }
+
+
+    /*
+     * Full version : try_step( sys , in , dxdt_in , t , out , dt )
+     *
+     * contains the actual implementation
+     */
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    controlled_step_result try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , time_type &dt )
+    {
+        if( m_max_dt != static_cast<time_type>(0) && detail::less_with_sign(m_max_dt, dt, dt) )
+        {
+            // given step size is bigger then max_dt
+            // set limit and return fail
+            dt = m_max_dt;
+            return fail;
+        }
+
+        BOOST_USING_STD_MIN();
+        BOOST_USING_STD_MAX();
+
+        static const value_type val1( 1.0 );
+
+        if( m_resizer.adjust_size( in , detail::bind( &controlled_error_bs_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ) )
+        {
+            reset(); // system resized -> reset
+        }
+
+        if( dt != m_dt_last )
+        {
+            reset(); // step size changed from outside -> reset
+        }
+
+        bool reject( true );
+
+        time_vector h_opt( m_k_max+1 );
+        inv_time_vector work( m_k_max+1 );
+
+        time_type new_h = dt;
+
+        /* m_current_k_opt is the estimated current optimal stage number */
+        for( size_t k = 0 ; k <= m_current_k_opt+1 ; k++ )
+        {
+            /* the stage counts are stored in m_interval_sequence */
+            m_midpoint.set_steps( m_interval_sequence[k] );
+            if( k == 0 )
+            {
+                m_midpoint.do_step( system , in , dxdt , t , out , dt );
+                /* the first step, nothing more to do */
+            }
+            else
+            {
+                m_midpoint.do_step( system , in , dxdt , t , m_table[k-1].m_v , dt );
+                extrapolate( k , m_table , m_coeff , out );
+                // get error estimate
+                m_algebra.for_each3( m_err.m_v , out , m_table[0].m_v ,
+                                     typename operations_type::template scale_sum2< value_type , value_type >( val1 , -val1 ) );
+                const value_type error = m_error_checker.error( m_algebra , in , dxdt , m_err.m_v , dt );
+                h_opt[k] = calc_h_opt( dt , error , k );
+                work[k] = static_cast<value_type>( m_cost[k] ) / h_opt[k];
+
+                if( (k == m_current_k_opt-1) || m_first )
+                { // convergence before k_opt ?
+                    if( error < 1.0 )
+                    {
+                        //convergence
+                        reject = false;
+                        if( (work[k] < KFAC2*work[k-1]) || (m_current_k_opt <= 2) )
+                        {
+                            // leave order as is (except we were in first round)
+                            m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(k)+1 ) );
+                            new_h = h_opt[k];
+                            new_h *= static_cast<value_type>( m_cost[k+1] ) / static_cast<value_type>( m_cost[k] );
+                        } else {
+                            m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(k) ) );
+                            new_h = h_opt[k];
+                        }
+                        break;
+                    }
+                    else if( should_reject( error , k ) && !m_first )
+                    {
+                        reject = true;
+                        new_h = h_opt[k];
+                        break;
+                    }
+                }
+                if( k == m_current_k_opt )
+                { // convergence at k_opt ?
+                    if( error < 1.0 )
+                    {
+                        //convergence
+                        reject = false;
+                        if( (work[k-1] < KFAC2*work[k]) )
+                        {
+                            m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(m_current_k_opt)-1 );
+                            new_h = h_opt[m_current_k_opt];
+                        }
+                        else if( (work[k] < KFAC2*work[k-1]) && !m_last_step_rejected )
+                        {
+                            m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max-1) , static_cast<int>(m_current_k_opt)+1 );
+                            new_h = h_opt[k];
+                            new_h *= static_cast<value_type>(m_cost[m_current_k_opt])/static_cast<value_type>(m_cost[k]);
+                        } else
+                            new_h = h_opt[m_current_k_opt];
+                        break;
+                    }
+                    else if( should_reject( error , k ) )
+                    {
+                        reject = true;
+                        new_h = h_opt[m_current_k_opt];
+                        break;
+                    }
+                }
+                if( k == m_current_k_opt+1 )
+                { // convergence at k_opt+1 ?
+                    if( error < 1.0 )
+                    {   //convergence
+                        reject = false;
+                        if( work[k-2] < KFAC2*work[k-1] )
+                            m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(m_current_k_opt)-1 );
+                        if( (work[k] < KFAC2*work[m_current_k_opt]) && !m_last_step_rejected )
+                            m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , static_cast<int>(k) );
+                        new_h = h_opt[m_current_k_opt];
+                    } else
+                    {
+                        reject = true;
+                        new_h = h_opt[m_current_k_opt];
+                    }
+                    break;
+                }
+            }
+        }
+
+        if( !reject )
+        {
+            t += dt;
+        }
+
+        if( !m_last_step_rejected || boost::numeric::odeint::detail::less_with_sign(new_h, dt, dt) )
+        {
+            // limit step size
+            if( m_max_dt != static_cast<time_type>(0) )
+            {
+                new_h = detail::min_abs(m_max_dt, new_h);
+            }
+            m_dt_last = new_h;
+            dt = new_h;
+        }
+
+        m_last_step_rejected = reject;
+        m_first = false;
+
+        if( reject )
+            return fail;
+        else
+            return success;
+    }
+
+    /** \brief Resets the internal state of the stepper */
+    void reset()
+    {
+        m_first = true;
+        m_last_step_rejected = false;
+        // crude estimate of optimal order
+        m_current_k_opt = 4;
+        /* no calculation because log10 might not exist for value_type!
+        const value_type logfact( -log10( max BOOST_PREVENT_MACRO_SUBSTITUTION( eps_rel , static_cast< value_type >(1.0E-12) ) ) * 0.6 + 0.5 );
+        m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( 1 ) , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( m_k_max-1 ) , logfact ));
+        */
+    }
+
+
+    /* Resizer methods */
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_m_dxdt( x );
+        resize_m_xnew( x );
+        resize_impl( x );
+        m_midpoint.adjust_size( x );
+    }
+
+
+private:
+
+    template< class StateIn >
+    bool resize_m_dxdt( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+    }
+
+    template< class StateIn >
+    bool resize_m_xnew( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_xnew , x , typename is_resizeable<state_type>::type() );
+    }
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized( false );
+        for( size_t i = 0 ; i < m_k_max ; ++i )
+            resized |= adjust_size_by_resizeability( m_table[i] , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_err , x , typename is_resizeable<state_type>::type() );
+        return resized;
+    }
+
+
+    template< class System , class StateInOut >
+    controlled_step_result try_step_v1( System system , StateInOut &x , time_type &t , time_type &dt )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_dxdt_resizer.adjust_size( x , detail::bind( &controlled_error_bs_type::template resize_m_dxdt< StateInOut > , detail::ref( *this ) , detail::_1 ) );
+        sys( x , m_dxdt.m_v ,t );
+        return try_step( system , x , m_dxdt.m_v , t , dt );
+    }
+
+
+    template< class StateInOut >
+    void extrapolate( size_t k , state_table_type &table , const value_matrix &coeff , StateInOut &xest )
+    /* polynomial extrapolation, see http://www.nr.com/webnotes/nr3web21.pdf
+       uses the obtained intermediate results to extrapolate to dt->0 
+    */
+    {
+        static const value_type val1 = static_cast< value_type >( 1.0 );
+        for( int j=k-1 ; j>0 ; --j )
+        {
+            m_algebra.for_each3( table[j-1].m_v , table[j].m_v , table[j-1].m_v ,
+                                 typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k][j] , -coeff[k][j] ) );
+        }
+        m_algebra.for_each3( xest , table[0].m_v , xest ,
+                             typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k][0] , -coeff[k][0]) );
+    }
+
+    time_type calc_h_opt( time_type h , value_type error , size_t k ) const
+    /* calculates the optimal step size for a given error and stage number */
+    {
+        BOOST_USING_STD_MIN();
+        BOOST_USING_STD_MAX();
+        using std::pow;
+        value_type expo( 1.0/(2*k+1) );
+        value_type facmin = m_facmin_table[k];
+        value_type fac;
+        if (error == 0.0)
+            fac=1.0/facmin;
+        else
+        {
+            fac = STEPFAC2 / pow BOOST_PREVENT_MACRO_SUBSTITUTION( error / STEPFAC1 , expo );
+            fac = max BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>(facmin/STEPFAC4) , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>(1.0/facmin) , fac ) );
+        }
+        return h*fac;
+    }
+
+    controlled_step_result set_k_opt( size_t k , const inv_time_vector &work , const time_vector &h_opt , time_type &dt )
+    /* calculates the optimal stage number */
+    {
+        if( k == 1 )
+        {
+            m_current_k_opt = 2;
+            return success;
+        }
+        if( (work[k-1] < KFAC1*work[k]) || (k == m_k_max) )
+        {   // order decrease
+            m_current_k_opt = k-1;
+            dt = h_opt[ m_current_k_opt ];
+            return success;
+        }
+        else if( (work[k] < KFAC2*work[k-1]) || m_last_step_rejected || (k == m_k_max-1) )
+        {   // same order - also do this if last step got rejected
+            m_current_k_opt = k;
+            dt = h_opt[ m_current_k_opt ];
+            return success;
+        }
+        else
+        {   // order increase - only if last step was not rejected
+            m_current_k_opt = k+1;
+            dt = h_opt[ m_current_k_opt-1 ] * m_cost[ m_current_k_opt ] / m_cost[ m_current_k_opt-1 ] ;
+            return success;
+        }
+    }
+
+    bool in_convergence_window( size_t k ) const
+    {
+        if( (k == m_current_k_opt-1) && !m_last_step_rejected )
+            return true; // decrease stepsize only if last step was not rejected
+        return ( (k == m_current_k_opt) || (k == m_current_k_opt+1) );
+    }
+
+    bool should_reject( value_type error , size_t k ) const
+    {
+        if( k == m_current_k_opt-1 )
+        {
+            const value_type d = m_interval_sequence[m_current_k_opt] * m_interval_sequence[m_current_k_opt+1] /
+                (m_interval_sequence[0]*m_interval_sequence[0]);
+            //step will fail, criterion 17.3.17 in NR
+            return ( error > d*d );
+        }
+        else if( k == m_current_k_opt )
+        {
+            const value_type d = m_interval_sequence[m_current_k_opt] / m_interval_sequence[0];
+            return ( error > d*d );
+        } else
+            return error > 1.0;
+    }
+
+    default_error_checker< value_type, algebra_type , operations_type > m_error_checker;
+    modified_midpoint< state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type > m_midpoint;
+
+    bool m_last_step_rejected;
+    bool m_first;
+
+    time_type m_dt_last;
+    time_type m_t_last;
+    time_type m_max_dt;
+
+    size_t m_current_k_opt;
+
+    algebra_type m_algebra;
+
+    resizer_type m_dxdt_resizer;
+    resizer_type m_xnew_resizer;
+    resizer_type m_resizer;
+
+    wrapped_state_type m_xnew;
+    wrapped_state_type m_err;
+    wrapped_deriv_type m_dxdt;
+
+    int_vector m_interval_sequence; // stores the successive interval counts
+    value_matrix m_coeff;
+    int_vector m_cost; // costs for interval count
+    value_vector m_facmin_table; // for precomputed facmin to save pow calls
+
+    state_table_type m_table; // sequence of states for extrapolation
+
+    value_type STEPFAC1 , STEPFAC2 , STEPFAC3 , STEPFAC4 , KFAC1 , KFAC2;
+};
+
+
+/******** DOXYGEN ********/
+/**
+ * \class bulirsch_stoer
+ * \brief The Bulirsch-Stoer algorithm.
+ * 
+ * The Bulirsch-Stoer is a controlled stepper that adjusts both step size
+ * and order of the method. The algorithm uses the modified midpoint and
+ * a polynomial extrapolation compute the solution.
+ *
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+    /**
+     * \fn bulirsch_stoer::bulirsch_stoer( value_type eps_abs , value_type eps_rel , value_type factor_x , value_type factor_dxdt )
+     * \brief Constructs the bulirsch_stoer class, including initialization of 
+     * the error bounds.
+     *
+     * \param eps_abs Absolute tolerance level.
+     * \param eps_rel Relative tolerance level.
+     * \param factor_x Factor for the weight of the state.
+     * \param factor_dxdt Factor for the weight of the derivative.
+     */
+
+    /**
+     * \fn bulirsch_stoer::try_step( System system , StateInOut &x , time_type &t , time_type &dt )
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed. Also, the internal order of the stepper is adjusted if required.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. 
+     * It must fulfill the Simple System concept.
+     * \param x The state of the ODE which should be solved. Overwritten if 
+     * the step is successful.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+
+    /**
+     * \fn bulirsch_stoer::try_step( System system , StateInOut &x , const DerivIn &dxdt , time_type &t , time_type &dt )
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed. Also, the internal order of the stepper is adjusted if required.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. 
+     * It must fulfill the Simple System concept.
+     * \param x The state of the ODE which should be solved. Overwritten if 
+     * the step is successful.
+     * \param dxdt The derivative of state.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+
+    /**
+     * \fn bulirsch_stoer::try_step( System system , const StateIn &in , time_type &t , StateOut &out , time_type &dt )
+     * \brief Tries to perform one step.
+     *
+     * \note This method is disabled if state_type=time_type to avoid ambiguity.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed. Also, the internal order of the stepper is adjusted if required.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. 
+     * It must fulfill the Simple System concept.
+     * \param in The state of the ODE which should be solved.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param out Used to store the result of the step.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+
+
+    /**
+     * \fn bulirsch_stoer::try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , time_type &dt )
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed. Also, the internal order of the stepper is adjusted if required.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. 
+     * It must fulfill the Simple System concept.
+     * \param in The state of the ODE which should be solved.
+     * \param dxdt The derivative of state.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param out Used to store the result of the step.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+
+
+    /**
+     * \fn bulirsch_stoer::adjust_size( const StateIn &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+}
+}
+}
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp b/include/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp
new file mode 100644
index 0000000..6a1eed1
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp
@@ -0,0 +1,838 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp
+
+ [begin_description]
+ Implementaiton of the Burlish-Stoer method with dense output
+ [end_description]
+
+ Copyright 2011-2015 Mario Mulansky
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_DENSE_OUT_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_DENSE_OUT_HPP_INCLUDED
+
+
+#include <iostream>
+
+#include <algorithm>
+
+#include <boost/config.hpp> // for min/max guidelines
+
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/math/special_functions/binomial.hpp>
+
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/modified_midpoint.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+
+#include <boost/numeric/odeint/integrate/max_step_checker.hpp>
+
+#include <boost/type_traits.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template<
+    class State ,
+    class Value = double ,
+    class Deriv = State ,
+    class Time = Value ,
+    class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+    class Operations = typename operations_dispatcher< State >::operations_type ,
+    class Resizer = initially_resizer
+    >
+class bulirsch_stoer_dense_out {
+
+
+public:
+
+    typedef State state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef Time time_type;
+    typedef Algebra algebra_type;
+    typedef Operations operations_type;
+    typedef Resizer resizer_type;
+    typedef dense_output_stepper_tag stepper_category;
+#ifndef DOXYGEN_SKIP
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+
+    typedef bulirsch_stoer_dense_out< State , Value , Deriv , Time , Algebra , Operations , Resizer > controlled_error_bs_type;
+
+    typedef typename inverse_time< time_type >::type inv_time_type;
+
+    typedef std::vector< value_type > value_vector;
+    typedef std::vector< time_type > time_vector;
+    typedef std::vector< inv_time_type > inv_time_vector;  //should be 1/time_type for boost.units
+    typedef std::vector< value_vector > value_matrix;
+    typedef std::vector< size_t > int_vector;
+    typedef std::vector< wrapped_state_type > state_vector_type;
+    typedef std::vector< wrapped_deriv_type > deriv_vector_type;
+    typedef std::vector< deriv_vector_type > deriv_table_type;
+#endif //DOXYGEN_SKIP
+
+    const static size_t m_k_max = 8;
+
+
+
+    bulirsch_stoer_dense_out(
+        value_type eps_abs = 1E-6 , value_type eps_rel = 1E-6 ,
+        value_type factor_x = 1.0 , value_type factor_dxdt = 1.0 ,
+        time_type max_dt = static_cast<time_type>(0) ,
+        bool control_interpolation = false )
+        : m_error_checker( eps_abs , eps_rel , factor_x, factor_dxdt ) ,
+          m_max_dt(max_dt) ,
+          m_control_interpolation( control_interpolation) ,
+          m_last_step_rejected( false ) , m_first( true ) ,
+          m_current_state_x1( true ) ,
+          m_error( m_k_max ) ,
+          m_interval_sequence( m_k_max+1 ) ,
+          m_coeff( m_k_max+1 ) ,
+          m_cost( m_k_max+1 ) ,
+          m_facmin_table( m_k_max+1 ) ,
+          m_table( m_k_max ) ,
+          m_mp_states( m_k_max+1 ) ,
+          m_derivs( m_k_max+1 ) ,
+          m_diffs( 2*m_k_max+2 ) ,
+          STEPFAC1( 0.65 ) , STEPFAC2( 0.94 ) , STEPFAC3( 0.02 ) , STEPFAC4( 4.0 ) , KFAC1( 0.8 ) , KFAC2( 0.9 )
+    {
+        BOOST_USING_STD_MIN();
+        BOOST_USING_STD_MAX();
+
+        for( unsigned short i = 0; i < m_k_max+1; i++ )
+        {
+            /* only this specific sequence allows for dense output */
+            m_interval_sequence[i] = 2 + 4*i;  // 2 6 10 14 ...
+            m_derivs[i].resize( m_interval_sequence[i] );
+            if( i == 0 )
+            {
+                m_cost[i] = m_interval_sequence[i];
+            } else
+            {
+                m_cost[i] = m_cost[i-1] + m_interval_sequence[i];
+            }
+            m_facmin_table[i] = pow BOOST_PREVENT_MACRO_SUBSTITUTION( STEPFAC3 , static_cast< value_type >(1) / static_cast< value_type >( 2*i+1 ) );
+            m_coeff[i].resize(i);
+            for( size_t k = 0 ; k < i ; ++k  )
+            {
+                const value_type r = static_cast< value_type >( m_interval_sequence[i] ) / static_cast< value_type >( m_interval_sequence[k] );
+                m_coeff[i][k] = 1.0 / ( r*r - static_cast< value_type >( 1.0 ) ); // coefficients for extrapolation
+            }
+            // crude estimate of optimal order
+
+            m_current_k_opt = 4;
+            /* no calculation because log10 might not exist for value_type!
+            const value_type logfact( -log10( max BOOST_PREVENT_MACRO_SUBSTITUTION( eps_rel , static_cast< value_type >( 1.0E-12 ) ) ) * 0.6 + 0.5 );
+            m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 1 , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>( m_k_max-1 ) , static_cast<int>( logfact ) ));
+            */
+        }
+        int num = 1;
+        for( int i = 2*(m_k_max)+1 ; i >=0  ; i-- )
+        {
+            m_diffs[i].resize( num );
+            num += (i+1)%2;
+        }
+    }
+
+    template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut >
+    controlled_step_result try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , DerivOut &dxdt_new , time_type &dt )
+    {
+        if( m_max_dt != static_cast<time_type>(0) && detail::less_with_sign(m_max_dt, dt, dt) )
+        {
+            // given step size is bigger then max_dt
+            // set limit and return fail
+            dt = m_max_dt;
+            return fail;
+        }
+
+        BOOST_USING_STD_MIN();
+        BOOST_USING_STD_MAX();
+        using std::pow;
+        
+        static const value_type val1( 1.0 );
+
+        bool reject( true );
+
+        time_vector h_opt( m_k_max+1 );
+        inv_time_vector work( m_k_max+1 );
+
+        m_k_final = 0;
+        time_type new_h = dt;
+
+        //std::cout << "t=" << t <<", dt=" << dt << ", k_opt=" << m_current_k_opt << ", first: " << m_first << std::endl;
+
+        for( size_t k = 0 ; k <= m_current_k_opt+1 ; k++ )
+        {
+            m_midpoint.set_steps( m_interval_sequence[k] );
+            if( k == 0 )
+            {
+                m_midpoint.do_step( system , in , dxdt , t , out , dt , m_mp_states[k].m_v , m_derivs[k]);
+            }
+            else
+            {
+                m_midpoint.do_step( system , in , dxdt , t , m_table[k-1].m_v , dt , m_mp_states[k].m_v , m_derivs[k] );
+                extrapolate( k , m_table , m_coeff , out );
+                // get error estimate
+                m_algebra.for_each3( m_err.m_v , out , m_table[0].m_v ,
+                                     typename operations_type::template scale_sum2< value_type , value_type >( val1 , -val1 ) );
+                const value_type error = m_error_checker.error( m_algebra , in , dxdt , m_err.m_v , dt );
+                h_opt[k] = calc_h_opt( dt , error , k );
+                work[k] = static_cast<value_type>( m_cost[k] ) / h_opt[k];
+
+                m_k_final = k;
+
+                if( (k == m_current_k_opt-1) || m_first )
+                { // convergence before k_opt ?
+                    if( error < 1.0 )
+                    {
+                        //convergence
+                        reject = false;
+                        if( (work[k] < KFAC2*work[k-1]) || (m_current_k_opt <= 2) )
+                        {
+                            // leave order as is (except we were in first round)
+                            m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(k)+1 ) );
+                            new_h = h_opt[k] * static_cast<value_type>( m_cost[k+1] ) / static_cast<value_type>( m_cost[k] );
+                        } else {
+                            m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(k) ) );
+                            new_h = h_opt[k];
+                        }
+                        break;
+                    }
+                    else if( should_reject( error , k ) && !m_first )
+                    {
+                        reject = true;
+                        new_h = h_opt[k];
+                        break;
+                    }
+                }
+                if( k == m_current_k_opt )
+                { // convergence at k_opt ?
+                    if( error < 1.0 )
+                    {
+                        //convergence
+                        reject = false;
+                        if( (work[k-1] < KFAC2*work[k]) )
+                        {
+                            m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(m_current_k_opt)-1 );
+                            new_h = h_opt[m_current_k_opt];
+                        }
+                        else if( (work[k] < KFAC2*work[k-1]) && !m_last_step_rejected )
+                        {
+                            m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , static_cast<int>(m_current_k_opt)+1 );
+                            new_h = h_opt[k]*static_cast<value_type>( m_cost[m_current_k_opt] ) / static_cast<value_type>( m_cost[k] );
+                        } else
+                            new_h = h_opt[m_current_k_opt];
+                        break;
+                    }
+                    else if( should_reject( error , k ) )
+                    {
+                        reject = true;
+                        new_h = h_opt[m_current_k_opt];
+                        break;
+                    }
+                }
+                if( k == m_current_k_opt+1 )
+                { // convergence at k_opt+1 ?
+                    if( error < 1.0 )
+                    {   //convergence
+                        reject = false;
+                        if( work[k-2] < KFAC2*work[k-1] )
+                            m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( 2 , static_cast<int>(m_current_k_opt)-1 );
+                        if( (work[k] < KFAC2*work[m_current_k_opt]) && !m_last_step_rejected )
+                            m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max)-1 , static_cast<int>(k) );
+                        new_h = h_opt[m_current_k_opt];
+                    } else
+                    {
+                        reject = true;
+                        new_h = h_opt[m_current_k_opt];
+                    }
+                    break;
+                }
+            }
+        }
+
+        if( !reject )
+        {
+
+            //calculate dxdt for next step and dense output
+            typename odeint::unwrap_reference< System >::type &sys = system;
+            sys( out , dxdt_new , t+dt );
+
+            //prepare dense output
+            value_type error = prepare_dense_output( m_k_final , in , dxdt , out , dxdt_new , dt );
+
+            if( error > static_cast<value_type>(10) ) // we are not as accurate for interpolation as for the steps
+            {
+                reject = true;
+                new_h = dt * pow BOOST_PREVENT_MACRO_SUBSTITUTION( error , static_cast<value_type>(-1)/(2*m_k_final+2) );
+            } else {
+                t += dt;
+            }
+        }
+        //set next stepsize
+        if( !m_last_step_rejected || (new_h < dt) )
+        {
+            // limit step size
+            if( m_max_dt != static_cast<time_type>(0) )
+            {
+                new_h = detail::min_abs(m_max_dt, new_h);
+            }
+            dt = new_h;
+        }
+
+        m_last_step_rejected = reject;
+        if( reject )
+            return fail;
+        else
+            return success;
+    }
+
+    template< class StateType >
+    void initialize( const StateType &x0 , const time_type &t0 , const time_type &dt0 )
+    {
+        m_resizer.adjust_size( x0 , detail::bind( &controlled_error_bs_type::template resize_impl< StateType > , detail::ref( *this ) , detail::_1 ) );
+        boost::numeric::odeint::copy( x0 , get_current_state() );
+        m_t = t0;
+        m_dt = dt0;
+        reset();
+    }
+
+
+    /*  =======================================================
+     *  the actual step method that should be called from outside (maybe make try_step private?)
+     */
+    template< class System >
+    std::pair< time_type , time_type > do_step( System system )
+    {
+        if( m_first )
+        {
+            typename odeint::unwrap_reference< System >::type &sys = system;
+            sys( get_current_state() , get_current_deriv() , m_t );
+        }
+
+        failed_step_checker fail_checker;  // to throw a runtime_error if step size adjustment fails
+        controlled_step_result res = fail;
+        m_t_last = m_t;
+        while( res == fail )
+        {
+            res = try_step( system , get_current_state() , get_current_deriv() , m_t , get_old_state() , get_old_deriv() , m_dt );
+            m_first = false;
+            fail_checker();  // check for overflow of failed steps
+        }
+        toggle_current_state();
+        return std::make_pair( m_t_last , m_t );
+    }
+
+    /* performs the interpolation from a calculated step */
+    template< class StateOut >
+    void calc_state( time_type t , StateOut &x ) const
+    {
+        do_interpolation( t , x );
+    }
+
+    const state_type& current_state( void ) const
+    {
+        return get_current_state();
+    }
+
+    time_type current_time( void ) const
+    {
+        return m_t;
+    }
+
+    const state_type& previous_state( void ) const
+    {
+        return get_old_state();
+    }
+
+    time_type previous_time( void ) const
+    {
+        return m_t_last;
+    }
+
+    time_type current_time_step( void ) const
+    {
+        return m_dt;
+    }
+
+    /** \brief Resets the internal state of the stepper. */
+    void reset()
+    {
+        m_first = true;
+        m_last_step_rejected = false;
+    }
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_impl( x );
+        m_midpoint.adjust_size( x );
+    }
+
+
+private:
+
+    template< class StateInOut , class StateVector >
+    void extrapolate( size_t k , StateVector &table , const value_matrix &coeff , StateInOut &xest , size_t order_start_index = 0 )
+    //polynomial extrapolation, see http://www.nr.com/webnotes/nr3web21.pdf
+    {
+        static const value_type val1( 1.0 );
+        for( int j=k-1 ; j>0 ; --j )
+        {
+            m_algebra.for_each3( table[j-1].m_v , table[j].m_v , table[j-1].m_v ,
+                                 typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k + order_start_index][j + order_start_index] ,
+                                                                                                           -coeff[k + order_start_index][j + order_start_index] ) );
+        }
+        m_algebra.for_each3( xest , table[0].m_v , xest ,
+                             typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k + order_start_index][0 + order_start_index] ,
+                                                                                                       -coeff[k + order_start_index][0 + order_start_index]) );
+    }
+
+
+    template< class StateVector >
+    void extrapolate_dense_out( size_t k , StateVector &table , const value_matrix &coeff , size_t order_start_index = 0 )
+    //polynomial extrapolation, see http://www.nr.com/webnotes/nr3web21.pdf
+    {
+        // result is written into table[0]
+        static const value_type val1( 1.0 );
+        for( int j=k ; j>1 ; --j )
+        {
+            m_algebra.for_each3( table[j-1].m_v , table[j].m_v , table[j-1].m_v ,
+                                 typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k + order_start_index][j + order_start_index - 1] ,
+                                                                                                           -coeff[k + order_start_index][j + order_start_index - 1] ) );
+        }
+        m_algebra.for_each3( table[0].m_v , table[1].m_v , table[0].m_v ,
+                             typename operations_type::template scale_sum2< value_type , value_type >( val1 + coeff[k + order_start_index][order_start_index] ,
+                                                                                                       -coeff[k + order_start_index][order_start_index]) );
+    }
+
+    time_type calc_h_opt( time_type h , value_type error , size_t k ) const
+    {
+        BOOST_USING_STD_MIN();
+        BOOST_USING_STD_MAX();
+        using std::pow;
+
+        value_type expo = static_cast<value_type>(1)/(m_interval_sequence[k-1]);
+        value_type facmin = m_facmin_table[k];
+        value_type fac;
+        if (error == 0.0)
+            fac = static_cast<value_type>(1)/facmin;
+        else
+        {
+            fac = STEPFAC2 / pow BOOST_PREVENT_MACRO_SUBSTITUTION( error / STEPFAC1 , expo );
+            fac = max BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( facmin/STEPFAC4 ) , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>(static_cast<value_type>(1)/facmin) , fac ) );
+        }
+        return h*fac;
+    }
+
+    bool in_convergence_window( size_t k ) const
+    {
+        if( (k == m_current_k_opt-1) && !m_last_step_rejected )
+            return true; // decrease order only if last step was not rejected
+        return ( (k == m_current_k_opt) || (k == m_current_k_opt+1) );
+    }
+
+    bool should_reject( value_type error , size_t k ) const
+    {
+        if( k == m_current_k_opt-1 )
+        {
+            const value_type d = m_interval_sequence[m_current_k_opt] * m_interval_sequence[m_current_k_opt+1] /
+                (m_interval_sequence[0]*m_interval_sequence[0]);
+            //step will fail, criterion 17.3.17 in NR
+            return ( error > d*d );
+        }
+        else if( k == m_current_k_opt )
+        {
+            const value_type d = m_interval_sequence[m_current_k_opt+1] / m_interval_sequence[0];
+            return ( error > d*d );
+        } else
+            return error > 1.0;
+    }
+
+    template< class StateIn1 , class DerivIn1 , class StateIn2 , class DerivIn2 >
+    value_type prepare_dense_output( int k , const StateIn1 &x_start , const DerivIn1 &dxdt_start ,
+                                     const StateIn2 & /* x_end */ , const DerivIn2 & /*dxdt_end */ , time_type dt )  
+    /* k is the order to which the result was approximated */
+    {
+
+        /* compute the coefficients of the interpolation polynomial
+         * we parametrize the interval t .. t+dt by theta = -1 .. 1
+         * we use 2k+3 values at the interval center theta=0 to obtain the interpolation coefficients
+         * the values are x(t+dt/2) and the derivatives dx/dt , ... d^(2k+2) x / dt^(2k+2) at the midpoints
+         * the derivatives are approximated via finite differences
+         * all values are obtained from interpolation of the results from the increasing orders of the midpoint calls
+         */
+
+        // calculate finite difference approximations to derivatives at the midpoint
+        for( int j = 0 ; j<=k ; j++ )
+        {
+            /* not working with boost units... */
+            const value_type d = m_interval_sequence[j] / ( static_cast<value_type>(2) * dt );
+            value_type f = 1.0; //factor 1/2 here because our interpolation interval has length 2 !!!
+            for( int kappa = 0 ; kappa <= 2*j+1 ; ++kappa )
+            {
+                calculate_finite_difference( j , kappa , f , dxdt_start );
+                f *= d;
+            }
+
+            if( j > 0 )
+                extrapolate_dense_out( j , m_mp_states , m_coeff );
+        }
+
+        time_type d = dt/2;
+
+        // extrapolate finite differences
+        for( int kappa = 0 ; kappa<=2*k+1 ; kappa++ )
+        {
+            for( int j=1 ; j<=(k-kappa/2) ; ++j )
+                extrapolate_dense_out( j , m_diffs[kappa] , m_coeff , kappa/2 );
+
+            // extrapolation results are now stored in m_diffs[kappa][0]
+
+            // divide kappa-th derivative by kappa because we need these terms for dense output interpolation
+            m_algebra.for_each1( m_diffs[kappa][0].m_v , typename operations_type::template scale< time_type >( static_cast<time_type>(d) ) );
+
+            d *= dt/(2*(kappa+2));
+        }
+
+        // dense output coefficients a_0 is stored in m_mp_states[0], a_i for i = 1...2k are stored in m_diffs[i-1][0]
+
+        // the error is just the highest order coefficient of the interpolation polynomial
+        // this is because we use only the midpoint theta=0 as support for the interpolation (remember that theta = -1 .. 1)
+
+        value_type error = 0.0;
+        if( m_control_interpolation )
+        {
+            boost::numeric::odeint::copy( m_diffs[2*k+1][0].m_v , m_err.m_v );
+            error = m_error_checker.error( m_algebra , x_start , dxdt_start , m_err.m_v , dt );
+        }
+
+        return error;
+    }
+
+    template< class DerivIn >
+    void calculate_finite_difference( size_t j , size_t kappa , value_type fac , const DerivIn &dxdt )
+    {
+        const int m = m_interval_sequence[j]/2-1;
+        if( kappa == 0) // no calculation required for 0th derivative of f
+        {
+            m_algebra.for_each2( m_diffs[0][j].m_v , m_derivs[j][m].m_v ,
+                                 typename operations_type::template scale_sum1< value_type >( fac ) );
+        }
+        else
+        {
+            // calculate the index of m_diffs for this kappa-j-combination
+            const int j_diffs = j - kappa/2;
+
+            m_algebra.for_each2( m_diffs[kappa][j_diffs].m_v , m_derivs[j][m+kappa].m_v ,
+                                 typename operations_type::template scale_sum1< value_type >( fac ) );
+            value_type sign = -1.0;
+            int c = 1;
+            //computes the j-th order finite difference for the kappa-th derivative of f at t+dt/2 using function evaluations stored in m_derivs
+            for( int i = m+static_cast<int>(kappa)-2 ; i >= m-static_cast<int>(kappa) ; i -= 2 )
+            {
+                if( i >= 0 )
+                {
+                    m_algebra.for_each3( m_diffs[kappa][j_diffs].m_v , m_diffs[kappa][j_diffs].m_v , m_derivs[j][i].m_v ,
+                                         typename operations_type::template scale_sum2< value_type , value_type >( 1.0 ,
+                                                                                                                   sign * fac * boost::math::binomial_coefficient< value_type >( kappa , c ) ) );
+                }
+                else
+                {
+                    m_algebra.for_each3( m_diffs[kappa][j_diffs].m_v , m_diffs[kappa][j_diffs].m_v , dxdt ,
+                                         typename operations_type::template scale_sum2< value_type , value_type >( 1.0 , sign * fac ) );
+                }
+                sign *= -1;
+                ++c;
+            }
+        }
+    }
+
+    template< class StateOut >
+    void do_interpolation( time_type t , StateOut &out ) const
+    {
+        // interpolation polynomial is defined for theta = -1 ... 1
+        // m_k_final is the number of order-iterations done for the last step - it governs the order of the interpolation polynomial
+        const value_type theta = 2 * get_unit_value( (t - m_t_last) / (m_t - m_t_last) ) - 1;
+        // we use only values at interval center, that is theta=0, for interpolation
+        // our interpolation polynomial is thus of order 2k+2, hence we have 2k+3 terms
+
+        boost::numeric::odeint::copy( m_mp_states[0].m_v , out );
+        // add remaining terms: x += a_1 theta + a2 theta^2 + ... + a_{2k} theta^{2k}
+        value_type theta_pow( theta );
+        for( size_t i=0 ; i<=2*m_k_final+1 ; ++i )
+        {
+            m_algebra.for_each3( out , out , m_diffs[i][0].m_v ,
+                                 typename operations_type::template scale_sum2< value_type >( static_cast<value_type>(1) , theta_pow ) );
+            theta_pow *= theta;
+        }
+    }
+
+    /* Resizer methods */
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized( false );
+
+        resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxdt1 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxdt2 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_err , x , typename is_resizeable<state_type>::type() );
+
+        for( size_t i = 0 ; i < m_k_max ; ++i )
+            resized |= adjust_size_by_resizeability( m_table[i] , x , typename is_resizeable<state_type>::type() );
+        for( size_t i = 0 ; i < m_k_max+1 ; ++i )
+            resized |= adjust_size_by_resizeability( m_mp_states[i] , x , typename is_resizeable<state_type>::type() );
+        for( size_t i = 0 ; i < m_k_max+1 ; ++i )
+            for( size_t j = 0 ; j < m_derivs[i].size() ; ++j )
+                resized |= adjust_size_by_resizeability( m_derivs[i][j] , x , typename is_resizeable<deriv_type>::type() );
+        for( size_t i = 0 ; i < 2*m_k_max+2 ; ++i )
+            for( size_t j = 0 ; j < m_diffs[i].size() ; ++j )
+                resized |= adjust_size_by_resizeability( m_diffs[i][j] , x , typename is_resizeable<deriv_type>::type() );
+
+        return resized;
+    }
+
+
+    state_type& get_current_state( void )
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    const state_type& get_current_state( void ) const
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    state_type& get_old_state( void )
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+    
+    const state_type& get_old_state( void ) const
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+
+    deriv_type& get_current_deriv( void )
+    {
+        return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ;
+    }
+    
+    const deriv_type& get_current_deriv( void ) const
+    {
+        return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ;
+    }
+    
+    deriv_type& get_old_deriv( void )
+    {
+        return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ;
+    }
+    
+    const deriv_type& get_old_deriv( void ) const
+    {
+        return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ;
+    }
+
+    
+    void toggle_current_state( void )
+    {
+        m_current_state_x1 = ! m_current_state_x1;
+    }
+
+
+
+    default_error_checker< value_type, algebra_type , operations_type > m_error_checker;
+    modified_midpoint_dense_out< state_type , value_type , deriv_type , time_type , algebra_type , operations_type , resizer_type > m_midpoint;
+
+    time_type m_max_dt;
+
+    bool m_control_interpolation;
+
+    bool m_last_step_rejected;
+    bool m_first;
+
+    time_type m_t;
+    time_type m_dt;
+    time_type m_dt_last;
+    time_type m_t_last;
+
+    size_t m_current_k_opt;
+    size_t m_k_final;
+
+    algebra_type m_algebra;
+
+    resizer_type m_resizer;
+
+    wrapped_state_type m_x1 , m_x2;
+    wrapped_deriv_type m_dxdt1 , m_dxdt2;
+    wrapped_state_type m_err;
+    bool m_current_state_x1;
+
+
+
+    value_vector m_error; // errors of repeated midpoint steps and extrapolations
+    int_vector m_interval_sequence; // stores the successive interval counts
+    value_matrix m_coeff;
+    int_vector m_cost; // costs for interval count
+    value_vector m_facmin_table; // for precomputed facmin to save pow calls
+
+    state_vector_type m_table; // sequence of states for extrapolation
+
+    //for dense output:
+    state_vector_type m_mp_states; // sequence of approximations of x at distance center
+    deriv_table_type m_derivs; // table of function values
+    deriv_table_type m_diffs; // table of function values
+
+    //wrapped_state_type m_a1 , m_a2 , m_a3 , m_a4;
+
+    value_type STEPFAC1 , STEPFAC2 , STEPFAC3 , STEPFAC4 , KFAC1 , KFAC2;
+};
+
+
+
+/********** DOXYGEN **********/
+
+/**
+ * \class bulirsch_stoer_dense_out
+ * \brief The Bulirsch-Stoer algorithm.
+ * 
+ * The Bulirsch-Stoer is a controlled stepper that adjusts both step size
+ * and order of the method. The algorithm uses the modified midpoint and
+ * a polynomial extrapolation compute the solution. This class also provides
+ * dense output facility.
+ *
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::bulirsch_stoer_dense_out( value_type eps_abs , value_type eps_rel , value_type factor_x , value_type factor_dxdt , bool control_interpolation )
+     * \brief Constructs the bulirsch_stoer class, including initialization of 
+     * the error bounds.
+     *
+     * \param eps_abs Absolute tolerance level.
+     * \param eps_rel Relative tolerance level.
+     * \param factor_x Factor for the weight of the state.
+     * \param factor_dxdt Factor for the weight of the derivative.
+     * \param control_interpolation Set true to additionally control the error of 
+     * the interpolation.
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , DerivOut &dxdt_new , time_type &dt )
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed. Also, the internal order of the stepper is adjusted if required.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. 
+     * It must fulfill the Simple System concept.
+     * \param in The state of the ODE which should be solved.
+     * \param dxdt The derivative of state.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param out Used to store the result of the step.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::initialize( const StateType &x0 , const time_type &t0 , const time_type &dt0 )
+     * \brief Initializes the dense output stepper.
+     *
+     * \param x0 The initial state.
+     * \param t0 The initial time.
+     * \param dt0 The initial time step.
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::do_step( System system )
+     * \brief Does one time step. This is the main method that should be used to 
+     * integrate an ODE with this stepper.
+     * \note initialize has to be called before using this method to set the
+     * initial conditions x,t and the stepsize.
+     * \param system The system function to solve, hence the r.h.s. of the
+     * ordinary differential equation. It must fulfill the Simple System concept.
+     * \return Pair with start and end time of the integration step.
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::calc_state( time_type t , StateOut &x ) const
+     * \brief Calculates the solution at an intermediate point within the last step
+     * \param t The time at which the solution should be calculated, has to be
+     * in the current time interval.
+     * \param x The output variable where the result is written into.
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::current_state( void ) const
+     * \brief Returns the current state of the solution.
+     * \return The current state of the solution x(t).
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::current_time( void ) const
+     * \brief Returns the current time of the solution.
+     * \return The current time of the solution t.
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::previous_state( void ) const
+     * \brief Returns the last state of the solution.
+     * \return The last state of the solution x(t-dt).
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::previous_time( void ) const
+     * \brief Returns the last time of the solution.
+     * \return The last time of the solution t-dt.
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::current_time_step( void ) const
+     * \brief Returns the current step size.
+     * \return The current step size.
+     */
+
+    /**
+     * \fn bulirsch_stoer_dense_out::adjust_size( const StateIn &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+}
+}
+}
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_BULIRSCH_STOER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp b/include/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
new file mode 100644
index 0000000..aac2b02
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
@@ -0,0 +1,1014 @@
+/* [auto_generated]
+ boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
+
+ [begin_description]
+ The default controlled stepper which can be used with all explicit Runge-Kutta error steppers.
+ [end_description]
+
+ Copyright 2010-2013 Karsten Ahnert
+ Copyright 2010-2015 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED
+
+
+
+#include <cmath>
+
+#include <boost/config.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template
+<
+class Value ,
+class Algebra ,
+class Operations
+>
+class default_error_checker
+{
+public:
+
+    typedef Value value_type;
+    typedef Algebra algebra_type;
+    typedef Operations operations_type;
+
+    default_error_checker(
+            value_type eps_abs = static_cast< value_type >( 1.0e-6 ) ,
+            value_type eps_rel = static_cast< value_type >( 1.0e-6 ) ,
+            value_type a_x = static_cast< value_type >( 1 ) ,
+            value_type a_dxdt = static_cast< value_type >( 1 ))
+        : m_eps_abs( eps_abs ) , m_eps_rel( eps_rel ) , m_a_x( a_x ) , m_a_dxdt( a_dxdt )
+    { }
+
+
+    template< class State , class Deriv , class Err, class Time >
+    value_type error( const State &x_old , const Deriv &dxdt_old , Err &x_err , Time dt ) const
+    {
+        return error( algebra_type() , x_old , dxdt_old , x_err , dt );
+    }
+
+    template< class State , class Deriv , class Err, class Time >
+    value_type error( algebra_type &algebra , const State &x_old , const Deriv &dxdt_old , Err &x_err , Time dt ) const
+    {
+        using std::abs;
+        // this overwrites x_err !
+        algebra.for_each3( x_err , x_old , dxdt_old ,
+                typename operations_type::template rel_error< value_type >( m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt * abs(get_unit_value( dt )) ) );
+
+        // value_type res = algebra.reduce( x_err ,
+        //        typename operations_type::template maximum< value_type >() , static_cast< value_type >( 0 ) );
+        return algebra.norm_inf( x_err );
+    }
+
+private:
+
+    value_type m_eps_abs;
+    value_type m_eps_rel;
+    value_type m_a_x;
+    value_type m_a_dxdt;
+
+};
+
+
+template< typename Value, typename Time >
+class default_step_adjuster
+{
+public:
+    typedef Time time_type;
+    typedef Value value_type;
+
+    default_step_adjuster(const time_type max_dt=static_cast<time_type>(0))
+            : m_max_dt(max_dt)
+    {}
+
+
+    time_type decrease_step(time_type dt, const value_type error, const int error_order) const
+    {
+        // returns the decreased time step
+        BOOST_USING_STD_MIN();
+        BOOST_USING_STD_MAX();
+        using std::pow;
+
+        dt *= max
+        BOOST_PREVENT_MACRO_SUBSTITUTION(
+                static_cast<value_type>( static_cast<value_type>(9) / static_cast<value_type>(10) *
+                                         pow(error, static_cast<value_type>(-1) / (error_order - 1))),
+                static_cast<value_type>( static_cast<value_type>(1) / static_cast<value_type> (5)));
+        if(m_max_dt != static_cast<time_type >(0))
+            // limit to maximal stepsize even when decreasing
+            dt = detail::min_abs(dt, m_max_dt);
+        return dt;
+    }
+
+    time_type increase_step(time_type dt, value_type error, const int stepper_order) const
+    {
+        // returns the increased time step
+        BOOST_USING_STD_MIN();
+        BOOST_USING_STD_MAX();
+        using std::pow;
+
+        // adjust the size if dt is smaller than max_dt (providede max_dt is not zero)
+        if(error < 0.5)
+        {
+            // error should be > 0
+            error = max BOOST_PREVENT_MACRO_SUBSTITUTION (
+                    static_cast<value_type>( pow( static_cast<value_type>(5.0) , -static_cast<value_type>(stepper_order) ) ) ,
+                    error);
+            // time_type dt_old = dt;   unused variable warning 
+            //error too small - increase dt and keep the evolution and limit scaling factor to 5.0
+            dt *= static_cast<value_type>(9)/static_cast<value_type>(10) *
+                  pow(error, static_cast<value_type>(-1) / stepper_order);
+            if(m_max_dt != static_cast<time_type >(0))
+                // limit to maximal stepsize
+                dt = detail::min_abs(dt, m_max_dt);
+        }
+        return dt;
+    }
+
+    bool check_step_size_limit(const time_type dt)
+    {
+        if(m_max_dt != static_cast<time_type >(0))
+            return detail::less_eq_with_sign(dt, m_max_dt, dt);
+        return true;
+    }
+
+    time_type get_max_dt() { return m_max_dt; }
+
+private:
+    time_type m_max_dt;
+};
+
+
+
+/*
+ * error stepper category dispatcher
+ */
+template<
+class ErrorStepper ,
+class ErrorChecker = default_error_checker< typename ErrorStepper::value_type ,
+    typename ErrorStepper::algebra_type ,
+    typename ErrorStepper::operations_type > ,
+class StepAdjuster = default_step_adjuster< typename ErrorStepper::value_type ,
+    typename ErrorStepper::time_type > ,
+class Resizer = typename ErrorStepper::resizer_type ,
+class ErrorStepperCategory = typename ErrorStepper::stepper_category
+>
+class controlled_runge_kutta ;
+
+
+
+/*
+ * explicit stepper version
+ *
+ * this class introduces the following try_step overloads
+    * try_step( sys , x , t , dt )
+    * try_step( sys , x , dxdt , t , dt )
+    * try_step( sys , in , t , out , dt )
+    * try_step( sys , in , dxdt , t , out , dt )
+ */
+/**
+ * \brief Implements step size control for Runge-Kutta steppers with error 
+ * estimation.
+ *
+ * This class implements the step size control for standard Runge-Kutta 
+ * steppers with error estimation.
+ *
+ * \tparam ErrorStepper The stepper type with error estimation, has to fulfill the ErrorStepper concept.
+ * \tparam ErrorChecker The error checker
+ * \tparam Resizer The resizer policy type.
+ */
+template<
+class ErrorStepper,
+class ErrorChecker,
+class StepAdjuster,
+class Resizer
+>
+class controlled_runge_kutta< ErrorStepper , ErrorChecker , StepAdjuster, Resizer ,
+        explicit_error_stepper_tag >
+{
+
+public:
+
+    typedef ErrorStepper stepper_type;
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef typename stepper_type::algebra_type algebra_type;
+    typedef typename stepper_type::operations_type operations_type;
+    typedef Resizer resizer_type;
+    typedef ErrorChecker error_checker_type;
+    typedef StepAdjuster step_adjuster_type;
+    typedef explicit_controlled_stepper_tag stepper_category;
+
+#ifndef DOXYGEN_SKIP
+    typedef typename stepper_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type;
+
+    typedef controlled_runge_kutta< ErrorStepper , ErrorChecker , StepAdjuster ,
+            Resizer , explicit_error_stepper_tag > controlled_stepper_type;
+#endif //DOXYGEN_SKIP
+
+
+    /**
+     * \brief Constructs the controlled Runge-Kutta stepper.
+     * \param error_checker An instance of the error checker.
+     * \param stepper An instance of the underlying stepper.
+     */
+    controlled_runge_kutta(
+            const error_checker_type &error_checker = error_checker_type( ) ,
+            const step_adjuster_type &step_adjuster = step_adjuster_type() ,
+            const stepper_type &stepper = stepper_type( )
+    )
+        : m_stepper(stepper), m_error_checker(error_checker) , m_step_adjuster(step_adjuster)
+    { }
+
+
+
+    /*
+     * Version 1 : try_step( sys , x , t , dt )
+     *
+     * The overloads are needed to solve the forwarding problem
+     */
+    /**
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. Overwritten if 
+     * the step is successful.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateInOut >
+    controlled_step_result try_step( System system , StateInOut &x , time_type &t , time_type &dt )
+    {
+        return try_step_v1( system , x , t, dt );
+    }
+
+    /**
+     * \brief Tries to perform one step. Solves the forwarding problem and 
+     * allows for using boost range as state_type.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. Overwritten if 
+     * the step is successful. Can be a boost range.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateInOut >
+    controlled_step_result try_step( System system , const StateInOut &x , time_type &t , time_type &dt )
+    {
+        return try_step_v1( system , x , t, dt );
+    }
+
+
+
+    /*
+     * Version 2 : try_step( sys , x , dxdt , t , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    /**
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. Overwritten if 
+     * the step is successful.
+     * \param dxdt The derivative of state.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateInOut , class DerivIn >
+    controlled_step_result try_step( System system , StateInOut &x , const DerivIn &dxdt , time_type &t , time_type &dt )
+    {
+        m_xnew_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_xnew_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
+        controlled_step_result res = try_step( system , x , dxdt , t , m_xnew.m_v , dt );
+        if( res == success )
+        {
+            boost::numeric::odeint::copy( m_xnew.m_v , x );
+        }
+        return res;
+    }
+
+    /*
+     * Version 3 : try_step( sys , in , t , out , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     *
+     * the disable is needed to avoid ambiguous overloads if state_type = time_type
+     */
+    /**
+     * \brief Tries to perform one step.
+     *
+     * \note This method is disabled if state_type=time_type to avoid ambiguity.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param out Used to store the result of the step.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateIn , class StateOut >
+    typename boost::disable_if< boost::is_same< StateIn , time_type > , controlled_step_result >::type
+    try_step( System system , const StateIn &in , time_type &t , StateOut &out , time_type &dt )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_dxdt_resizer.adjust_size( in , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_impl< StateIn > , detail::ref( *this ) , detail::_1 ) );
+        sys( in , m_dxdt.m_v , t );
+        return try_step( system , in , m_dxdt.m_v , t , out , dt );
+    }
+
+
+    /*
+     * Version 4 : try_step( sys , in , dxdt , t , out , dt )
+     *
+     * this version does not solve the forwarding problem, boost.range can not be used
+     */
+    /**
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved.
+     * \param dxdt The derivative of state.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param out Used to store the result of the step.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    controlled_step_result try_step( System system , const StateIn &in , const DerivIn &dxdt , time_type &t , StateOut &out , time_type &dt )
+    {
+        if( !m_step_adjuster.check_step_size_limit(dt) )
+        {
+            // given dt was above step size limit - adjust and return fail;
+            dt = m_step_adjuster.get_max_dt();
+            return fail;
+        }
+
+        m_xerr_resizer.adjust_size( in , detail::bind( &controlled_runge_kutta::template resize_m_xerr_impl< StateIn > , detail::ref( *this ) , detail::_1 ) );
+
+        // do one step with error calculation
+        m_stepper.do_step( system , in , dxdt , t , out , dt , m_xerr.m_v );
+
+        value_type max_rel_err = m_error_checker.error( m_stepper.algebra() , in , dxdt , m_xerr.m_v , dt );
+
+        if( max_rel_err > 1.0 )
+        {
+            // error too big, decrease step size and reject this step
+            dt = m_step_adjuster.decrease_step(dt, max_rel_err, m_stepper.error_order());
+            return fail;
+        } else
+        {
+            // otherwise, increase step size and accept
+            t += dt;
+            dt = m_step_adjuster.increase_step(dt, max_rel_err, m_stepper.stepper_order());
+            return success;
+        }
+    }
+
+    /**
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_m_xerr_impl( x );
+        resize_m_dxdt_impl( x );
+        resize_m_xnew_impl( x );
+        m_stepper.adjust_size( x );
+    }
+
+    /**
+     * \brief Returns the instance of the underlying stepper.
+     * \returns The instance of the underlying stepper.
+     */
+    stepper_type& stepper( void )
+    {
+        return m_stepper;
+    }
+
+    /**
+     * \brief Returns the instance of the underlying stepper.
+     * \returns The instance of the underlying stepper.
+     */
+    const stepper_type& stepper( void ) const
+    {
+        return m_stepper;
+    }
+
+private:
+
+
+    template< class System , class StateInOut >
+    controlled_step_result try_step_v1( System system , StateInOut &x , time_type &t , time_type &dt )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        m_dxdt_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
+        sys( x , m_dxdt.m_v ,t );
+        return try_step( system , x , m_dxdt.m_v , t , dt );
+    }
+
+    template< class StateIn >
+    bool resize_m_xerr_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_xerr , x , typename is_resizeable<state_type>::type() );
+    }
+
+    template< class StateIn >
+    bool resize_m_dxdt_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+    }
+
+    template< class StateIn >
+    bool resize_m_xnew_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_xnew , x , typename is_resizeable<state_type>::type() );
+    }
+
+
+
+    stepper_type m_stepper;
+    error_checker_type m_error_checker;
+    step_adjuster_type m_step_adjuster;
+
+    resizer_type m_dxdt_resizer;
+    resizer_type m_xerr_resizer;
+    resizer_type m_xnew_resizer;
+
+    wrapped_deriv_type m_dxdt;
+    wrapped_state_type m_xerr;
+    wrapped_state_type m_xnew;
+};
+
+
+
+
+
+
+
+
+
+
+/*
+ * explicit stepper fsal version
+ *
+ * the class introduces the following try_step overloads
+    * try_step( sys , x , t , dt ) 
+    * try_step( sys , in , t , out , dt )
+    * try_step( sys , x , dxdt , t , dt )
+    * try_step( sys , in , dxdt_in , t , out , dxdt_out , dt )
+ */
+/**
+ * \brief Implements step size control for Runge-Kutta FSAL steppers with 
+ * error estimation.
+ *
+ * This class implements the step size control for FSAL Runge-Kutta 
+ * steppers with error estimation.
+ *
+ * \tparam ErrorStepper The stepper type with error estimation, has to fulfill the ErrorStepper concept.
+ * \tparam ErrorChecker The error checker
+ * \tparam Resizer The resizer policy type.
+ */
+template<
+class ErrorStepper ,
+class ErrorChecker ,
+class StepAdjuster ,
+class Resizer
+>
+class controlled_runge_kutta< ErrorStepper , ErrorChecker , StepAdjuster , Resizer , explicit_error_stepper_fsal_tag >
+{
+
+public:
+
+    typedef ErrorStepper stepper_type;
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef typename stepper_type::algebra_type algebra_type;
+    typedef typename stepper_type::operations_type operations_type;
+    typedef Resizer resizer_type;
+    typedef ErrorChecker error_checker_type;
+    typedef StepAdjuster step_adjuster_type;
+    typedef explicit_controlled_stepper_fsal_tag stepper_category;
+
+#ifndef DOXYGEN_SKIP
+    typedef typename stepper_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type;
+
+    typedef controlled_runge_kutta< ErrorStepper , ErrorChecker , StepAdjuster , Resizer , explicit_error_stepper_tag > controlled_stepper_type;
+#endif // DOXYGEN_SKIP
+
+    /**
+     * \brief Constructs the controlled Runge-Kutta stepper.
+     * \param error_checker An instance of the error checker.
+     * \param stepper An instance of the underlying stepper.
+     */
+    controlled_runge_kutta(
+            const error_checker_type &error_checker = error_checker_type() ,
+            const step_adjuster_type &step_adjuster = step_adjuster_type() ,
+            const stepper_type &stepper = stepper_type()
+    )
+    : m_stepper( stepper ) , m_error_checker( error_checker ) , m_step_adjuster(step_adjuster) ,
+      m_first_call( true )
+    { }
+
+    /*
+     * Version 1 : try_step( sys , x , t , dt )
+     *
+     * The two overloads are needed in order to solve the forwarding problem
+     */
+    /**
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. Overwritten if 
+     * the step is successful.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateInOut >
+    controlled_step_result try_step( System system , StateInOut &x , time_type &t , time_type &dt )
+    {
+        return try_step_v1( system , x , t , dt );
+    }
+
+
+    /**
+     * \brief Tries to perform one step. Solves the forwarding problem and 
+     * allows for using boost range as state_type.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. Overwritten if 
+     * the step is successful. Can be a boost range.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateInOut >
+    controlled_step_result try_step( System system , const StateInOut &x , time_type &t , time_type &dt )
+    {
+        return try_step_v1( system , x , t , dt );
+    }
+
+
+
+    /*
+     * Version 2 : try_step( sys , in , t , out , dt );
+     *
+     * This version does not solve the forwarding problem, boost::range can not be used.
+     * 
+     * The disabler is needed to solve ambiguous overloads
+     */
+    /**
+     * \brief Tries to perform one step.
+     *
+     * \note This method is disabled if state_type=time_type to avoid ambiguity.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param out Used to store the result of the step.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateIn , class StateOut >
+    typename boost::disable_if< boost::is_same< StateIn , time_type > , controlled_step_result >::type
+    try_step( System system , const StateIn &in , time_type &t , StateOut &out , time_type &dt )
+    {
+        if( m_dxdt_resizer.adjust_size( in , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_impl< StateIn > , detail::ref( *this ) , detail::_1 ) ) || m_first_call )
+        {
+            initialize( system , in , t );
+        }
+        return try_step( system , in , m_dxdt.m_v , t , out , dt );
+    }
+
+
+    /*
+     * Version 3 : try_step( sys , x , dxdt , t , dt )
+     *
+     * This version does not solve the forwarding problem, boost::range can not be used.
+     */
+    /**
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The state of the ODE which should be solved. Overwritten if 
+     * the step is successful.
+     * \param dxdt The derivative of state.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateInOut , class DerivInOut >
+    controlled_step_result try_step( System system , StateInOut &x , DerivInOut &dxdt , time_type &t , time_type &dt )
+    {
+        m_xnew_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_xnew_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
+        m_dxdt_new_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_new_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
+        controlled_step_result res = try_step( system , x , dxdt , t , m_xnew.m_v , m_dxdtnew.m_v , dt );
+        if( res == success )
+        {
+            boost::numeric::odeint::copy( m_xnew.m_v , x );
+            boost::numeric::odeint::copy( m_dxdtnew.m_v , dxdt );
+        }
+        return res;
+    }
+
+
+    /*
+     * Version 4 : try_step( sys , in , dxdt_in , t , out , dxdt_out , dt )
+     *
+     * This version does not solve the forwarding problem, boost::range can not be used.
+     */
+    /**
+     * \brief Tries to perform one step.
+     *
+     * This method tries to do one step with step size dt. If the error estimate
+     * is to large, the step is rejected and the method returns fail and the 
+     * step size dt is reduced. If the error estimate is acceptably small, the
+     * step is performed, success is returned and dt might be increased to make 
+     * the steps as large as possible. This method also updates t if a step is
+     * performed.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved.
+     * \param dxdt The derivative of state.
+     * \param t The value of the time. Updated if the step is successful.
+     * \param out Used to store the result of the step.
+     * \param dt The step size. Updated.
+     * \return success if the step was accepted, fail otherwise.
+     */
+    template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut >
+    controlled_step_result try_step( System system , const StateIn &in , const DerivIn &dxdt_in , time_type &t ,
+            StateOut &out , DerivOut &dxdt_out , time_type &dt )
+    {
+        if( !m_step_adjuster.check_step_size_limit(dt) )
+        {
+            // given dt was above step size limit - adjust and return fail;
+            dt = m_step_adjuster.get_max_dt();
+            return fail;
+        }
+
+        m_xerr_resizer.adjust_size( in , detail::bind( &controlled_runge_kutta::template resize_m_xerr_impl< StateIn > , detail::ref( *this ) , detail::_1 ) );
+
+        //fsal: m_stepper.get_dxdt( dxdt );
+        //fsal: m_stepper.do_step( sys , x , dxdt , t , dt , m_x_err );
+        m_stepper.do_step( system , in , dxdt_in , t , out , dxdt_out , dt , m_xerr.m_v );
+
+        // this potentially overwrites m_x_err! (standard_error_checker does, at least)
+        value_type max_rel_err = m_error_checker.error( m_stepper.algebra() , in , dxdt_in , m_xerr.m_v , dt );
+
+        if( max_rel_err > 1.0 )
+        {
+            // error too big, decrease step size and reject this step
+            dt = m_step_adjuster.decrease_step(dt, max_rel_err, m_stepper.error_order());
+            return fail;
+        }
+        // otherwise, increase step size and accept
+        t += dt;
+        dt = m_step_adjuster.increase_step(dt, max_rel_err, m_stepper.stepper_order());
+        return success;
+    }
+
+
+    /**
+     * \brief Resets the internal state of the underlying FSAL stepper.
+     */
+    void reset( void )
+    {
+        m_first_call = true;
+    }
+
+    /**
+     * \brief Initializes the internal state storing an internal copy of the derivative.
+     *
+     * \param deriv The initial derivative of the ODE.
+     */
+    template< class DerivIn >
+    void initialize( const DerivIn &deriv )
+    {
+        boost::numeric::odeint::copy( deriv , m_dxdt.m_v );
+        m_first_call = false;
+    }
+
+    /**
+     * \brief Initializes the internal state storing an internal copy of the derivative.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param x The initial state of the ODE which should be solved.
+     * \param t The initial time.
+     */
+    template< class System , class StateIn >
+    void initialize( System system , const StateIn &x , time_type t )
+    {
+        typename odeint::unwrap_reference< System >::type &sys = system;
+        sys( x , m_dxdt.m_v , t );
+        m_first_call = false;
+    }
+
+    /**
+     * \brief Returns true if the stepper has been initialized, false otherwise.
+     *
+     * \return true, if the stepper has been initialized, false otherwise.
+     */
+    bool is_initialized( void ) const
+    {
+        return ! m_first_call;
+    }
+
+
+    /**
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_m_xerr_impl( x );
+        resize_m_dxdt_impl( x );
+        resize_m_dxdt_new_impl( x );
+        resize_m_xnew_impl( x );
+    }
+
+
+    /**
+     * \brief Returns the instance of the underlying stepper.
+     * \returns The instance of the underlying stepper.
+     */
+    stepper_type& stepper( void )
+    {
+        return m_stepper;
+    }
+
+    /**
+     * \brief Returns the instance of the underlying stepper.
+     * \returns The instance of the underlying stepper.
+     */
+    const stepper_type& stepper( void ) const
+    {
+        return m_stepper;
+    }
+
+
+
+private:
+
+
+    template< class StateIn >
+    bool resize_m_xerr_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_xerr , x , typename is_resizeable<state_type>::type() );
+    }
+
+    template< class StateIn >
+    bool resize_m_dxdt_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+    }
+
+    template< class StateIn >
+    bool resize_m_dxdt_new_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dxdtnew , x , typename is_resizeable<deriv_type>::type() );
+    }
+
+    template< class StateIn >
+    bool resize_m_xnew_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_xnew , x , typename is_resizeable<state_type>::type() );
+    }
+
+
+    template< class System , class StateInOut >
+    controlled_step_result try_step_v1( System system , StateInOut &x , time_type &t , time_type &dt )
+    {
+        if( m_dxdt_resizer.adjust_size( x , detail::bind( &controlled_runge_kutta::template resize_m_dxdt_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) ) || m_first_call )
+        {
+            initialize( system , x , t );
+        }
+        return try_step( system , x , m_dxdt.m_v , t , dt );
+    }
+
+
+    stepper_type m_stepper;
+    error_checker_type m_error_checker;
+    step_adjuster_type m_step_adjuster;
+
+    resizer_type m_dxdt_resizer;
+    resizer_type m_xerr_resizer;
+    resizer_type m_xnew_resizer;
+    resizer_type m_dxdt_new_resizer;
+
+    wrapped_deriv_type m_dxdt;
+    wrapped_state_type m_xerr;
+    wrapped_state_type m_xnew;
+    wrapped_deriv_type m_dxdtnew;
+    bool m_first_call;
+};
+
+
+/********** DOXYGEN **********/
+
+/**** DEFAULT ERROR CHECKER ****/
+
+/**
+ * \class default_error_checker
+ * \brief The default error checker to be used with Runge-Kutta error steppers
+ *
+ * This class provides the default mechanism to compare the error estimates 
+ * reported by Runge-Kutta error steppers with user defined error bounds.
+ * It is used by the controlled_runge_kutta steppers.
+ *
+ * \tparam Value The value type.
+ * \tparam Time The time type.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ */
+
+    /**
+     * \fn default_error_checker( value_type eps_abs , value_type eps_rel , value_type a_x , value_type a_dxdt ,
+     * time_type max_dt)
+     * \brief Constructs the error checker.
+     *
+     * The error is calculated as follows: ???? 
+     *
+     * \param eps_abs Absolute tolerance level.
+     * \param eps_rel Relative tolerance level.
+     * \param a_x Factor for the weight of the state.
+     * \param a_dxdt Factor for the weight of the derivative.
+     * \param max_dt Maximum allowed step size.
+     */
+    
+    /**
+     * \fn error( const State &x_old , const Deriv &dxdt_old , Err &x_err , time_type dt ) const
+     * \brief Calculates the error level.
+     *
+     * If the returned error level is greater than 1, the estimated error was
+     * larger than the permitted error bounds and the step should be repeated
+     * with a smaller step size.
+     *
+     * \param x_old State at the beginning of the step.
+     * \param dxdt_old Derivative at the beginning of the step.
+     * \param x_err Error estimate.
+     * \param dt Time step.
+     * \return error
+     */
+
+    /**
+     * \fn error( algebra_type &algebra , const State &x_old , const Deriv &dxdt_old , Err &x_err , time_type dt ) const
+     * \brief Calculates the error level using a given algebra.
+     *
+     * If the returned error level is greater than 1, the estimated error was
+     * larger than the permitted error bounds and the step should be repeated
+     * with a smaller step size.
+     *
+     * \param algebra The algebra used for calculation of the error.
+     * \param x_old State at the beginning of the step.
+     * \param dxdt_old Derivative at the beginning of the step.
+     * \param x_err Error estimate.
+     * \param dt Time step.
+     * \return error
+     */
+
+    /**
+     * \fn time_type decrease_step(const time_type dt, const value_type error, const int error_order)
+     * \brief Returns a decreased step size based on the given error and order
+     *
+     * Calculates a new smaller step size based on the given error and its order.
+     *
+     * \param dt The old step size.
+     * \param error The computed error estimate.
+     * \param error_order The error order of the stepper.
+     * \return dt_new The new, reduced step size.
+     */
+
+    /**
+     * \fn time_type increase_step(const time_type dt, const value_type error, const int error_order)
+     * \brief Returns an increased step size based on the given error and order.
+     *
+     * Calculates a new bigger step size based on the given error and its order. If max_dt != 0, the
+     * new step size is limited to max_dt.
+     *
+     * \param dt The old step size.
+     * \param error The computed error estimate.
+     * \param error_order The order of the stepper.
+     * \return dt_new The new, increased step size.
+     */
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/controlled_step_result.hpp b/include/boost/numeric/odeint/stepper/controlled_step_result.hpp
new file mode 100644
index 0000000..7f17726
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/controlled_step_result.hpp
@@ -0,0 +1,42 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/controlled_step_result.hpp
+
+ [begin_description]
+ Defines the result type for all controlled stepper.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_STEP_RESULT_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_STEP_RESULT_HPP_INCLUDED
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/**
+ * \enum controlled_step_result
+ *
+ * \brief Enum representing the return values of the controlled steppers.
+ */
+typedef enum
+{
+    success , /**< The trial step was successful, hence the state and the time have been advanced. */
+    fail      /**< The step was not successful and might possibly be repeated with a small step size. */
+} controlled_step_result;
+
+} // namespace odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_CONTROLLED_STEP_RESULT_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp b/include/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
new file mode 100644
index 0000000..94abc5a
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
@@ -0,0 +1,476 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
+
+ [begin_description]
+ Implementation of the Dense-output stepper for all steppers. Note, that this class does
+ not computes the result but serves as an interface.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2015 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED
+
+
+#include <utility>
+#include <stdexcept>
+
+#include <boost/throw_exception.hpp>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/numeric/odeint/util/copy.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/integrate/max_step_checker.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class Stepper , class StepperCategory = typename Stepper::stepper_category >
+class dense_output_runge_kutta;
+
+
+/**
+ * \brief The class representing dense-output Runge-Kutta steppers.
+ * \note In this stepper, the initialize method has to be called before using
+ * the do_step method.
+ *
+ * The dense-output functionality allows to interpolate the solution between
+ * subsequent integration points using intermediate results obtained during the
+ * computation. This version works based on a normal stepper without step-size
+ * control. 
+ * 
+ *
+ * \tparam Stepper The stepper type of the underlying algorithm.
+ */
+template< class Stepper >
+class dense_output_runge_kutta< Stepper , stepper_tag >
+{
+
+public:
+
+    /*
+     * We do not need all typedefs.
+     */
+    typedef Stepper stepper_type;
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef typename stepper_type::algebra_type algebra_type;
+    typedef typename stepper_type::operations_type operations_type;
+    typedef typename stepper_type::resizer_type resizer_type;
+    typedef dense_output_stepper_tag stepper_category;
+    typedef dense_output_runge_kutta< Stepper > dense_output_stepper_type;
+
+
+    /**
+     * \brief Constructs the dense_output_runge_kutta class. An instance of the
+     * underlying stepper can be provided.
+     * \param stepper An instance of the underlying stepper.
+     */
+    dense_output_runge_kutta( const stepper_type &stepper = stepper_type() )
+    : m_stepper( stepper ) , m_resizer() ,
+      m_x1() , m_x2() , m_current_state_x1( true ) , 
+      m_t() , m_t_old() , m_dt()
+    { } 
+
+
+    /**
+     * \brief Initializes the stepper. Has to be called before do_step can be 
+     * used to set the initial conditions and the step size.
+     * \param x0 The initial state of the ODE which should be solved.
+     * \param t0 The initial time, at which the step should be performed.
+     * \param dt0 The step size.
+     */
+    template< class StateType >
+    void initialize( const StateType &x0 , time_type t0 , time_type dt0 )
+    {
+        m_resizer.adjust_size( x0 , detail::bind( &dense_output_stepper_type::template resize_impl< StateType > , detail::ref( *this ) , detail::_1 ) );
+        boost::numeric::odeint::copy( x0 , get_current_state() );
+        m_t = t0;
+        m_dt = dt0;
+    }
+
+    /**
+     * \brief Does one time step.
+     * \note initialize has to be called before using this method to set the
+     * initial conditions x,t and the stepsize.
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Simple System concept.
+     * \return Pair with start and end time of the integration step.
+     */
+    template< class System >
+    std::pair< time_type , time_type > do_step( System system )
+    {
+        m_stepper.do_step( system , get_current_state() , m_t , get_old_state() , m_dt );
+        m_t_old = m_t;
+        m_t += m_dt;
+        toggle_current_state();
+        return std::make_pair( m_t_old , m_dt );
+    }
+
+    /*
+     * The next two overloads are needed to solve the forwarding problem
+     */
+    
+    /**
+     * \brief Calculates the solution at an intermediate point.
+     * \param t The time at which the solution should be calculated, has to be
+     * in the current time interval.
+     * \param x The output variable where the result is written into.
+     */
+    template< class StateOut >
+    void calc_state( time_type t , StateOut &x ) const
+    {
+        if( t == current_time() )
+        {
+            boost::numeric::odeint::copy( get_current_state() , x );
+        }
+        m_stepper.calc_state( x , t , get_old_state() , m_t_old , get_current_state() , m_t );
+    }
+
+    /**
+     * \brief Calculates the solution at an intermediate point. Solves the forwarding problem
+     * \param t The time at which the solution should be calculated, has to be
+     * in the current time interval.
+     * \param x The output variable where the result is written into, can be a boost range.
+     */
+    template< class StateOut >
+    void calc_state( time_type t , const StateOut &x ) const
+    {
+        m_stepper.calc_state( x , t , get_old_state() , m_t_old , get_current_state() , m_t );
+    }
+
+    /**
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_impl( x );
+        m_stepper.stepper().resize( x );
+    }
+
+    /**
+     * \brief Returns the current state of the solution.
+     * \return The current state of the solution x(t).
+     */
+    const state_type& current_state( void ) const
+    {
+        return get_current_state();
+    }
+
+    /**
+     * \brief Returns the current time of the solution.
+     * \return The current time of the solution t.
+     */
+    time_type current_time( void ) const
+    {
+        return m_t;
+    }
+
+    /**
+     * \brief Returns the last state of the solution.
+     * \return The last state of the solution x(t-dt).
+     */
+    const state_type& previous_state( void ) const
+    {
+        return get_old_state();
+    }
+
+    /**
+     * \brief Returns the last time of the solution.
+     * \return The last time of the solution t-dt.
+     */
+    time_type previous_time( void ) const
+    {
+        return m_t_old;
+    }
+
+    /**
+     * \brief Returns the current time step.
+     * \return dt.
+     */
+    time_type current_time_step( void ) const
+    {
+        return m_dt;
+    }
+
+
+private:
+
+    state_type& get_current_state( void )
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    const state_type& get_current_state( void ) const
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    state_type& get_old_state( void )
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+    
+    const state_type& get_old_state( void ) const
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+    
+    void toggle_current_state( void )
+    {
+        m_current_state_x1 = ! m_current_state_x1;
+    }
+
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() );
+        return resized;
+    }
+
+
+    stepper_type m_stepper;
+    resizer_type m_resizer;
+    wrapped_state_type m_x1 , m_x2;
+    bool m_current_state_x1;    // if true, the current state is m_x1
+    time_type m_t , m_t_old , m_dt;
+
+};
+
+
+
+
+
+/**
+ * \brief The class representing dense-output Runge-Kutta steppers with FSAL property.
+ *
+ * The interface is the same as for dense_output_runge_kutta< Stepper , stepper_tag >.
+ * This class provides dense output functionality based on methods with step size controlled 
+ * 
+ *
+ * \tparam Stepper The stepper type of the underlying algorithm.
+ */
+template< class Stepper >
+class dense_output_runge_kutta< Stepper , explicit_controlled_stepper_fsal_tag >
+{
+public:
+
+    /*
+     * We do not need all typedefs.
+     */
+    typedef Stepper controlled_stepper_type;
+
+    typedef typename controlled_stepper_type::stepper_type stepper_type;
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef typename stepper_type::algebra_type algebra_type;
+    typedef typename stepper_type::operations_type operations_type;
+    typedef typename stepper_type::resizer_type resizer_type;
+    typedef dense_output_stepper_tag stepper_category;
+    typedef dense_output_runge_kutta< Stepper > dense_output_stepper_type;
+
+
+    dense_output_runge_kutta( const controlled_stepper_type &stepper = controlled_stepper_type() )
+    : m_stepper( stepper ) , m_resizer() ,
+      m_current_state_x1( true ) ,
+      m_x1() , m_x2() , m_dxdt1() , m_dxdt2() ,
+      m_t() , m_t_old() , m_dt() ,
+      m_is_deriv_initialized( false )
+    { }
+
+
+    template< class StateType >
+    void initialize( const StateType &x0 , time_type t0 , time_type dt0 )
+    {
+        m_resizer.adjust_size( x0 , detail::bind( &dense_output_stepper_type::template resize< StateType > , detail::ref( *this ) , detail::_1 ) );
+        boost::numeric::odeint::copy( x0 , get_current_state() );
+        m_t = t0;
+        m_dt = dt0;
+        m_is_deriv_initialized = false;
+    }
+
+    template< class System >
+    std::pair< time_type , time_type > do_step( System system )
+    {
+        if( !m_is_deriv_initialized )
+        {
+            typename odeint::unwrap_reference< System >::type &sys = system;
+            sys( get_current_state() , get_current_deriv() , m_t );
+            m_is_deriv_initialized = true;
+        }
+
+        failed_step_checker fail_checker;  // to throw a runtime_error if step size adjustment fails
+        controlled_step_result res = fail;
+        m_t_old = m_t;
+        do
+        {
+            res = m_stepper.try_step( system , get_current_state() , get_current_deriv() , m_t ,
+                                      get_old_state() , get_old_deriv() , m_dt );
+            fail_checker();  // check for overflow of failed steps
+        }
+        while( res == fail );
+        toggle_current_state();
+        return std::make_pair( m_t_old , m_t );
+    }
+
+
+    /*
+     * The two overloads are needed in order to solve the forwarding problem.
+     */
+    template< class StateOut >
+    void calc_state( time_type t , StateOut &x ) const
+    {
+        m_stepper.stepper().calc_state( t , x , get_old_state() , get_old_deriv() , m_t_old ,
+                                        get_current_state() , get_current_deriv() , m_t );
+    }
+
+    template< class StateOut >
+    void calc_state( time_type t , const StateOut &x ) const
+    {
+        m_stepper.stepper().calc_state( t , x , get_old_state() , get_old_deriv() , m_t_old ,
+                                        get_current_state() , get_current_deriv() , m_t );
+    }
+
+
+    template< class StateIn >
+    bool resize( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxdt1 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxdt2 , x , typename is_resizeable<deriv_type>::type() );
+        return resized;
+    }
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize( x );
+        m_stepper.stepper().resize( x );
+    }
+
+    const state_type& current_state( void ) const
+    {
+        return get_current_state();
+    }
+
+    time_type current_time( void ) const
+    {
+        return m_t;
+    }
+
+    const state_type& previous_state( void ) const
+    {
+        return get_old_state();
+    }
+
+    time_type previous_time( void ) const
+    {
+        return m_t_old;
+    }
+
+    time_type current_time_step( void ) const
+    {
+        return m_dt;
+    }
+
+
+private:
+
+    state_type& get_current_state( void )
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    const state_type& get_current_state( void ) const
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    state_type& get_old_state( void )
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+    
+    const state_type& get_old_state( void ) const
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+
+    deriv_type& get_current_deriv( void )
+    {
+        return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ;
+    }
+    
+    const deriv_type& get_current_deriv( void ) const
+    {
+        return m_current_state_x1 ? m_dxdt1.m_v : m_dxdt2.m_v ;
+    }
+    
+    deriv_type& get_old_deriv( void )
+    {
+        return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ;
+    }
+    
+    const deriv_type& get_old_deriv( void ) const
+    {
+        return m_current_state_x1 ? m_dxdt2.m_v : m_dxdt1.m_v ;
+    }
+
+    
+    void toggle_current_state( void )
+    {
+        m_current_state_x1 = ! m_current_state_x1;
+    }
+
+
+    controlled_stepper_type m_stepper;
+    resizer_type m_resizer;
+    bool m_current_state_x1;
+    wrapped_state_type m_x1 , m_x2;
+    wrapped_deriv_type m_dxdt1 , m_dxdt2;
+    time_type m_t , m_t_old , m_dt;
+    bool m_is_deriv_initialized;
+
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp b/include/boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp
new file mode 100644
index 0000000..cc279ab
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp
@@ -0,0 +1,151 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp
+
+ [begin_description]
+ Algebra caller for the Adams Bashforth stepper.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_CALL_ALGEBRA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_CALL_ALGEBRA_HPP_INCLUDED
+
+#include <boost/assert.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< size_t Step , class Algebra , class Operations >
+struct adams_bashforth_call_algebra;
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 1 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each3( out , in , steps[0].m_v , typename Operations::template scale_sum2< value_type , Time >( 1.0 , dt * coef[0] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 2 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each4( out , in , steps[0].m_v , steps[1].m_v ,
+                typename Operations::template scale_sum3< value_type , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 3 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each5( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v ,
+                typename Operations::template scale_sum4< value_type , Time , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 4 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each6( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v ,
+                typename Operations::template scale_sum5< value_type , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 5 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each7( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v ,
+                typename Operations::template scale_sum6< value_type , Time , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 6 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each8( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v ,
+                typename Operations::template scale_sum7< value_type , Time , Time , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 7 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        //BOOST_ASSERT( false ); // not implemented
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each9( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , steps[6].m_v ,
+                            typename Operations::template scale_sum8< value_type , Time , Time , Time , Time , Time , Time >(
+                                1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_bashforth_call_algebra< 8 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        //BOOST_ASSERT( false ); // not implemented
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each10( out , in , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , steps[6].m_v , steps[7].m_v ,
+                             typename Operations::template scale_sum9< value_type , Time , Time , Time , Time , Time , Time , Time >(
+                                 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] , dt * coef[7] ) );
+    }
+};
+
+
+
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_CALL_ALGEBRA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp b/include/boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp
new file mode 100644
index 0000000..26a9f9a
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp
@@ -0,0 +1,168 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp
+
+ [begin_description]
+ Definition of the coefficients for the Adams-Bashforth method.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_COEFFICIENTS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_COEFFICIENTS_HPP_INCLUDED
+
+#include <boost/array.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< class Value , size_t Steps >
+class adams_bashforth_coefficients ;
+
+template< class Value >
+class adams_bashforth_coefficients< Value , 1 > : public boost::array< Value , 1 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : boost::array< Value , 1 >()
+      {
+        (*this)[0] = static_cast< Value >( 1 );
+      }
+};
+
+
+template< class Value >
+class adams_bashforth_coefficients< Value , 2 > : public boost::array< Value , 2 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : boost::array< Value , 2 >()
+      {
+        (*this)[0] = static_cast< Value >( 3 ) / static_cast< Value >( 2 );
+        (*this)[1] = -static_cast< Value >( 1 ) / static_cast< Value >( 2 );
+      }
+};
+
+
+template< class Value >
+class adams_bashforth_coefficients< Value , 3 > : public boost::array< Value , 3 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : boost::array< Value , 3 >()
+      {
+        (*this)[0] = static_cast< Value >( 23 ) / static_cast< Value >( 12 );
+        (*this)[1] = -static_cast< Value >( 4 ) / static_cast< Value >( 3 );
+        (*this)[2] = static_cast< Value >( 5 ) / static_cast< Value >( 12 );
+      }
+};
+
+
+template< class Value >
+class adams_bashforth_coefficients< Value , 4 > : public boost::array< Value , 4 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : boost::array< Value , 4 >()
+      {
+        (*this)[0] = static_cast< Value >( 55 ) / static_cast< Value >( 24 );
+        (*this)[1] = -static_cast< Value >( 59 ) / static_cast< Value >( 24 );
+        (*this)[2] = static_cast< Value >( 37 ) / static_cast< Value >( 24 );
+        (*this)[3] = -static_cast< Value >( 3 ) / static_cast< Value >( 8 );
+      }
+};
+
+
+template< class Value >
+class adams_bashforth_coefficients< Value , 5 > : public boost::array< Value , 5 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : boost::array< Value , 5 >()
+      {
+        (*this)[0] = static_cast< Value >( 1901 ) / static_cast< Value >( 720 );
+        (*this)[1] = -static_cast< Value >( 1387 ) / static_cast< Value >( 360 );
+        (*this)[2] = static_cast< Value >( 109 ) / static_cast< Value >( 30 );
+        (*this)[3] = -static_cast< Value >( 637 ) / static_cast< Value >( 360 );
+        (*this)[4] = static_cast< Value >( 251 ) / static_cast< Value >( 720 );
+      }
+};
+
+
+template< class Value >
+class adams_bashforth_coefficients< Value , 6 > : public boost::array< Value , 6 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : boost::array< Value , 6 >()
+      {
+        (*this)[0] = static_cast< Value >( 4277 ) / static_cast< Value >( 1440 );
+        (*this)[1] = -static_cast< Value >( 2641 ) / static_cast< Value >( 480 );
+        (*this)[2] = static_cast< Value >( 4991 ) / static_cast< Value >( 720 );
+        (*this)[3] = -static_cast< Value >( 3649 ) / static_cast< Value >( 720 );
+        (*this)[4] = static_cast< Value >( 959 ) / static_cast< Value >( 480 );
+        (*this)[5] = -static_cast< Value >( 95 ) / static_cast< Value >( 288 );
+      }
+};
+
+
+template< class Value >
+class adams_bashforth_coefficients< Value , 7 > : public boost::array< Value , 7 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : boost::array< Value , 7 >()
+      {
+        (*this)[0] = static_cast< Value >( 198721 ) / static_cast< Value >( 60480 );
+        (*this)[1] = -static_cast< Value >( 18637 ) / static_cast< Value >( 2520 );
+        (*this)[2] = static_cast< Value >( 235183 ) / static_cast< Value >( 20160 );
+        (*this)[3] = -static_cast< Value >( 10754 ) / static_cast< Value >( 945 );
+        (*this)[4] = static_cast< Value >( 135713 ) / static_cast< Value >( 20160 );
+        (*this)[5] = -static_cast< Value >( 5603 ) / static_cast< Value >( 2520 );
+        (*this)[6] = static_cast< Value >( 19087 ) / static_cast< Value >( 60480 );
+      }
+};
+
+
+template< class Value >
+class adams_bashforth_coefficients< Value , 8 > : public boost::array< Value , 8 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : boost::array< Value , 8 >()
+      {
+        (*this)[0] = static_cast< Value >( 16083 ) / static_cast< Value >( 4480 );
+        (*this)[1] = -static_cast< Value >( 1152169 ) / static_cast< Value >( 120960 );
+        (*this)[2] = static_cast< Value >( 242653 ) / static_cast< Value >( 13440 );
+        (*this)[3] = -static_cast< Value >( 296053 ) / static_cast< Value >( 13440 );
+        (*this)[4] = static_cast< Value >( 2102243 ) / static_cast< Value >( 120960 );
+        (*this)[5] = -static_cast< Value >( 115747 ) / static_cast< Value >( 13440 );
+        (*this)[6] = static_cast< Value >( 32863 ) / static_cast< Value >( 13440 );
+        (*this)[7] = -static_cast< Value >( 5257 ) / static_cast< Value >( 17280 );
+      }
+};
+
+
+
+
+
+
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_BASHFORTH_COEFFICIENTS_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp b/include/boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp
new file mode 100644
index 0000000..b6f5f2a
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp
@@ -0,0 +1,148 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp
+
+ [begin_description]
+ Algebra caller for the Adams Moulton method.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_CALL_ALGEBRA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_CALL_ALGEBRA_HPP_INCLUDED
+
+#include <boost/assert.hpp> 
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< size_t Step , class Algebra , class Operations >
+struct adams_moulton_call_algebra;
+
+template< class Algebra , class Operations >
+struct adams_moulton_call_algebra< 1 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage& /* steps */ , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each3( out , in , dxdt , typename Operations::template scale_sum2< value_type , Time >( 1.0 , dt * coef[0] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_moulton_call_algebra< 2 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each4( out , in , dxdt , steps[0].m_v ,
+                typename Operations::template scale_sum3< value_type , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_moulton_call_algebra< 3 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each5( out , in , dxdt , steps[0].m_v , steps[1].m_v ,
+                typename Operations::template scale_sum4< value_type , Time , Time >( 1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_moulton_call_algebra< 4 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each6( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v ,
+                typename Operations::template scale_sum5< value_type , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_moulton_call_algebra< 5 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each7( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v ,
+                typename Operations::template scale_sum6< value_type , Time , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_moulton_call_algebra< 6 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each8( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v ,
+                typename Operations::template scale_sum7< value_type , Time , Time , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_moulton_call_algebra< 7 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each9( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v ,
+                typename Operations::template scale_sum8< value_type , Time , Time , Time , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] ) );
+    }
+};
+
+
+template< class Algebra , class Operations >
+struct adams_moulton_call_algebra< 8 , Algebra , Operations >
+{
+    template< class StateIn , class StateOut , class DerivIn , class StepStorage , class Coefficients , class Time >
+    void operator()( Algebra &algebra , const StateIn &in , StateOut &out , const DerivIn &dxdt , const StepStorage &steps , const Coefficients &coef , Time dt ) const
+    {
+        typedef typename Coefficients::value_type value_type;
+        algebra.for_each10( out , in , dxdt , steps[0].m_v , steps[1].m_v , steps[2].m_v , steps[3].m_v , steps[4].m_v , steps[5].m_v , steps[6].m_v ,
+                typename Operations::template scale_sum9< value_type , Time , Time , Time , Time , Time , Time , Time >(
+                        1.0 , dt * coef[0] , dt * coef[1] , dt * coef[2] , dt * coef[3] , dt * coef[4] , dt * coef[5] , dt * coef[6] , dt * coef[7] ) );
+    }
+};
+
+
+
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_CALL_ALGEBRA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp b/include/boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp
new file mode 100644
index 0000000..8047fa8
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp
@@ -0,0 +1,168 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp
+
+ [begin_description]
+ Coefficients for the Adams Moulton method.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_COEFFICIENTS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_COEFFICIENTS_HPP_INCLUDED
+
+
+#include <boost/array.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< class Value , size_t Steps >
+class adams_moulton_coefficients ;
+
+template< class Value >
+class adams_moulton_coefficients< Value , 1 > : public boost::array< Value , 1 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : boost::array< Value , 1 >()
+      {
+        (*this)[0] = static_cast< Value >( 1 );
+      }
+};
+
+
+template< class Value >
+class adams_moulton_coefficients< Value , 2 > : public boost::array< Value , 2 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : boost::array< Value , 2 >()
+      {
+        (*this)[0] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
+        (*this)[1] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
+      }
+};
+
+
+template< class Value >
+class adams_moulton_coefficients< Value , 3 > : public boost::array< Value , 3 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : boost::array< Value , 3 >()
+      {
+        (*this)[0] = static_cast< Value >( 5 ) / static_cast< Value >( 12 );
+        (*this)[1] = static_cast< Value >( 2 ) / static_cast< Value >( 3 );
+        (*this)[2] = -static_cast< Value >( 1 ) / static_cast< Value >( 12 );
+      }
+};
+
+
+template< class Value >
+class adams_moulton_coefficients< Value , 4 > : public boost::array< Value , 4 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : boost::array< Value , 4 >()
+      {
+        (*this)[0] = static_cast< Value >( 3 ) / static_cast< Value >( 8 );
+        (*this)[1] = static_cast< Value >( 19 ) / static_cast< Value >( 24 );
+        (*this)[2] = -static_cast< Value >( 5 ) / static_cast< Value >( 24 );
+        (*this)[3] = static_cast< Value >( 1 ) / static_cast< Value >( 24 );
+      }
+};
+
+
+template< class Value >
+class adams_moulton_coefficients< Value , 5 > : public boost::array< Value , 5 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : boost::array< Value , 5 >()
+      {
+        (*this)[0] = static_cast< Value >( 251 ) / static_cast< Value >( 720 );
+        (*this)[1] = static_cast< Value >( 323 ) / static_cast< Value >( 360 );
+        (*this)[2] = -static_cast< Value >( 11 ) / static_cast< Value >( 30 );
+        (*this)[3] = static_cast< Value >( 53 ) / static_cast< Value >( 360 );
+        (*this)[4] = -static_cast< Value >( 19 ) / static_cast< Value >( 720 );
+      }
+};
+
+
+template< class Value >
+class adams_moulton_coefficients< Value , 6 > : public boost::array< Value , 6 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : boost::array< Value , 6 >()
+      {
+        (*this)[0] = static_cast< Value >( 95 ) / static_cast< Value >( 288 );
+        (*this)[1] = static_cast< Value >( 1427 ) / static_cast< Value >( 1440 );
+        (*this)[2] = -static_cast< Value >( 133 ) / static_cast< Value >( 240 );
+        (*this)[3] = static_cast< Value >( 241 ) / static_cast< Value >( 720 );
+        (*this)[4] = -static_cast< Value >( 173 ) / static_cast< Value >( 1440 );
+        (*this)[5] = static_cast< Value >( 3 ) / static_cast< Value >( 160 );
+      }
+};
+
+template< class Value >
+class adams_moulton_coefficients< Value , 7 > : public boost::array< Value , 7 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : boost::array< Value , 7 >()
+      {
+        (*this)[0] = static_cast< Value >( 19087 ) / static_cast< Value >( 60480 );
+        (*this)[1] = static_cast< Value >( 2713 ) / static_cast< Value >( 2520 );
+        (*this)[2] = -static_cast< Value >( 15487 ) / static_cast< Value >( 20160 );
+        (*this)[3] = static_cast< Value >( 586 ) / static_cast< Value >( 945 );
+        (*this)[4] = -static_cast< Value >( 6737 ) / static_cast< Value >( 20160 );
+        (*this)[5] = static_cast< Value >( 263 ) / static_cast< Value >( 2520 );
+        (*this)[6] = -static_cast< Value >( 863 ) / static_cast< Value >( 60480 );
+      }
+};
+
+
+template< class Value >
+class adams_moulton_coefficients< Value , 8 > : public boost::array< Value , 8 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : boost::array< Value , 8 >()
+      {
+        (*this)[0] = static_cast< Value >( 5257 ) / static_cast< Value >( 17280 );
+        (*this)[1] = static_cast< Value >( 139849 ) / static_cast< Value >( 120960 );
+        (*this)[2] = -static_cast< Value >( 4511 ) / static_cast< Value >( 4480 );
+        (*this)[3] = static_cast< Value >( 123133 ) / static_cast< Value >( 120960 );
+        (*this)[4] = -static_cast< Value >( 88547 ) / static_cast< Value >( 120960 );
+        (*this)[5] = static_cast< Value >( 1537 ) / static_cast< Value >( 4480 );
+        (*this)[6] = -static_cast< Value >( 11351 ) / static_cast< Value >( 120960 );
+        (*this)[7] = static_cast< Value >( 275 ) / static_cast< Value >( 24192 );
+      }
+};
+
+
+
+
+
+
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAMS_MOULTON_COEFFICIENTS_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp b/include/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp
new file mode 100644
index 0000000..ab74b24
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp
@@ -0,0 +1,247 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp
+
+ [begin_description]
+ Implementation of the generic Runge-Kutta method.
+ [end_description]
+
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_ALGORITHM_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_ALGORITHM_HPP_INCLUDED
+
+#include <boost/static_assert.hpp>
+
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/range_c.hpp>
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/size_t.hpp>
+
+#include <boost/fusion/algorithm.hpp>
+#include <boost/fusion/iterator.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/sequence.hpp>
+
+#include <boost/array.hpp>
+
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp>
+#include <boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp>
+#include <boost/numeric/odeint/util/bind.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< class T , class Constant >
+struct array_wrapper
+{
+    typedef const typename boost::array< T , Constant::value > type;
+};
+
+template< class T , size_t i >
+struct stage
+{
+    T c;
+    boost::array< T , i > a;
+};
+
+
+template< class T , class Constant >
+struct stage_wrapper
+{
+    typedef stage< T , Constant::value > type;
+};
+
+
+template<
+size_t StageCount,
+class Value ,
+class Algebra ,
+class Operations
+>
+class generic_rk_algorithm {
+
+public:
+    typedef mpl::range_c< size_t , 1 , StageCount > stage_indices;
+
+    typedef typename boost::fusion::result_of::as_vector
+            <
+            typename boost::mpl::copy
+            <
+            stage_indices ,
+            boost::mpl::inserter
+            <
+            boost::mpl::vector0< > ,
+            boost::mpl::push_back< boost::mpl::_1 , array_wrapper< Value , boost::mpl::_2 > >
+    >
+    >::type
+    >::type coef_a_type;
+
+    typedef boost::array< Value , StageCount > coef_b_type;
+    typedef boost::array< Value , StageCount > coef_c_type;
+
+    typedef typename boost::fusion::result_of::as_vector
+            <
+            typename boost::mpl::push_back
+            <
+            typename boost::mpl::copy
+            <
+            stage_indices,
+            boost::mpl::inserter
+            <
+            boost::mpl::vector0<> ,
+            boost::mpl::push_back< boost::mpl::_1 , stage_wrapper< Value , boost::mpl::_2 > >
+    >
+    >::type ,
+    stage< Value , StageCount >
+    >::type
+    >::type stage_vector_base;
+
+
+    struct stage_vector : public stage_vector_base
+    {
+        struct do_insertion
+        {
+            stage_vector_base &m_base;
+            const coef_a_type &m_a;
+            const coef_c_type &m_c;
+
+            do_insertion( stage_vector_base &base , const coef_a_type &a , const coef_c_type &c )
+            : m_base( base ) , m_a( a ) , m_c( c ) { }
+
+            template< class Index >
+            void operator()( Index ) const
+            {
+                //boost::fusion::at< Index >( m_base ) = stage< double , Index::value+1 , intermediate_stage >( m_c[ Index::value ] , boost::fusion::at< Index >( m_a ) );
+                boost::fusion::at< Index >( m_base ).c  = m_c[ Index::value ];
+                boost::fusion::at< Index >( m_base ).a = boost::fusion::at< Index >( m_a );
+            }
+        };
+
+        struct print_butcher
+        {
+            const stage_vector_base &m_base;
+            std::ostream &m_os;
+
+            print_butcher( const stage_vector_base &base , std::ostream &os )
+            : m_base( base ) , m_os( os )
+            { }
+
+            template<class Index>
+            void operator()(Index) const {
+                m_os << boost::fusion::at<Index>(m_base).c << " | ";
+                for( size_t i=0 ; i<Index::value ; ++i )
+                    m_os << boost::fusion::at<Index>(m_base).a[i] << " ";
+                m_os << std::endl;
+            }
+        };
+
+
+        stage_vector( const coef_a_type &a , const coef_b_type &b , const coef_c_type &c )
+        {
+            typedef boost::mpl::range_c< size_t , 0 , StageCount-1 > indices;
+            boost::mpl::for_each< indices >( do_insertion( *this , a , c ) );
+            boost::fusion::at_c< StageCount - 1 >( *this ).c = c[ StageCount - 1 ];
+            boost::fusion::at_c< StageCount - 1 >( *this ).a = b;
+        }
+
+        void print( std::ostream &os ) const
+        {
+            typedef boost::mpl::range_c< size_t , 0 , StageCount > indices;
+            boost::mpl::for_each< indices >( print_butcher( *this , os ) );
+        }
+    };
+
+
+
+    template< class System , class StateIn , class StateTemp , class DerivIn , class Deriv ,
+    class StateOut , class Time >
+    struct calculate_stage
+    {
+        Algebra &algebra;
+        System &system;
+        const StateIn &x;
+        StateTemp &x_tmp;
+        StateOut &x_out;
+        const DerivIn &dxdt;
+        Deriv *F;
+        Time t;
+        Time dt;
+
+        calculate_stage( Algebra &_algebra , System &_system , const StateIn &_x , const DerivIn &_dxdt , StateOut &_out ,
+                StateTemp &_x_tmp , Deriv *_F , Time _t , Time _dt )
+        : algebra( _algebra ) , system( _system ) , x( _x ) , x_tmp( _x_tmp ) , x_out( _out) , dxdt( _dxdt ) , F( _F ) , t( _t ) , dt( _dt )
+        {}
+
+
+        template< typename T , size_t stage_number >
+        void inline operator()( stage< T , stage_number > const &stage ) const
+        //typename stage_fusion_wrapper< T , mpl::size_t< stage_number > , intermediate_stage >::type const &stage ) const
+        {
+            if( stage_number > 1 )
+            {
+#ifdef BOOST_MSVC
+#pragma warning( disable : 4307 34 )
+#endif
+                system( x_tmp , F[stage_number-2].m_v , t + stage.c * dt );
+#ifdef BOOST_MSVC
+#pragma warning( default : 4307 34 )
+#endif
+            }
+            //std::cout << stage_number-2 << ", t': " << t + stage.c * dt << std::endl;
+
+            if( stage_number < StageCount )
+                detail::template generic_rk_call_algebra< stage_number , Algebra >()( algebra , x_tmp , x , dxdt , F ,
+                        detail::generic_rk_scale_sum< stage_number , Operations , Value , Time >( stage.a , dt) );
+            //                  algebra_type::template for_eachn<stage_number>( x_tmp , x , dxdt , F ,
+            //                          typename operations_type::template scale_sumn< stage_number , time_type >( stage.a , dt ) );
+            else
+                detail::template generic_rk_call_algebra< stage_number , Algebra >()( algebra , x_out , x , dxdt , F ,
+                        detail::generic_rk_scale_sum< stage_number , Operations , Value , Time >( stage.a , dt ) );
+            //                algebra_type::template for_eachn<stage_number>( x_out , x , dxdt , F ,
+            //                            typename operations_type::template scale_sumn< stage_number , time_type >( stage.a , dt ) );
+        }
+
+    };
+
+    generic_rk_algorithm( const coef_a_type &a , const coef_b_type &b , const coef_c_type &c )
+    : m_stages( a , b , c )
+    { }
+
+    template< class System , class StateIn , class DerivIn , class Time , class StateOut , class StateTemp , class Deriv >
+    void inline do_step( Algebra &algebra , System system , const StateIn &in , const DerivIn &dxdt ,
+            Time t , StateOut &out , Time dt ,
+            StateTemp &x_tmp , Deriv F[StageCount-1] ) const
+    {
+        typedef typename odeint::unwrap_reference< System >::type unwrapped_system_type;
+        unwrapped_system_type &sys = system;
+        boost::fusion::for_each( m_stages , calculate_stage<
+                unwrapped_system_type , StateIn , StateTemp , DerivIn , Deriv , StateOut , Time >
+        ( algebra , sys , in , dxdt , out , x_tmp , F , t , dt ) );
+    }
+
+private:
+    stage_vector m_stages;
+};
+
+
+}
+}
+}
+}
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_ALGORITHM_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp b/include/boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp
new file mode 100644
index 0000000..0249d86
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp
@@ -0,0 +1,263 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp
+
+ [begin_description]
+ Algebra caller for the generic Runge-Kutta methods.
+ [end_description]
+
+ Copyright 2011-2012 Mario Mulansky
+ Copyright 2011-2012 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_CALL_ALGEBRA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_CALL_ALGEBRA_HPP_INCLUDED
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< size_t StageNumber , class Algebra >
+struct generic_rk_call_algebra;
+
+template< class Algebra >
+struct generic_rk_call_algebra< 1 , Algebra >
+{
+    typedef Algebra algebra_type;
+
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( algebra_type &algebra , S1 &s1 , S2 &s2 ,  S3 &s3 , S4 * /* s4_array */ , Op op ) const
+    {
+        algebra.for_each3( s1 , s2 , s3 , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( algebra_type &algebra , S1 &s1 , S2 &s2 , S4 * /* s4_array */ , Op op ) const
+    {
+        algebra.for_each2( s1 , s2 , op );
+    }
+};
+
+template< class Algebra >
+struct generic_rk_call_algebra< 2 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 ,  S3 &s3 , S4 s4_array[1] , Op op ) const
+    {
+        algebra.for_each4( s1 , s2 , s3 , s4_array[0].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[1] , Op op ) const
+    {
+        algebra.for_each3( s1 , s2 , s4_array[0].m_v , op );
+    }
+};
+
+
+template< class Algebra >
+struct generic_rk_call_algebra< 3 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[2] , Op op ) const
+    {
+        algebra.for_each5( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[2] , Op op ) const
+    {
+        algebra.for_each4( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , op );
+    }
+};
+
+
+template< class Algebra >
+struct generic_rk_call_algebra< 4 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[3] , Op op ) const
+    {
+        algebra.for_each6( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[3] , Op op ) const
+    {
+        algebra.for_each5( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , op );
+    }
+};
+
+
+template< class Algebra >
+struct generic_rk_call_algebra< 5 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[4] , Op op ) const
+    {
+        algebra.for_each7( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[4] , Op op ) const
+    {
+        algebra.for_each6( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , op );
+    }
+};
+
+template< class Algebra >
+struct generic_rk_call_algebra< 6 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[5] , Op op ) const
+    {
+        algebra.for_each8( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[5] , Op op ) const
+    {
+        algebra.for_each7( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v , op );
+    }
+};
+
+template< class Algebra >
+struct generic_rk_call_algebra< 7 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[6] , Op op ) const
+    {
+        algebra.for_each9( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[6] , Op op ) const
+    {
+        algebra.for_each8( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , op );
+    }
+};
+
+template< class Algebra >
+struct generic_rk_call_algebra< 8 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[7] , Op op ) const
+    {
+        algebra.for_each10( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[7] , Op op ) const
+    {
+        algebra.for_each9( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , op );
+    }
+};
+
+template< class Algebra >
+struct generic_rk_call_algebra< 9 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[8] , Op op ) const
+    {
+        algebra.for_each11( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[8] , Op op ) const
+    {
+        algebra.for_each10( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , op );
+    }
+};
+
+template< class Algebra >
+struct generic_rk_call_algebra< 10 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[9] , Op op ) const
+    {
+        algebra.for_each12( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[9] , Op op ) const
+    {
+        algebra.for_each11( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , op );
+    }
+};
+
+
+template< class Algebra >
+struct generic_rk_call_algebra< 11 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[10] , Op op ) const
+    {
+        algebra.for_each13( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[10] , Op op ) const
+    {
+        algebra.for_each12( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , op );
+    }
+};
+
+template< class Algebra >
+struct generic_rk_call_algebra< 12 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[11] , Op op ) const
+    {
+        algebra.for_each14( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , s4_array[10].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[11] , Op op ) const
+    {
+        algebra.for_each13( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , s4_array[10].m_v , op );
+    }
+};
+
+template< class Algebra >
+struct generic_rk_call_algebra< 13 , Algebra >
+{
+    template< class S1 , class S2 , class S3 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S3 &s3 , S4 s4_array[12] , Op op ) const
+    {
+        algebra.for_each15( s1 , s2 , s3 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , s4_array[10].m_v , s4_array[11].m_v , op );
+    }
+
+    template< class S1 , class S2 , class S4 , class Op>
+    void operator()( Algebra &algebra , S1 &s1 , S2 &s2 , S4 s4_array[12] , Op op ) const
+    {
+        algebra.for_each14( s1 , s2 , s4_array[0].m_v , s4_array[1].m_v , s4_array[2].m_v , s4_array[3].m_v , s4_array[4].m_v ,
+                s4_array[5].m_v , s4_array[6].m_v , s4_array[7].m_v , s4_array[8].m_v , s4_array[9].m_v , s4_array[10].m_v , s4_array[11].m_v , op );
+    }
+};
+
+}
+}
+}
+}
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_CALL_ALGEBRA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp b/include/boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp
new file mode 100644
index 0000000..2cce3f4
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp
@@ -0,0 +1,252 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp
+
+ [begin_description]
+ Operations caller for the generic Runge Kutta method.
+ [end_description]
+
+ Copyright 2011 Mario Mulansky
+ Copyright 2011-2012 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_OPERATIONS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_OPERATIONS_HPP_INCLUDED
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< size_t StageNumber , class Operations , class Fac , class Time >
+struct generic_rk_scale_sum;
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 1 , Operations , Fac , Time > : public Operations::template scale_sum2< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,1> &a , Time dt ) : Operations::template scale_sum2< Fac , Time >( 1.0 , a[0]*dt )
+                { }
+
+    typedef void result_type;
+};
+
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 2 , Operations , Fac , Time > : public Operations::template scale_sum3< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,2> &a , Time dt )
+                    : Operations::template scale_sum3< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 3 , Operations , Fac , Time > : public Operations::template scale_sum4< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,3> &a , Time dt )
+                    : Operations::template scale_sum4< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 4 , Operations , Fac , Time > : public Operations::template scale_sum5< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,4> &a , Time dt )
+                    : Operations::template scale_sum5< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 5 , Operations , Fac , Time > : public Operations::template scale_sum6< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,5> &a , Time dt )
+                    : Operations::template scale_sum6< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 6 , Operations , Fac , Time > : public Operations::template scale_sum7< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,6> &a , Time dt )
+                    : Operations::template scale_sum7< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 7 , Operations , Fac , Time > : public Operations::template scale_sum8< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,7> &a , Time dt )
+                    : Operations::template scale_sum8< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt , a[6]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 8 , Operations , Fac , Time > : public Operations::template scale_sum9< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,8> &a , Time dt )
+                    : Operations::template scale_sum9< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt ,
+                            a[5]*dt , a[6]*dt , a[7]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 9 , Operations , Fac , Time > : public Operations::template scale_sum10< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,9> &a , Time dt )
+                    : Operations::template scale_sum10< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt ,
+                            a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 10 , Operations , Fac , Time > : public Operations::template scale_sum11< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,10> &a , Time dt )
+                    : Operations::template scale_sum11< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt ,
+                            a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 11 , Operations , Fac , Time > : public Operations::template scale_sum12< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,11> &a , Time dt )
+                    : Operations::template scale_sum12< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt ,
+                            a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt , a[10]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 12 , Operations , Fac , Time > : public Operations::template scale_sum13< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,12> &a , Time dt )
+                    : Operations::template scale_sum13< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt ,
+                            a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt , a[10]*dt , a[11]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum< 13 , Operations , Fac , Time > : public Operations::template scale_sum14< Fac , Time >
+{
+    generic_rk_scale_sum( const boost::array<Fac,13> &a , Time dt )
+                    : Operations::template scale_sum14< Fac , Time >( 1.0 , a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt ,
+                            a[5]*dt , a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt , a[10]*dt , a[11]*dt , a[12]*dt  )
+                      { }
+
+    typedef void result_type;
+};
+
+
+// for error estimates
+template< size_t StageNumber , class Operations , class Fac , class Time >
+struct generic_rk_scale_sum_err;
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum_err< 1 , Operations , Fac , Time > : public Operations::template scale_sum1< Time >
+{
+    generic_rk_scale_sum_err( const boost::array<Fac,1> &a , Time dt ) : Operations::template scale_sum1< Time >( a[0]*dt )
+                { }
+
+    typedef void result_type;
+};
+
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum_err< 2 , Operations , Fac , Time > : public Operations::template scale_sum2< Time >
+{
+    generic_rk_scale_sum_err( const boost::array<Fac,2> &a , Time dt )
+                    : Operations::template scale_sum2< Time >( a[0]*dt , a[1]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum_err< 3 , Operations , Fac , Time > : public Operations::template scale_sum3< Time >
+{
+    generic_rk_scale_sum_err( const boost::array<Fac,3> &a , Time dt )
+                    : Operations::template scale_sum3< Time >( a[0]*dt , a[1]*dt , a[2]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum_err< 4 , Operations , Fac , Time > : public Operations::template scale_sum4< Time >
+{
+    generic_rk_scale_sum_err( const boost::array<Fac,4> &a , Time dt )
+                    : Operations::template scale_sum4< Time >( a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum_err< 5 , Operations , Fac , Time > : public Operations::template scale_sum5< Fac >
+{
+    generic_rk_scale_sum_err( const boost::array<Fac,5> &a , Time dt )
+                    : Operations::template scale_sum5< Time >( a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum_err< 6 , Operations , Fac , Time > : public Operations::template scale_sum6< Time >
+{
+    generic_rk_scale_sum_err( const boost::array<Fac,6> &a , Time dt )
+                    : Operations::template scale_sum6< Time >( a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+
+// for rk87
+template< class Operations , class Fac , class Time >
+struct generic_rk_scale_sum_err< 13 , Operations , Fac , Time > : public Operations::template scale_sum13< Time >
+{
+    generic_rk_scale_sum_err( const boost::array<Fac,13> &a , Time dt )
+                    : Operations::template scale_sum13< Time >( a[0]*dt , a[1]*dt , a[2]*dt , a[3]*dt , a[4]*dt , a[5]*dt ,
+                        a[6]*dt , a[7]*dt , a[8]*dt , a[9]*dt , a[10]*dt , a[11]*dt , a[12]*dt )
+                      { }
+
+    typedef void result_type;
+};
+
+
+}
+}
+}
+}
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_GENERIC_RK_OPERATIONS_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/detail/rotating_buffer.hpp b/include/boost/numeric/odeint/stepper/detail/rotating_buffer.hpp
new file mode 100644
index 0000000..2338afd
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/detail/rotating_buffer.hpp
@@ -0,0 +1,84 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/detail/rotating_buffer.hpp
+
+ [begin_description]
+ Implemetation of a rotating (cyclic) buffer for use in the Adam Bashforth stepper
+ [end_description]
+
+ Copyright 2011 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ROTATING_BUFFER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ROTATING_BUFFER_HPP_INCLUDED
+
+#include <boost/array.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template< class T , size_t N >
+class rotating_buffer
+{
+public:
+
+    typedef T value_type;
+    const static size_t dim = N;
+
+    rotating_buffer( void ) : m_first( 0 )
+    { }
+
+    size_t size( void ) const
+    {
+        return dim;
+    }
+
+    value_type& operator[]( size_t i )
+    {
+        return m_data[ get_index( i ) ];
+    }
+
+    const value_type& operator[]( size_t i ) const
+    {
+        return m_data[ get_index( i ) ];
+    }
+
+    void rotate( void )
+    {
+        if( m_first == 0 )
+            m_first = dim-1;
+        else
+            --m_first;
+    }
+
+protected:
+
+    value_type m_data[N];
+
+private:
+
+    size_t get_index( size_t i ) const
+    {
+        return ( ( i + m_first ) % dim );
+    }
+
+    size_t m_first;
+
+};
+
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ROTATING_BUFFER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/euler.hpp b/include/boost/numeric/odeint/stepper/euler.hpp
new file mode 100644
index 0000000..1c7c126
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/euler.hpp
@@ -0,0 +1,166 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/euler.hpp
+
+ [begin_description]
+ Implementation of the classical explicit Euler stepper. This method is really simple and should only
+ be used for demonstration purposes.
+ [end_description]
+
+ Copyright 2010-2013 Karsten Ahnert
+ Copyright 2010-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_EULER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_EULER_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template<
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+#ifndef DOXYGEN_SKIP
+class euler
+: public explicit_stepper_base<
+  euler< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+  1 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
+#else
+class euler : public explicit_stepper_base
+#endif
+{
+public :
+
+    #ifndef DOXYGEN_SKIP
+    typedef explicit_stepper_base< euler< State , Value , Deriv , Time , Algebra , Operations , Resizer > , 1 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type;
+    #else
+    typedef explicit_stepper_base< euler< ... > , ... > stepper_base_type;
+    #endif
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+
+    #ifndef DOXYGEN_SKIP
+    typedef typename stepper_base_type::stepper_type stepper_type;
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    #endif 
+
+
+    euler( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra )
+    { }
+
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    void do_step_impl( System /* system */ , const StateIn &in , const DerivIn &dxdt , time_type /* t */ , StateOut &out , time_type dt )
+    {
+        stepper_base_type::m_algebra.for_each3( out , in , dxdt ,
+                typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , dt ) );
+
+    }
+
+    template< class StateOut , class StateIn1 , class StateIn2 >
+    void calc_state( StateOut &x , time_type t ,  const StateIn1 &old_state , time_type t_old , const StateIn2 & /*current_state*/ , time_type /* t_new */ ) const
+    {
+        const time_type delta = t - t_old;
+        stepper_base_type::m_algebra.for_each3( x , old_state , stepper_base_type::m_dxdt.m_v ,
+                typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , delta ) );
+    }
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        stepper_base_type::adjust_size( x );
+    }
+};
+
+
+
+/********** DOXYGEN ***********/
+
+/**
+ * \class euler
+ * \brief An implementation of the Euler method.
+ *
+ * The Euler method is a very simply solver for ordinary differential equations. This method should not be used
+ * for real applications. It is only useful for demonstration purposes. Step size control is not provided but
+ * trivial continuous output is available.
+ * 
+ * This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern),
+ * see explicit_stepper_base
+ *
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+    /**
+     * \fn euler::euler( const algebra_type &algebra )
+     * \brief Constructs the euler class. This constructor can be used as a default
+     * constructor of the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+    
+    /**
+     * \fn euler::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+     * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
+     * The result is updated out of place, hence the input is in `in` and the output in `out`.
+     * Access to this step functionality is provided by explicit_stepper_base and 
+     * `do_step_impl` should not be called directly.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+
+    /**
+     * \fn euler::calc_state( StateOut &x , time_type t ,  const StateIn1 &old_state , time_type t_old , const StateIn2 &current_state , time_type t_new ) const
+     * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the 
+     * knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`.
+     */
+
+    /**
+     * \fn euler::adjust_size( const StateType &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_EULER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp b/include/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp
new file mode 100644
index 0000000..3c59810
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp
@@ -0,0 +1,255 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp
+
+ [begin_description]
+ Implementation of the generic Runge Kutta error stepper. Base class for many RK error steppers.
+ [end_description]
+
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_ERROR_GENERIC_RK_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_ERROR_GENERIC_RK_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp>
+
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+#include <boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp>
+#include <boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp>
+#include <boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template<
+size_t StageCount,
+size_t Order,
+size_t StepperOrder ,
+size_t ErrorOrder ,
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+#ifndef DOXYGEN_SKIP
+class explicit_error_generic_rk
+: public explicit_error_stepper_base<
+  explicit_error_generic_rk< StageCount , Order , StepperOrder , ErrorOrder , State ,
+  Value , Deriv , Time , Algebra , Operations , Resizer > ,
+  Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra ,
+  Operations , Resizer >
+#else
+class explicit_error_generic_rk : public explicit_error_stepper_base
+#endif
+{
+
+public:
+#ifndef DOXYGEN_SKIP
+    typedef explicit_error_stepper_base<
+            explicit_error_generic_rk< StageCount , Order , StepperOrder , ErrorOrder , State ,
+            Value , Deriv , Time , Algebra , Operations , Resizer > ,
+            Order , StepperOrder , ErrorOrder , State , Value , Deriv , Time , Algebra ,
+            Operations , Resizer > stepper_base_type;
+#else
+    typedef explicit_stepper_base< ... > stepper_base_type;
+#endif
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+#ifndef DOXYGEN_SKIP
+    typedef explicit_error_generic_rk< StageCount , Order , StepperOrder , ErrorOrder , State ,
+            Value , Deriv , Time , Algebra , Operations , Resizer > stepper_type;
+#endif
+    typedef detail::generic_rk_algorithm< StageCount , Value , Algebra , Operations > rk_algorithm_type;
+
+    typedef typename rk_algorithm_type::coef_a_type coef_a_type;
+    typedef typename rk_algorithm_type::coef_b_type coef_b_type;
+    typedef typename rk_algorithm_type::coef_c_type coef_c_type;
+
+    static const size_t stage_count = StageCount;
+
+private:
+
+
+public:
+
+    // we use an explicit_generic_rk to do the normal rk step
+    // and add a separate calculation of the error estimate afterwards
+    explicit_error_generic_rk( const coef_a_type &a ,
+            const coef_b_type &b ,
+            const coef_b_type &b2 ,
+            const coef_c_type &c ,
+            const algebra_type &algebra = algebra_type() )
+    : stepper_base_type( algebra ) , m_rk_algorithm( a , b , c ) , m_b2( b2 )
+    { }
+
+
+    template< class System , class StateIn , class DerivIn , class StateOut , class Err >
+    void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt ,
+            time_type t , StateOut &out , time_type dt , Err &xerr )
+    {
+        // normal step
+        do_step_impl( system , in , dxdt , t , out , dt );
+
+        // additionally, perform the error calculation
+        detail::template generic_rk_call_algebra< StageCount , algebra_type >()( stepper_base_type::m_algebra ,
+                xerr , dxdt , m_F , detail::generic_rk_scale_sum_err< StageCount , operations_type , value_type , time_type >( m_b2 , dt) );
+    }
+
+
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt ,
+            time_type t , StateOut &out , time_type dt )
+    {
+        m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) );
+
+        // actual calculation done in generic_rk.hpp
+        m_rk_algorithm.do_step( stepper_base_type::m_algebra , system , in , dxdt , t , out , dt , m_x_tmp.m_v , m_F );
+    }
+
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_impl( x );
+        stepper_base_type::adjust_size( x );
+    }
+
+
+private:
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized( false );
+        resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() );
+        for( size_t i = 0 ; i < StageCount-1 ; ++i )
+        {
+            resized |= adjust_size_by_resizeability( m_F[i] , x , typename is_resizeable<deriv_type>::type() );
+        }
+        return resized;
+    }
+
+
+    rk_algorithm_type m_rk_algorithm;
+    coef_b_type m_b2;
+
+    resizer_type m_resizer;
+
+    wrapped_state_type m_x_tmp;
+    wrapped_deriv_type m_F[StageCount-1];
+
+};
+
+
+/********* DOXYGEN *********/
+
+/**
+ * \class explicit_error_generic_rk
+ * \brief A generic implementation of explicit Runge-Kutta algorithms with error estimation. This class is as a
+ * base class for all explicit Runge-Kutta steppers with error estimation.
+ *
+ * This class implements the explicit Runge-Kutta algorithms with error estimation in a generic way.
+ * The Butcher tableau is passed to the stepper which constructs the stepper scheme with the help of a
+ * template-metaprogramming algorithm. ToDo : Add example!
+ * 
+ * This class derives explicit_error_stepper_base which provides the stepper interface.
+ *
+ * \tparam StageCount The number of stages of the Runge-Kutta algorithm.
+ * \tparam Order The order of a stepper if the stepper is used without error estimation.
+ * \tparam StepperOrder The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have 
+ * the same value.
+ * \tparam ErrorOrder The order of the error step if the stepper is used with error estimation.
+ * \tparam State The type representing the state of the ODE.
+ * \tparam Value The floating point type which is used in the computations.
+ * \tparam Time The type representing the independent variable - the time - of the ODE.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+
+    /**
+     * \fn explicit_error_generic_rk::explicit_error_generic_rk( const coef_a_type &a , const coef_b_type &b , const coef_b_type &b2 , const coef_c_type &c , const algebra_type &algebra )
+     * \brief Constructs the explicit_error_generik_rk class with the given parameters a, b, b2 and c. See examples section for details on the coefficients.
+     *
+     * \param a Triangular matrix of parameters b in the Butcher tableau.
+     * \param b Last row of the butcher tableau.
+     * \param b2 Parameters for lower-order evaluation to estimate the error.
+     * \param c Parameters to calculate the time points in the Butcher tableau.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+
+    /**
+     * \fn explicit_error_generic_rk::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
+     * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
+     * The result is updated out-of-place, hence the input is in `in` and the output in `out`. Futhermore, an
+     * estimation of the error is stored in `xerr`. `do_step_impl` is used by explicit_error_stepper_base.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     * \param xerr The result of the error estimation is written in xerr.
+     */
+
+    /**
+     * \fn explicit_error_generic_rk::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+     * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
+     * The result is updated out-of-place, hence the input is in `in` and the output in `out`.
+     * Access to this step functionality is provided by explicit_stepper_base and 
+     * `do_step_impl` should not be called directly.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn explicit_error_generic_rk::adjust_size( const StateIn &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+}
+}
+}
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_ERROR_GENERIC_RK_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/explicit_generic_rk.hpp b/include/boost/numeric/odeint/stepper/explicit_generic_rk.hpp
new file mode 100644
index 0000000..f8edc20
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/explicit_generic_rk.hpp
@@ -0,0 +1,246 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/explicit_generic_rk.hpp
+
+ [begin_description]
+ Implementation of the generic Runge-Kutta steppers. This is the base class for many Runge-Kutta steppers.
+ [end_description]
+
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_GENERIC_RK_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_GENERIC_RK_HPP_INCLUDED
+
+
+#include <boost/array.hpp>
+
+
+#include <boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+#include <boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+//forward declarations
+
+#ifndef DOXYGEN_SKIP
+template<
+size_t StageCount,
+size_t Order,
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+class explicit_generic_rk;
+
+
+struct stage_vector;
+
+template< class T , class Constant >
+struct array_wrapper
+{
+    typedef const typename boost::array< T , Constant::value > type;
+};
+
+template< class T , size_t i >
+struct stage
+{
+    T c;
+    boost::array< T , i > a;
+};
+
+
+template< class T , class Constant >
+struct stage_wrapper
+{
+    typedef stage< T , Constant::value > type;
+};
+#endif
+
+
+template<
+size_t StageCount,
+size_t Order,
+class State ,
+class Value ,
+class Deriv ,
+class Time ,
+class Algebra ,
+class Operations ,
+class Resizer
+>
+#ifndef DOXYGEN_SKIP
+class explicit_generic_rk : public explicit_stepper_base<
+explicit_generic_rk< StageCount , Order , State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+Order , State , Value , Deriv , Time , Algebra , Operations , Resizer >
+#else
+class explicit_generic_rk : public explicit_stepper_base
+#endif
+{
+
+public:
+
+    #ifndef DOXYGEN_SKIP
+    typedef explicit_stepper_base<
+            explicit_generic_rk< StageCount , Order , State , Value , Deriv ,Time , Algebra , Operations , Resizer > ,
+            Order , State , Value , Deriv , Time , Algebra ,
+            Operations , Resizer > stepper_base_type;
+    #else
+    typedef explicit_stepper_base< ... > stepper_base_type;
+    #endif
+
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+
+    #ifndef DOXYGEN_SKIP
+    typedef explicit_generic_rk< StageCount , Order , State , Value , Deriv ,Time , Algebra , Operations , Resizer > stepper_type;
+    #endif 
+
+    typedef detail::generic_rk_algorithm< StageCount , Value , Algebra , Operations > rk_algorithm_type;
+
+    typedef typename rk_algorithm_type::coef_a_type coef_a_type;
+    typedef typename rk_algorithm_type::coef_b_type coef_b_type;
+    typedef typename rk_algorithm_type::coef_c_type coef_c_type;
+
+    #ifndef DOXYGEN_SKIP
+    static const size_t stage_count = StageCount;
+    #endif
+
+public:
+
+    explicit_generic_rk( const coef_a_type &a , const coef_b_type &b , const coef_c_type &c ,
+            const algebra_type &algebra = algebra_type() )
+    : stepper_base_type( algebra ) , m_rk_algorithm( a , b , c )
+    { }
+
+
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt ,
+            time_type t , StateOut &out , time_type dt )
+    {
+        m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) );
+
+        // actual calculation done in generic_rk.hpp
+        m_rk_algorithm.do_step( stepper_base_type::m_algebra , system , in , dxdt , t , out , dt , m_x_tmp.m_v , m_F );
+    }
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_impl( x );
+        stepper_base_type::adjust_size( x );
+    }
+
+private:
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized( false );
+        resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() );
+        for( size_t i = 0 ; i < StageCount-1 ; ++i )
+        {
+            resized |= adjust_size_by_resizeability( m_F[i] , x , typename is_resizeable<deriv_type>::type() );
+        }
+        return resized;
+    }
+
+
+    rk_algorithm_type m_rk_algorithm;
+
+    resizer_type m_resizer;
+
+    wrapped_state_type m_x_tmp;
+    wrapped_deriv_type m_F[StageCount-1];
+
+};
+
+
+
+/*********** DOXYGEN *************/
+
+/**
+ * \class explicit_generic_rk
+ * \brief A generic implementation of explicit Runge-Kutta algorithms. This class is as a base class
+ * for all explicit Runge-Kutta steppers.
+ *
+ * This class implements the explicit Runge-Kutta algorithms without error estimation in a generic way.
+ * The Butcher tableau is passed to the stepper which constructs the stepper scheme with the help of a
+ * template-metaprogramming algorithm. ToDo : Add example!
+ * 
+ * This class derives explicit_stepper_base which provides the stepper interface.
+ *
+ * \tparam StageCount The number of stages of the Runge-Kutta algorithm.
+ * \tparam Order The order of the stepper.
+ * \tparam State The type representing the state of the ODE.
+ * \tparam Value The floating point type which is used in the computations.
+ * \tparam Time The type representing the independent variable - the time - of the ODE.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+    /**
+     * \fn explicit_generic_rk::explicit_generic_rk( const coef_a_type &a , const coef_b_type &b , const coef_c_type &c , const algebra_type &algebra )
+     * \brief Constructs the explicit_generic_rk class. See examples section for details on the coefficients.
+     * \param a Triangular matrix of parameters b in the Butcher tableau.
+     * \param b Last row of the butcher tableau.
+     * \param c Parameters to calculate the time points in the Butcher tableau.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+    
+    /**
+     * \fn explicit_generic_rk::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+     * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
+     * The result is updated out of place, hence the input is in `in` and the output in `out`.
+     * Access to this step functionality is provided by explicit_stepper_base and 
+     * `do_step_impl` should not be called directly.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+
+    /**
+     * \fn explicit_generic_rk::adjust_size( const StateIn &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+}
+}
+}
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_EXPLICIT_GENERIC_RK_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/extrapolation_stepper.hpp b/include/boost/numeric/odeint/stepper/extrapolation_stepper.hpp
new file mode 100644
index 0000000..3b688e9
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/extrapolation_stepper.hpp
@@ -0,0 +1,293 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/stepper/extrapolation_stepper.hpp
+
+  [begin_description]
+  extrapolation stepper
+  [end_description]
+
+  Copyright 2009-2015 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_EXTRAPOLATION_STEPPER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_EXTRAPOLATION_STEPPER_HPP_INCLUDED
+
+#include <iostream>
+
+#include <algorithm>
+
+#include <boost/config.hpp> // for min/max guidelines
+#include <boost/static_assert.hpp>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+
+#include <boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp>
+#include <boost/numeric/odeint/stepper/modified_midpoint.hpp>
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+namespace boost
+{
+namespace numeric
+{
+namespace odeint
+{
+
+template < unsigned short Order, class State, class Value = double,
+           class Deriv = State, class Time = Value,
+           class Algebra = typename algebra_dispatcher< State >::algebra_type,
+           class Operations =
+               typename operations_dispatcher< State >::operations_type,
+           class Resizer = initially_resizer >
+#ifndef DOXYGEN_SKIP
+class extrapolation_stepper
+    : public explicit_error_stepper_base<
+          extrapolation_stepper< Order, State, Value, Deriv, Time, Algebra,
+                                 Operations, Resizer >,
+          Order, Order, Order - 2, State, Value, Deriv, Time, Algebra,
+          Operations, Resizer >
+#else
+class extrapolation_stepper : public explicit_error_stepper_base
+#endif
+{
+
+  private:
+    // check for Order being odd
+    BOOST_STATIC_ASSERT_MSG(
+        ( ( Order % 2 ) == 0 ) && ( Order > 2 ),
+        "extrapolation_stepper requires even Order larger than 2" );
+
+  public:
+#ifndef DOXYGEN_SKIP
+    typedef explicit_error_stepper_base<
+        extrapolation_stepper< Order, State, Value, Deriv, Time, Algebra,
+                               Operations, Resizer >,
+        Order, Order, Order - 2, State, Value, Deriv, Time, Algebra, Operations,
+        Resizer > stepper_base_type;
+#else
+    typedef explicit_error_stepper_base< extrapolation_stepper< ... >, ... >
+    stepper_base_type;
+#endif
+
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+
+#ifndef DOXYGEN_SKIP
+    typedef typename stepper_base_type::stepper_type stepper_type;
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+
+    typedef std::vector< value_type > value_vector;
+    typedef std::vector< value_vector > value_matrix;
+    typedef std::vector< size_t > int_vector;
+    typedef std::vector< wrapped_state_type > state_table_type;
+    typedef modified_midpoint< state_type, value_type, deriv_type, time_type,
+                               algebra_type, operations_type,
+                               resizer_type > midpoint_stepper_type;
+
+#endif // DOXYGEN_SKIP
+
+    typedef unsigned short order_type;
+    static const order_type order_value = stepper_base_type::order_value;
+    static const order_type stepper_order_value =
+        stepper_base_type::stepper_order_value;
+    static const order_type error_order_value =
+        stepper_base_type::error_order_value;
+
+    const static size_t m_k_max = ( order_value - 2 ) / 2;
+
+    extrapolation_stepper( const algebra_type &algebra = algebra_type() )
+        : stepper_base_type( algebra ), m_interval_sequence( m_k_max + 1 ),
+          m_coeff( m_k_max + 1 ), m_table( m_k_max )
+    {
+        for ( unsigned short i = 0; i < m_k_max + 1; i++ )
+        {
+            m_interval_sequence[i] = 2 * ( i + 1 );
+            m_coeff[i].resize( i );
+            for ( size_t k = 0; k < i; ++k )
+            {
+                const value_type r =
+                    static_cast< value_type >( m_interval_sequence[i] ) /
+                    static_cast< value_type >( m_interval_sequence[k] );
+                m_coeff[i][k] =
+                    static_cast< value_type >( 1 ) /
+                    ( r * r - static_cast< value_type >(
+                                  1 ) ); // coefficients for extrapolation
+            }
+        }
+    }
+
+    template < class System, class StateIn, class DerivIn, class StateOut,
+               class Err >
+    void do_step_impl( System system, const StateIn &in, const DerivIn &dxdt,
+                       time_type t, StateOut &out, time_type dt, Err &xerr )
+    {
+        // std::cout << "dt: " << dt << std::endl;
+        // normal step
+        do_step_impl( system, in, dxdt, t, out, dt );
+
+        static const value_type val1( 1.0 );
+        // additionally, perform the error calculation
+        stepper_base_type::m_algebra.for_each3(
+            xerr, out, m_table[0].m_v,
+            typename operations_type::template scale_sum2<
+                value_type, value_type >( val1, -val1 ) );
+    }
+
+    template < class System, class StateInOut, class DerivIn, class Err >
+    void do_step_impl_io( System system, StateInOut &inout, const DerivIn &dxdt,
+                          time_type t, time_type dt, Err &xerr )
+    {
+        // normal step
+        do_step_impl_io( system, inout, dxdt, t, dt );
+
+        static const value_type val1( 1.0 );
+        // additionally, perform the error calculation
+        stepper_base_type::m_algebra.for_each3(
+            xerr, inout, m_table[0].m_v,
+            typename operations_type::template scale_sum2<
+                value_type, value_type >( val1, -val1 ) );
+    }
+
+    template < class System, class StateIn, class DerivIn, class StateOut >
+    void do_step_impl( System system, const StateIn &in, const DerivIn &dxdt,
+                       time_type t, StateOut &out, time_type dt )
+    {
+        m_resizer.adjust_size(
+            in, detail::bind( &stepper_type::template resize_impl< StateIn >,
+                              detail::ref( *this ), detail::_1 ) );
+        size_t k = 0;
+        m_midpoint.set_steps( m_interval_sequence[k] );
+        m_midpoint.do_step( system, in, dxdt, t, out, dt );
+        for ( k = 1; k <= m_k_max; ++k )
+        {
+            m_midpoint.set_steps( m_interval_sequence[k] );
+            m_midpoint.do_step( system, in, dxdt, t, m_table[k - 1].m_v, dt );
+            extrapolate( k, m_table, m_coeff, out );
+        }
+    }
+
+    template < class System, class StateInOut, class DerivIn >
+    void do_step_impl_io( System system, StateInOut &inout, const DerivIn &dxdt,
+                          time_type t, time_type dt )
+    {
+        // special care for inout
+        m_xout_resizer.adjust_size(
+            inout,
+            detail::bind( &stepper_type::template resize_m_xout< StateInOut >,
+                          detail::ref( *this ), detail::_1 ) );
+        do_step_impl( system, inout, dxdt, t, m_xout.m_v, dt );
+        boost::numeric::odeint::copy( m_xout.m_v, inout );
+    }
+
+    template < class System, class StateInOut, class DerivIn >
+    void do_step_dxdt_impl( System system, StateInOut &x, const DerivIn &dxdt,
+                            time_type t, time_type dt )
+    {
+        do_step_impl_io( system , x , dxdt , t , dt );
+    }
+
+    template < class System, class StateIn, class DerivIn, class StateOut >
+    void do_step_dxdt_impl( System system, const StateIn &in,
+                            const DerivIn &dxdt, time_type t, StateOut &out,
+                            time_type dt )
+    {
+        do_step_impl( system , in , dxdt , t , out , dt );
+    }
+
+
+    template < class StateIn > void adjust_size( const StateIn &x )
+    {
+        resize_impl( x );
+        m_midpoint.adjust_size( x );
+    }
+
+  private:
+    template < class StateIn > bool resize_impl( const StateIn &x )
+    {
+        bool resized( false );
+        for ( size_t i = 0; i < m_k_max; ++i )
+            resized |= adjust_size_by_resizeability(
+                m_table[i], x, typename is_resizeable< state_type >::type() );
+        return resized;
+    }
+
+    template < class StateIn > bool resize_m_xout( const StateIn &x )
+    {
+        return adjust_size_by_resizeability(
+            m_xout, x, typename is_resizeable< state_type >::type() );
+    }
+
+    template < class StateInOut >
+    void extrapolate( size_t k, state_table_type &table,
+                      const value_matrix &coeff, StateInOut &xest )
+    /* polynomial extrapolation, see http://www.nr.com/webnotes/nr3web21.pdf
+       uses the obtained intermediate results to extrapolate to dt->0
+    */
+    {
+        static const value_type val1 = static_cast< value_type >( 1.0 );
+
+        for ( int j = k - 1; j > 0; --j )
+        {
+            stepper_base_type::m_algebra.for_each3(
+                table[j - 1].m_v, table[j].m_v, table[j - 1].m_v,
+                typename operations_type::template scale_sum2<
+                    value_type, value_type >( val1 + coeff[k][j],
+                                              -coeff[k][j] ) );
+        }
+        stepper_base_type::m_algebra.for_each3(
+            xest, table[0].m_v, xest,
+            typename operations_type::template scale_sum2<
+                value_type, value_type >( val1 + coeff[k][0], -coeff[k][0] ) );
+    }
+
+  private:
+    midpoint_stepper_type m_midpoint;
+
+    resizer_type m_resizer;
+    resizer_type m_xout_resizer;
+
+    int_vector m_interval_sequence; // stores the successive interval counts
+    value_matrix m_coeff;
+
+    wrapped_state_type m_xout;
+    state_table_type m_table; // sequence of states for extrapolation
+};
+
+/******** DOXYGEN *******/
+
+/**
+ * \class extrapolation_stepper
+ * \brief Extrapolation stepper with configurable order, and error estimation.
+ *
+ * The extrapolation stepper is a stepper with error estimation and configurable
+ * order. The order is given as template parameter and needs to be an _odd_
+ * number. The stepper is based on several executions of the modified midpoint
+ * method and a Richardson extrapolation. This is essentially the same technique
+ * as for bulirsch_stoer, but without the variable order.
+ *
+ * \note The Order parameter has to be an even number greater 2.
+ */
+}
+}
+}
+#endif
diff --git a/include/boost/numeric/odeint/stepper/generation.hpp b/include/boost/numeric/odeint/stepper/generation.hpp
new file mode 100644
index 0000000..90ad2b9
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation.hpp
@@ -0,0 +1,36 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation.hpp
+
+ [begin_description]
+ Forward header for the factory functions. Includes all files from the generation directory.
+ [end_description]
+
+ Copyright 2011 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/generation/make_controlled.hpp>
+#include <boost/numeric/odeint/stepper/generation/make_dense_output.hpp>
+
+#include <boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp>
+
+#include <boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp>
+#include <boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp>
+#include <boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp>
+#include <boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp>
+
+
+#include <boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp>
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp b/include/boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp
new file mode 100644
index 0000000..bad2bed
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp
@@ -0,0 +1,61 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp
+
+ [begin_description]
+ Specialization of the controller factory for the controlled_runge_kutta class.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/generation/make_controlled.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+// controller factory for controlled_runge_kutta
+template< class Stepper >
+struct controller_factory< Stepper , controlled_runge_kutta< Stepper > >
+{
+    typedef Stepper stepper_type;
+    typedef controlled_runge_kutta< stepper_type > controller_type;
+    typedef typename controller_type::error_checker_type error_checker_type;
+    typedef typename controller_type::step_adjuster_type step_adjuster_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::value_type time_type;
+
+    controller_type operator()( value_type abs_error , value_type rel_error , const stepper_type &stepper )
+    {
+        return controller_type( error_checker_type( abs_error , rel_error ) ,
+                                step_adjuster_type() , stepper );
+    }
+
+    controller_type operator()( value_type abs_error , value_type rel_error ,
+                                time_type max_dt, const stepper_type &stepper )
+    {
+        return controller_type( error_checker_type( abs_error , rel_error ) ,
+                                step_adjuster_type(max_dt) , stepper );
+    }
+};
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_CONTROLLED_RUNGE_KUTTA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp b/include/boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp
new file mode 100644
index 0000000..276358a
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp
@@ -0,0 +1,65 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp
+
+ [begin_description]
+ Specialization of the controller factory for the dense_output_runge_kutta class.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/generation/make_dense_output.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+// controller factory for controlled_runge_kutta
+template< class Stepper >
+struct dense_output_factory< Stepper , dense_output_runge_kutta< controlled_runge_kutta< Stepper > > >
+{
+    typedef Stepper stepper_type;
+    typedef controlled_runge_kutta< stepper_type > controller_type;
+    typedef typename controller_type::error_checker_type error_checker_type;
+    typedef typename controller_type::step_adjuster_type step_adjuster_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef dense_output_runge_kutta< controller_type > dense_output_type;
+
+    dense_output_type operator()( value_type abs_error , value_type rel_error , const stepper_type &stepper )
+    {
+        return dense_output_type( controller_type( error_checker_type( abs_error , rel_error ) ,
+                                                   step_adjuster_type() , stepper ) );
+    }
+
+    dense_output_type operator()( value_type abs_error , value_type rel_error ,
+                                  time_type max_dt , const stepper_type &stepper )
+    {
+        return dense_output_type(
+                controller_type( error_checker_type( abs_error , rel_error) ,
+                                 step_adjuster_type( max_dt ) , stepper ) );
+    }
+};
+
+
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_DENSE_OUTPUT_RUNGE_KUTTA_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp b/include/boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp
new file mode 100644
index 0000000..366cb5e
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp
@@ -0,0 +1,79 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp
+
+ [begin_description]
+ Enable the factory functions for the controller and the dense output of the Rosenbrock4 method.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_ROSENBROCK4_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_ROSENBROCK4_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/rosenbrock4.hpp>
+#include <boost/numeric/odeint/stepper/rosenbrock4_controller.hpp>
+#include <boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template< class Value , class Coefficients , class Resize >
+struct get_controller< rosenbrock4< Value , Coefficients , Resize > >
+{
+    typedef rosenbrock4< Value , Coefficients , Resize > stepper_type;
+    typedef rosenbrock4_controller< stepper_type > type;
+};
+
+
+
+template< class Value , class Coefficients , class Resize >
+struct get_dense_output< rosenbrock4< Value , Coefficients , Resize > >
+{
+    typedef rosenbrock4< Value , Coefficients , Resize > stepper_type;
+    typedef rosenbrock4_controller< stepper_type > controller_type;
+    typedef rosenbrock4_dense_output< controller_type > type;
+};
+
+
+
+// controller factory for controlled_runge_kutta
+template< class Stepper >
+struct dense_output_factory< Stepper , rosenbrock4_dense_output< rosenbrock4_controller< Stepper > > >
+{
+    typedef Stepper stepper_type;
+    typedef rosenbrock4_controller< stepper_type > controller_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef rosenbrock4_dense_output< controller_type > dense_output_type;
+
+    dense_output_type operator()( value_type abs_error , value_type rel_error , const stepper_type &stepper )
+    {
+        return dense_output_type( controller_type( abs_error , rel_error , stepper ) );
+    }
+
+    dense_output_type operator()( value_type abs_error , value_type rel_error ,
+                                  time_type max_dt, const stepper_type &stepper )
+    {
+        return dense_output_type( controller_type( abs_error , rel_error , max_dt , stepper ) );
+    }
+};
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_ROSENBROCK4_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp b/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp
new file mode 100644
index 0000000..24ae547
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp
@@ -0,0 +1,47 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp
+
+ [begin_description]
+ Enable the factory functions for the controller and the dense output of the Runge-Kutta-Cash-Karp 54 method.
+ [end_description]
+
+ Copyright 2011 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp>
+#include <boost/numeric/odeint/stepper/generation/make_controlled.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+// Specializations for runge_kutta_cash_karp54
+template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize >
+struct get_controller< runge_kutta_cash_karp54< State , Value , Deriv , Time , Algebra , Operations , Resize > >
+{
+    typedef runge_kutta_cash_karp54< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type;
+    typedef controlled_runge_kutta< stepper_type > type;
+};
+
+
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp b/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp
new file mode 100644
index 0000000..1cc0f91
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp
@@ -0,0 +1,48 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp
+
+ [begin_description]
+ Enable the factory functions for the controller and the dense output of the
+ Runge-Kutta-Cash-Karp 54 method with the classical implementation.
+ [end_description]
+
+ Copyright 2011 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp>
+#include <boost/numeric/odeint/stepper/generation/make_controlled.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+// Specializations for runge_kutta_cash_karp54
+template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize >
+struct get_controller< runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resize > >
+{
+    typedef runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type;
+    typedef controlled_runge_kutta< stepper_type > type;
+};
+
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp b/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp
new file mode 100644
index 0000000..1a607f3
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp
@@ -0,0 +1,56 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp
+
+ [begin_description]
+ Enable the factory functions for the controller and the dense output of the Runge-Kutta-Dormand-Prince5 method.
+ [end_description]
+
+ Copyright 2011 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp>
+#include <boost/numeric/odeint/stepper/generation/make_controlled.hpp>
+#include <boost/numeric/odeint/stepper/generation/make_dense_output.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize >
+struct get_controller< runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resize > >
+{
+    typedef runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type;
+    typedef controlled_runge_kutta< stepper_type > type;
+};
+
+
+template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize >
+struct get_dense_output< runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resize > >
+{
+    typedef runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type;
+    typedef controlled_runge_kutta< stepper_type > controller_type;
+    typedef dense_output_runge_kutta< controller_type > type;
+};
+
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp b/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp
new file mode 100644
index 0000000..d89343b
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp
@@ -0,0 +1,46 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp
+
+ [begin_description]
+ Enable the factory functions for the controller and the dense output of the Runge-Kutta-Fehlberg 78 method.
+ [end_description]
+
+ Copyright 2011 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_FEHLBERG78_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_FEHLBERG78_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/controlled_runge_kutta.hpp>
+#include <boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp>
+#include <boost/numeric/odeint/stepper/generation/make_controlled.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template< class State , class Value , class Deriv , class Time , class Algebra , class Operations , class Resize >
+struct get_controller< runge_kutta_fehlberg78< State , Value , Deriv , Time , Algebra , Operations , Resize > >
+{
+    typedef runge_kutta_fehlberg78< State , Value , Deriv , Time , Algebra , Operations , Resize > stepper_type;
+    typedef controlled_runge_kutta< stepper_type > type;
+};
+
+
+
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_GENERATION_RUNGE_KUTTA_FEHLBERG78_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/generation/make_controlled.hpp b/include/boost/numeric/odeint/stepper/generation/make_controlled.hpp
new file mode 100644
index 0000000..61bc8f1
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation/make_controlled.hpp
@@ -0,0 +1,103 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation/make_controlled.hpp
+
+ [begin_description]
+ Factory function to simplify the creation of controlled steppers from error steppers.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_CONTROLLED_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_CONTROLLED_HPP_INCLUDED
+
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+// default template for the controller
+template< class Stepper > struct get_controller { };
+
+
+
+// default controller factory
+template< class Stepper , class Controller >
+struct controller_factory
+{
+    Controller operator()(
+            typename Stepper::value_type abs_error ,
+            typename Stepper::value_type rel_error ,
+            const Stepper &stepper )
+    {
+        return Controller( abs_error , rel_error , stepper );
+    }
+
+    Controller operator()(
+            typename Stepper::value_type abs_error ,
+            typename Stepper::value_type rel_error ,
+            typename Stepper::time_type max_dt ,
+            const Stepper &stepper )
+    {
+        return Controller( abs_error , rel_error , max_dt, stepper );
+    }
+};
+
+
+
+
+namespace result_of
+{
+    template< class Stepper >
+    struct make_controlled
+    {
+        typedef typename get_controller< Stepper >::type type;
+    };
+}
+
+
+template< class Stepper >
+typename result_of::make_controlled< Stepper >::type make_controlled(
+        typename Stepper::value_type abs_error ,
+        typename Stepper::value_type rel_error ,
+        const Stepper & stepper = Stepper() )
+{
+    typedef Stepper stepper_type;
+    typedef typename result_of::make_controlled< stepper_type >::type controller_type;
+    typedef controller_factory< stepper_type , controller_type > factory_type;
+    factory_type factory;
+    return factory( abs_error , rel_error , stepper );
+}
+
+
+template< class Stepper >
+typename result_of::make_controlled< Stepper >::type make_controlled(
+        typename Stepper::value_type abs_error ,
+        typename Stepper::value_type rel_error ,
+        typename Stepper::time_type max_dt ,
+        const Stepper & stepper = Stepper() )
+{
+    typedef Stepper stepper_type;
+    typedef typename result_of::make_controlled< stepper_type >::type controller_type;
+    typedef controller_factory< stepper_type , controller_type > factory_type;
+    factory_type factory;
+    return factory( abs_error , rel_error , max_dt, stepper );
+}
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_CONTROLLED_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/generation/make_dense_output.hpp b/include/boost/numeric/odeint/stepper/generation/make_dense_output.hpp
new file mode 100644
index 0000000..fff3590
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/generation/make_dense_output.hpp
@@ -0,0 +1,100 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/generation/make_dense_output.hpp
+
+ [begin_description]
+ Factory function to simplify the creation of dense output steppers from error steppers.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_DENSE_OUTPUT_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_DENSE_OUTPUT_HPP_INCLUDED
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+// default template for the dense output
+template< class Stepper > struct get_dense_output { };
+
+
+
+// default dense output factory
+template< class Stepper , class DenseOutput >
+struct dense_output_factory
+{
+    DenseOutput operator()(
+            typename Stepper::value_type abs_error ,
+            typename Stepper::value_type rel_error ,
+            const Stepper &stepper )
+    {
+        return DenseOutput( abs_error , rel_error , stepper );
+    }
+
+    DenseOutput operator()(
+            typename Stepper::value_type abs_error ,
+            typename Stepper::value_type rel_error ,
+            typename Stepper::time_type max_dt ,
+            const Stepper &stepper )
+    {
+        return DenseOutput( abs_error , rel_error , max_dt , stepper );
+    }
+};
+
+
+
+namespace result_of
+{
+    template< class Stepper >
+    struct make_dense_output
+    {
+        typedef typename get_dense_output< Stepper >::type type;
+    };
+}
+
+
+
+template< class Stepper >
+typename result_of::make_dense_output< Stepper >::type make_dense_output(
+        typename Stepper::value_type abs_error ,
+        typename Stepper::value_type rel_error ,
+        const Stepper &stepper = Stepper() )
+{
+    typedef Stepper stepper_type;
+    typedef typename result_of::make_dense_output< stepper_type >::type dense_output_type;
+    typedef dense_output_factory< stepper_type , dense_output_type > factory_type;
+    factory_type factory;
+    return factory( abs_error , rel_error , stepper );
+}
+
+
+template< class Stepper >
+typename result_of::make_dense_output< Stepper >::type make_dense_output(
+        typename Stepper::value_type abs_error ,
+        typename Stepper::value_type rel_error ,
+        typename Stepper::time_type max_dt ,
+        const Stepper &stepper = Stepper() )
+{
+    typedef Stepper stepper_type;
+    typedef typename result_of::make_dense_output< stepper_type >::type dense_output_type;
+    typedef dense_output_factory< stepper_type , dense_output_type > factory_type;
+    factory_type factory;
+    return factory( abs_error , rel_error , max_dt, stepper );
+}
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_GENERATION_MAKE_DENSE_OUTPUT_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/implicit_euler.hpp b/include/boost/numeric/odeint/stepper/implicit_euler.hpp
new file mode 100644
index 0000000..e1c6416
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/implicit_euler.hpp
@@ -0,0 +1,170 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/implicit_euler.hpp
+
+ [begin_description]
+ Impementation of the implicit Euler method. Works with ublas::vector as state type.
+ [end_description]
+
+ Copyright 2010-2012 Mario Mulansky
+ Copyright 2010-2012 Karsten Ahnert
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_IMPLICIT_EULER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_IMPLICIT_EULER_HPP_INCLUDED
+
+
+#include <utility>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/util/ublas_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/lu.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+
+
+
+
+
+template< class ValueType , class Resizer = initially_resizer >
+class implicit_euler
+{
+
+public:
+
+    typedef ValueType value_type;
+    typedef value_type time_type;
+    typedef boost::numeric::ublas::vector< value_type > state_type;
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef state_type deriv_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef boost::numeric::ublas::matrix< value_type > matrix_type;
+    typedef state_wrapper< matrix_type > wrapped_matrix_type;
+    typedef boost::numeric::ublas::permutation_matrix< size_t > pmatrix_type;
+    typedef state_wrapper< pmatrix_type > wrapped_pmatrix_type;
+    typedef Resizer resizer_type;
+    typedef stepper_tag stepper_category;
+    typedef implicit_euler< ValueType , Resizer > stepper_type;
+
+    implicit_euler( value_type epsilon = 1E-6 )
+    : m_epsilon( epsilon ) 
+    { }
+
+
+    template< class System >
+    void do_step( System system , state_type &x , time_type t , time_type dt )
+    {
+        typedef typename odeint::unwrap_reference< System >::type system_type;
+        typedef typename odeint::unwrap_reference< typename system_type::first_type >::type deriv_func_type;
+        typedef typename odeint::unwrap_reference< typename system_type::second_type >::type jacobi_func_type;
+        system_type &sys = system;
+        deriv_func_type &deriv_func = sys.first;
+        jacobi_func_type &jacobi_func = sys.second;
+
+        m_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_impl<state_type> , detail::ref( *this ) , detail::_1 ) );
+
+        for( size_t i=0 ; i<x.size() ; ++i )
+            m_pm.m_v[i] = i;
+
+        t += dt;
+
+        // apply first Newton step
+        deriv_func( x , m_dxdt.m_v , t );
+
+        m_b.m_v = dt * m_dxdt.m_v;
+
+        jacobi_func( x , m_jacobi.m_v  , t );
+        m_jacobi.m_v *= dt;
+        m_jacobi.m_v -= boost::numeric::ublas::identity_matrix< value_type >( x.size() );
+
+        solve( m_b.m_v , m_jacobi.m_v );
+
+        m_x.m_v = x - m_b.m_v;
+
+        // iterate Newton until some precision is reached
+        // ToDo: maybe we should apply only one Newton step -> linear implicit one-step scheme
+        while( boost::numeric::ublas::norm_2( m_b.m_v ) > m_epsilon )
+        {
+            deriv_func( m_x.m_v , m_dxdt.m_v , t );
+            m_b.m_v = x - m_x.m_v + dt*m_dxdt.m_v;
+
+            // simplified version, only the first Jacobian is used
+            //            jacobi( m_x , m_jacobi , t );
+            //            m_jacobi *= dt;
+            //            m_jacobi -= boost::numeric::ublas::identity_matrix< value_type >( x.size() );
+
+            solve( m_b.m_v , m_jacobi.m_v );
+
+            m_x.m_v -= m_b.m_v;
+        }
+        x = m_x.m_v;
+    }
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_impl( x );
+    }
+
+
+private:
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_b , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_jacobi , x , typename is_resizeable<matrix_type>::type() );
+        resized |= adjust_size_by_resizeability( m_pm , x , typename is_resizeable<pmatrix_type>::type() );
+        return resized;
+    }
+
+
+    void solve( state_type &x , matrix_type &m )
+    {
+        int res = boost::numeric::ublas::lu_factorize( m , m_pm.m_v );
+        if( res != 0 ) std::exit(0);
+        boost::numeric::ublas::lu_substitute( m , m_pm.m_v , x );
+    }
+
+private:
+
+    value_type m_epsilon;
+    resizer_type m_resizer;
+    wrapped_deriv_type m_dxdt;
+    wrapped_state_type m_x;
+    wrapped_deriv_type m_b;
+    wrapped_matrix_type m_jacobi;
+    wrapped_pmatrix_type m_pm;
+
+
+};
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_IMPLICIT_EULER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/modified_midpoint.hpp b/include/boost/numeric/odeint/stepper/modified_midpoint.hpp
new file mode 100644
index 0000000..9e34c7d
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/modified_midpoint.hpp
@@ -0,0 +1,315 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/modified_midpoint.hpp
+
+ [begin_description]
+ Modified midpoint method for the use in Burlish-Stoer stepper.
+ [end_description]
+
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_MODIFIED_MIDPOINT_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_MODIFIED_MIDPOINT_HPP_INCLUDED
+
+#include <vector>
+
+#include <boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template<
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+#ifndef DOXYGEN_SKIP
+class modified_midpoint
+: public explicit_stepper_base<
+  modified_midpoint< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+  2 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
+#else
+class modified_midpoint : public explicit_stepper_base
+#endif
+{
+
+public :
+
+    typedef explicit_stepper_base<
+    modified_midpoint< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+    2 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type;
+
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+    typedef typename stepper_base_type::stepper_type stepper_type;
+
+
+    modified_midpoint( unsigned short steps = 2 , const algebra_type &algebra = algebra_type() )
+    : stepper_base_type( algebra ) , m_steps( steps )
+    { }
+
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+    {
+        static const value_type val1 = static_cast< value_type >( 1 );
+        static const value_type val05 = static_cast< value_type >( 1 ) / static_cast< value_type >( 2 );
+
+        m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) );
+
+        const time_type h = dt /  static_cast<value_type>( m_steps );
+        const time_type h2 = static_cast<value_type>(2) * h;
+
+        typename odeint::unwrap_reference< System >::type &sys = system;
+
+        time_type th = t + h;
+
+        // m_x1 = x + h*dxdt
+        stepper_base_type::m_algebra.for_each3( m_x1.m_v , in , dxdt ,
+                typename operations_type::template scale_sum2< value_type , time_type >( val1 , h ) );
+
+        sys( m_x1.m_v , m_dxdt.m_v , th );
+
+        boost::numeric::odeint::copy( in , m_x0.m_v );
+
+        unsigned short i = 1;
+        while( i != m_steps )
+        {
+            // general step
+            //tmp = m_x1; m_x1 = m_x0 + h2*m_dxdt; m_x0 = tmp
+            stepper_base_type::m_algebra.for_each3( m_x1.m_v , m_x0.m_v , m_dxdt.m_v ,
+                    typename operations_type::template scale_sum_swap2< value_type , time_type >( val1 , h2 ) );
+            th += h;
+            sys( m_x1.m_v , m_dxdt.m_v , th);
+            i++;
+        }
+
+        // last step
+        // x = 0.5*( m_x0 + m_x1 + h*m_dxdt )
+        stepper_base_type::m_algebra.for_each4( out , m_x0.m_v , m_x1.m_v , m_dxdt.m_v ,
+                typename operations_type::template scale_sum3< value_type , value_type , time_type >( val05 , val05 , val05*h ) );
+    }
+
+
+    void set_steps( unsigned short steps )
+    {   m_steps = steps; }
+
+
+    unsigned short steps( void ) const
+    {   return m_steps; }
+
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_impl( x );
+        stepper_base_type::adjust_size( x );
+    }
+
+private:
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized( false );
+        resized |= adjust_size_by_resizeability( m_x0 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+        return resized;
+    }
+
+
+    unsigned short m_steps;
+
+    resizer_type m_resizer;
+
+    wrapped_state_type m_x0;
+    wrapped_state_type m_x1;
+    wrapped_deriv_type m_dxdt;
+
+};
+
+
+/* Modified midpoint which stores derivatives and state at dt/2 in some external storage for later usage in dense output calculation
+ * This Stepper is for use in Bulirsch Stoer only. It DOES NOT meet any stepper concept.
+ */
+template<
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+class modified_midpoint_dense_out
+{
+
+public :
+
+    typedef State state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef Time time_type;
+    typedef Algebra algebra_type;
+    typedef Operations operations_type;
+    typedef Resizer resizer_type;
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+
+    typedef modified_midpoint_dense_out< State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_type;
+    typedef std::vector< wrapped_deriv_type > deriv_table_type;
+
+    modified_midpoint_dense_out( unsigned short steps = 2 , const algebra_type &algebra = algebra_type() )
+    : m_algebra( algebra ) , m_steps( steps )
+    { }
+
+    /*
+     * performs a modified midpoint step with m_steps intermediate points
+     * stores approximation for x(t+dt/2) in x_mp and all evaluated function results in derivs
+     *
+     */
+
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    void do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt ,
+            state_type &x_mp , deriv_table_type &derivs )
+    {
+
+        static const value_type val1 = static_cast< value_type >( 1 );
+        static const value_type val05 = static_cast< value_type >( 1 ) / static_cast< value_type >( 2 );
+
+        m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize< StateIn > , detail::ref( *this ) , detail::_1 ) );
+
+        const time_type h = dt / static_cast<value_type>( m_steps );
+        const time_type h2 = static_cast<value_type>( 2 ) * h;
+
+        typename odeint::unwrap_reference< System >::type &sys = system;
+
+        time_type th = t + h;
+
+        // m_x1 = x + h*dxdt
+        m_algebra.for_each3( m_x1.m_v , in , dxdt ,
+                typename operations_type::template scale_sum2< value_type , time_type >( val1 , h ) );
+
+        if( m_steps == 2 )
+            // result of first step already gives approximation at the center of the interval
+            boost::numeric::odeint::copy( m_x1.m_v , x_mp );
+
+        sys( m_x1.m_v , derivs[0].m_v , th );
+
+        boost::numeric::odeint::copy( in , m_x0.m_v );
+
+        unsigned short i = 1;
+        while( i != m_steps )
+        {
+            // general step
+            //tmp = m_x1; m_x1 = m_x0 + h2*m_dxdt; m_x0 = tmp
+            m_algebra.for_each3( m_x1.m_v , m_x0.m_v , derivs[i-1].m_v ,
+                    typename operations_type::template scale_sum_swap2< value_type , time_type >( val1 , h2 ) );
+            if( i == m_steps/2-1 )
+                // save approximation at the center of the interval
+                boost::numeric::odeint::copy( m_x1.m_v , x_mp );
+
+            th += h;
+            sys( m_x1.m_v , derivs[i].m_v , th);
+            i++;
+        }
+
+        // last step
+        // x = 0.5*( m_x0 + m_x1 + h*m_dxdt )
+        m_algebra.for_each4( out , m_x0.m_v , m_x1.m_v , derivs[m_steps-1].m_v ,
+                typename operations_type::template scale_sum3< value_type , value_type , time_type >( val05 , val05 , val05*h ) );
+    }
+
+
+    void set_steps( unsigned short steps )
+    {   m_steps = steps; }
+
+
+    unsigned short steps( void ) const
+    {   return m_steps; }
+
+
+    template< class StateIn >
+    bool resize( const StateIn &x )
+    {
+        bool resized( false );
+        resized |= adjust_size_by_resizeability( m_x0 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() );
+        return resized;
+    }
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize( x );
+    }
+
+private:
+
+    algebra_type m_algebra;
+
+    unsigned short m_steps;
+
+    resizer_type m_resizer;
+
+    wrapped_state_type m_x0;
+    wrapped_state_type m_x1;
+
+};
+
+
+
+/********** DOXYGEN ***********/
+
+/**
+ * \class modified_midpoint
+ *
+ * Implementation of the modified midpoint method with a configurable 
+ * number of intermediate steps. This class is used by the Bulirsch-Stoer
+ * algorithm and is not meant for direct usage.
+ */
+
+
+/**
+ * \class modified_midpoint_dense_out
+ *
+ * Implementation of the modified midpoint method with a configurable 
+ * number of intermediate steps. This class is used by the dense output
+ * Bulirsch-Stoer algorithm and is not meant for direct usage.
+ * \note This stepper is for internal use only and does not meet 
+ * any stepper concept.
+ */
+
+
+}
+}
+}
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_MODIFIED_MIDPOINT_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/rosenbrock4.hpp b/include/boost/numeric/odeint/stepper/rosenbrock4.hpp
new file mode 100644
index 0000000..8613698
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/rosenbrock4.hpp
@@ -0,0 +1,346 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/rosenbrock4.hpp
+
+ [begin_description]
+ Implementation of the Rosenbrock 4 method for solving stiff ODEs. Note, that a
+ controller and a dense-output stepper exist for this method,
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/lu.hpp>
+
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/util/ublas_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/lu.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * ToDo:
+ *
+ * 2. Interfacing for odeint, check if controlled_error_stepper can be used
+ * 3. dense output
+ */
+
+
+
+template< class Value >
+struct default_rosenbrock_coefficients
+{
+    typedef Value value_type;
+    typedef unsigned short order_type;
+
+    default_rosenbrock_coefficients( void )
+    : gamma ( static_cast< value_type >( 0.25 ) ) ,
+      d1 ( static_cast< value_type >( 0.25 ) ) ,
+      d2 ( static_cast< value_type >( -0.1043 ) ) ,
+      d3 ( static_cast< value_type >( 0.1035 ) ) ,
+      d4 ( static_cast< value_type >( 0.3620000000000023e-01 ) ) ,
+      c2 ( static_cast< value_type >( 0.386 ) ) ,
+      c3 ( static_cast< value_type >( 0.21 ) ) ,
+      c4 ( static_cast< value_type >( 0.63 ) ) ,
+      c21 ( static_cast< value_type >( -0.5668800000000000e+01 ) ) ,
+      a21 ( static_cast< value_type >( 0.1544000000000000e+01 ) ) ,
+      c31 ( static_cast< value_type >( -0.2430093356833875e+01 ) ) ,
+      c32 ( static_cast< value_type >( -0.2063599157091915e+00 ) ) ,
+      a31 ( static_cast< value_type >( 0.9466785280815826e+00 ) ) ,
+      a32 ( static_cast< value_type >( 0.2557011698983284e+00 ) ) ,
+      c41 ( static_cast< value_type >( -0.1073529058151375e+00 ) ) ,
+      c42 ( static_cast< value_type >( -0.9594562251023355e+01 ) ) ,
+      c43 ( static_cast< value_type >( -0.2047028614809616e+02 ) ) ,
+      a41 ( static_cast< value_type >( 0.3314825187068521e+01 ) ) ,
+      a42 ( static_cast< value_type >( 0.2896124015972201e+01 ) ) ,
+      a43 ( static_cast< value_type >( 0.9986419139977817e+00 ) ) ,
+      c51 ( static_cast< value_type >( 0.7496443313967647e+01 ) ) ,
+      c52 ( static_cast< value_type >( -0.1024680431464352e+02 ) ) ,
+      c53 ( static_cast< value_type >( -0.3399990352819905e+02 ) ) ,
+      c54 ( static_cast< value_type >(  0.1170890893206160e+02 ) ) ,
+      a51 ( static_cast< value_type >( 0.1221224509226641e+01 ) ) ,
+      a52 ( static_cast< value_type >( 0.6019134481288629e+01 ) ) ,
+      a53 ( static_cast< value_type >( 0.1253708332932087e+02 ) ) ,
+      a54 ( static_cast< value_type >( -0.6878860361058950e+00 ) ) ,
+      c61 ( static_cast< value_type >( 0.8083246795921522e+01 ) ) ,
+      c62 ( static_cast< value_type >( -0.7981132988064893e+01 ) ) ,
+      c63 ( static_cast< value_type >( -0.3152159432874371e+02 ) ) ,
+      c64 ( static_cast< value_type >( 0.1631930543123136e+02 ) ) ,
+      c65 ( static_cast< value_type >( -0.6058818238834054e+01 ) ) ,
+      d21 ( static_cast< value_type >( 0.1012623508344586e+02 ) ) ,
+      d22 ( static_cast< value_type >( -0.7487995877610167e+01 ) ) ,
+      d23 ( static_cast< value_type >( -0.3480091861555747e+02 ) ) ,
+      d24 ( static_cast< value_type >( -0.7992771707568823e+01 ) ) ,
+      d25 ( static_cast< value_type >( 0.1025137723295662e+01 ) ) ,
+      d31 ( static_cast< value_type >( -0.6762803392801253e+00 ) ) ,
+      d32 ( static_cast< value_type >( 0.6087714651680015e+01 ) ) ,
+      d33 ( static_cast< value_type >( 0.1643084320892478e+02 ) ) ,
+      d34 ( static_cast< value_type >( 0.2476722511418386e+02 ) ) ,
+      d35 ( static_cast< value_type >( -0.6594389125716872e+01 ) )
+    {}
+
+    const value_type gamma;
+    const value_type d1 , d2 , d3 , d4;
+    const value_type c2 , c3 , c4;
+    const value_type c21 ;
+    const value_type a21;
+    const value_type c31 , c32;
+    const value_type a31 , a32;
+    const value_type c41 , c42 , c43;
+    const value_type a41 , a42 , a43;
+    const value_type c51 , c52 , c53 , c54;
+    const value_type a51 , a52 , a53 , a54;
+    const value_type c61 , c62 , c63 , c64 , c65;
+    const value_type d21 , d22 , d23 , d24 , d25;
+    const value_type d31 , d32 , d33 , d34 , d35;
+
+    static const order_type stepper_order = 4;
+    static const order_type error_order = 3;
+};
+
+
+
+template< class Value , class Coefficients = default_rosenbrock_coefficients< Value > , class Resizer = initially_resizer >
+class rosenbrock4
+{
+private:
+
+public:
+
+    typedef Value value_type;
+    typedef boost::numeric::ublas::vector< value_type > state_type;
+    typedef state_type deriv_type;
+    typedef value_type time_type;
+    typedef boost::numeric::ublas::matrix< value_type > matrix_type;
+    typedef boost::numeric::ublas::permutation_matrix< size_t > pmatrix_type;
+    typedef Resizer resizer_type;
+    typedef Coefficients rosenbrock_coefficients;
+    typedef stepper_tag stepper_category;
+    typedef unsigned short order_type;
+
+    typedef state_wrapper< state_type > wrapped_state_type;
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef state_wrapper< matrix_type > wrapped_matrix_type;
+    typedef state_wrapper< pmatrix_type > wrapped_pmatrix_type;
+
+    typedef rosenbrock4< Value , Coefficients , Resizer > stepper_type;
+
+    const static order_type stepper_order = rosenbrock_coefficients::stepper_order;
+    const static order_type error_order = rosenbrock_coefficients::error_order;
+
+    rosenbrock4( void )
+    : m_resizer() , m_x_err_resizer() ,
+      m_jac() , m_pm() ,
+      m_dfdt() , m_dxdt() , m_dxdtnew() ,
+      m_g1() , m_g2() , m_g3() , m_g4() , m_g5() ,
+      m_cont3() , m_cont4() , m_xtmp() , m_x_err() ,
+      m_coef()
+    { }
+
+
+    order_type order() const { return stepper_order; } 
+
+    template< class System >
+    void do_step( System system , const state_type &x , time_type t , state_type &xout , time_type dt , state_type &xerr )
+    {
+        // get the system and jacobi function
+        typedef typename odeint::unwrap_reference< System >::type system_type;
+        typedef typename odeint::unwrap_reference< typename system_type::first_type >::type deriv_func_type;
+        typedef typename odeint::unwrap_reference< typename system_type::second_type >::type jacobi_func_type;
+        system_type &sys = system;
+        deriv_func_type &deriv_func = sys.first;
+        jacobi_func_type &jacobi_func = sys.second;
+
+        const size_t n = x.size();
+
+        m_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_impl<state_type> , detail::ref( *this ) , detail::_1 ) );
+
+        for( size_t i=0 ; i<n ; ++i )
+            m_pm.m_v( i ) = i;
+
+        deriv_func( x , m_dxdt.m_v , t );
+        jacobi_func( x , m_jac.m_v , t , m_dfdt.m_v );
+
+        m_jac.m_v *= -1.0;
+        m_jac.m_v += 1.0 / m_coef.gamma / dt * boost::numeric::ublas::identity_matrix< value_type >( n );
+        boost::numeric::ublas::lu_factorize( m_jac.m_v , m_pm.m_v );
+
+        for( size_t i=0 ; i<n ; ++i )
+            m_g1.m_v[i] = m_dxdt.m_v[i] + dt * m_coef.d1 * m_dfdt.m_v[i];
+        boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g1.m_v );
+
+
+        for( size_t i=0 ; i<n ; ++i )
+            m_xtmp.m_v[i] = x[i] + m_coef.a21 * m_g1.m_v[i];
+        deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + m_coef.c2 * dt );
+        for( size_t i=0 ; i<n ; ++i )
+            m_g2.m_v[i] = m_dxdtnew.m_v[i] + dt * m_coef.d2 * m_dfdt.m_v[i] + m_coef.c21 * m_g1.m_v[i] / dt;
+        boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g2.m_v );
+
+
+        for( size_t i=0 ; i<n ; ++i )
+            m_xtmp.m_v[i] = x[i] + m_coef.a31 * m_g1.m_v[i] + m_coef.a32 * m_g2.m_v[i];
+        deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + m_coef.c3 * dt );
+        for( size_t i=0 ; i<n ; ++i )
+            m_g3.m_v[i] = m_dxdtnew.m_v[i] + dt * m_coef.d3 * m_dfdt.m_v[i] + ( m_coef.c31 * m_g1.m_v[i] + m_coef.c32 * m_g2.m_v[i] ) / dt;
+        boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g3.m_v );
+
+
+        for( size_t i=0 ; i<n ; ++i )
+            m_xtmp.m_v[i] = x[i] + m_coef.a41 * m_g1.m_v[i] + m_coef.a42 * m_g2.m_v[i] + m_coef.a43 * m_g3.m_v[i];
+        deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + m_coef.c4 * dt );
+        for( size_t i=0 ; i<n ; ++i )
+            m_g4.m_v[i] = m_dxdtnew.m_v[i] + dt * m_coef.d4 * m_dfdt.m_v[i] + ( m_coef.c41 * m_g1.m_v[i] + m_coef.c42 * m_g2.m_v[i] + m_coef.c43 * m_g3.m_v[i] ) / dt;
+        boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g4.m_v );
+
+
+        for( size_t i=0 ; i<n ; ++i )
+            m_xtmp.m_v[i] = x[i] + m_coef.a51 * m_g1.m_v[i] + m_coef.a52 * m_g2.m_v[i] + m_coef.a53 * m_g3.m_v[i] + m_coef.a54 * m_g4.m_v[i];
+        deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + dt );
+        for( size_t i=0 ; i<n ; ++i )
+            m_g5.m_v[i] = m_dxdtnew.m_v[i] + ( m_coef.c51 * m_g1.m_v[i] + m_coef.c52 * m_g2.m_v[i] + m_coef.c53 * m_g3.m_v[i] + m_coef.c54 * m_g4.m_v[i] ) / dt;
+        boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , m_g5.m_v );
+
+        for( size_t i=0 ; i<n ; ++i )
+            m_xtmp.m_v[i] += m_g5.m_v[i];
+        deriv_func( m_xtmp.m_v , m_dxdtnew.m_v , t + dt );
+        for( size_t i=0 ; i<n ; ++i )
+            xerr[i] = m_dxdtnew.m_v[i] + ( m_coef.c61 * m_g1.m_v[i] + m_coef.c62 * m_g2.m_v[i] + m_coef.c63 * m_g3.m_v[i] + m_coef.c64 * m_g4.m_v[i] + m_coef.c65 * m_g5.m_v[i] ) / dt;
+        boost::numeric::ublas::lu_substitute( m_jac.m_v , m_pm.m_v , xerr );
+
+        for( size_t i=0 ; i<n ; ++i )
+            xout[i] = m_xtmp.m_v[i] + xerr[i];
+    }
+
+    template< class System >
+    void do_step( System system , state_type &x , time_type t , time_type dt , state_type &xerr )
+    {
+        do_step( system , x , t , x , dt , xerr );
+    }
+
+    /*
+     * do_step without error output - just calls above functions with and neglects the error estimate
+     */
+    template< class System >
+    void do_step( System system , const state_type &x , time_type t , state_type &xout , time_type dt )
+    {
+        m_x_err_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_x_err<state_type> , detail::ref( *this ) , detail::_1 ) );
+        do_step( system , x , t , xout , dt , m_x_err.m_v );
+    }
+
+    template< class System >
+    void do_step( System system , state_type &x , time_type t , time_type dt )
+    {
+        m_x_err_resizer.adjust_size( x , detail::bind( &stepper_type::template resize_x_err<state_type> , detail::ref( *this ) , detail::_1 ) );
+        do_step( system , x , t , dt , m_x_err.m_v );
+    }
+
+    void prepare_dense_output()
+    {
+        const size_t n = m_g1.m_v.size();
+        for( size_t i=0 ; i<n ; ++i )
+        {
+            m_cont3.m_v[i] = m_coef.d21 * m_g1.m_v[i] + m_coef.d22 * m_g2.m_v[i] + m_coef.d23 * m_g3.m_v[i] + m_coef.d24 * m_g4.m_v[i] + m_coef.d25 * m_g5.m_v[i];
+            m_cont4.m_v[i] = m_coef.d31 * m_g1.m_v[i] + m_coef.d32 * m_g2.m_v[i] + m_coef.d33 * m_g3.m_v[i] + m_coef.d34 * m_g4.m_v[i] + m_coef.d35 * m_g5.m_v[i];
+        }
+    }
+
+
+    void calc_state( time_type t , state_type &x ,
+            const state_type &x_old , time_type t_old ,
+            const state_type &x_new , time_type t_new )
+    {
+        const size_t n = m_g1.m_v.size();
+        time_type dt = t_new - t_old;
+        time_type s = ( t - t_old ) / dt;
+        time_type s1 = 1.0 - s;
+        for( size_t i=0 ; i<n ; ++i )
+            x[i] = x_old[i] * s1 + s * ( x_new[i] + s1 * ( m_cont3.m_v[i] + s * m_cont4.m_v[i] ) );
+    }
+
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_impl( x );
+        resize_x_err( x );
+    }
+
+
+protected:
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dfdt , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxdtnew , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_xtmp , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_g1 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_g2 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_g3 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_g4 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_g5 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_cont3 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_cont4 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_jac , x , typename is_resizeable<matrix_type>::type() );
+        resized |= adjust_size_by_resizeability( m_pm , x , typename is_resizeable<pmatrix_type>::type() );
+        return resized;
+    }
+
+    template< class StateIn >
+    bool resize_x_err( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_x_err , x , typename is_resizeable<state_type>::type() );
+    }
+
+private:
+
+
+    resizer_type m_resizer;
+    resizer_type m_x_err_resizer;
+
+    wrapped_matrix_type m_jac;
+    wrapped_pmatrix_type m_pm;
+    wrapped_deriv_type m_dfdt , m_dxdt , m_dxdtnew;
+    wrapped_state_type m_g1 , m_g2 , m_g3 , m_g4 , m_g5;
+    wrapped_state_type m_cont3 , m_cont4;
+    wrapped_state_type m_xtmp;
+    wrapped_state_type m_x_err;
+
+    const rosenbrock_coefficients m_coef;
+};
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp b/include/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp
new file mode 100644
index 0000000..61d6e51
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp
@@ -0,0 +1,240 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/rosenbrock4_controller.hpp
+
+ [begin_description]
+ Controller for the Rosenbrock4 method.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_CONTROLLER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_CONTROLLER_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/util/copy.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
+
+#include <boost/numeric/odeint/stepper/rosenbrock4.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class Stepper >
+class rosenbrock4_controller
+{
+private:
+
+
+public:
+
+    typedef Stepper stepper_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_type::resizer_type resizer_type;
+    typedef controlled_stepper_tag stepper_category;
+
+    typedef rosenbrock4_controller< Stepper > controller_type;
+
+
+    rosenbrock4_controller( value_type atol = 1.0e-6 , value_type rtol = 1.0e-6 ,
+                            const stepper_type &stepper = stepper_type() )
+        : m_stepper( stepper ) , m_atol( atol ) , m_rtol( rtol ) ,
+          m_max_dt( static_cast<time_type>(0) ) ,
+          m_first_step( true ) , m_err_old( 0.0 ) , m_dt_old( 0.0 ) ,
+          m_last_rejected( false )
+    { }
+
+    rosenbrock4_controller( value_type atol, value_type rtol, time_type max_dt,
+                            const stepper_type &stepper = stepper_type() )
+            : m_stepper( stepper ) , m_atol( atol ) , m_rtol( rtol ) , m_max_dt( max_dt ) ,
+              m_first_step( true ) , m_err_old( 0.0 ) , m_dt_old( 0.0 ) ,
+              m_last_rejected( false )
+    { }
+
+    value_type error( const state_type &x , const state_type &xold , const state_type &xerr )
+    {
+        BOOST_USING_STD_MAX();
+        using std::abs;
+        using std::sqrt;
+        
+        const size_t n = x.size();
+        value_type err = 0.0 , sk = 0.0;
+        for( size_t i=0 ; i<n ; ++i )
+        {
+            sk = m_atol + m_rtol * max BOOST_PREVENT_MACRO_SUBSTITUTION ( abs( xold[i] ) , abs( x[i] ) );
+            err += xerr[i] * xerr[i] / sk / sk;
+        }
+        return sqrt( err / value_type( n ) );
+    }
+
+    value_type last_error( void ) const
+    {
+        return m_err_old;
+    }
+
+
+
+
+    template< class System >
+    boost::numeric::odeint::controlled_step_result
+    try_step( System sys , state_type &x , time_type &t , time_type &dt )
+    {
+        m_xnew_resizer.adjust_size( x , detail::bind( &controller_type::template resize_m_xnew< state_type > , detail::ref( *this ) , detail::_1 ) );
+        boost::numeric::odeint::controlled_step_result res = try_step( sys , x , t , m_xnew.m_v , dt );
+        if( res == success )
+        {
+            boost::numeric::odeint::copy( m_xnew.m_v , x );
+        }
+        return res;
+    }
+
+
+    template< class System >
+    boost::numeric::odeint::controlled_step_result
+    try_step( System sys , const state_type &x , time_type &t , state_type &xout , time_type &dt )
+    {
+        if( m_max_dt != static_cast<time_type>(0) && detail::less_with_sign(m_max_dt, dt, dt) )
+        {
+            // given step size is bigger then max_dt
+            // set limit and return fail
+            dt = m_max_dt;
+            return fail;
+        }
+
+        BOOST_USING_STD_MIN();
+        BOOST_USING_STD_MAX();
+        using std::pow;
+
+        static const value_type safe = 0.9 , fac1 = 5.0 , fac2 = 1.0 / 6.0;
+
+        m_xerr_resizer.adjust_size( x , detail::bind( &controller_type::template resize_m_xerr< state_type > , detail::ref( *this ) , detail::_1 ) );
+
+        m_stepper.do_step( sys , x , t , xout , dt , m_xerr.m_v );
+        value_type err = error( xout , x , m_xerr.m_v );
+
+        value_type fac = max BOOST_PREVENT_MACRO_SUBSTITUTION (
+            fac2 , min BOOST_PREVENT_MACRO_SUBSTITUTION (
+                fac1 ,
+                static_cast< value_type >( pow( err , 0.25 ) / safe ) ) );
+        value_type dt_new = dt / fac;
+        if ( err <= 1.0 )
+        {
+            if( m_first_step )
+            {
+                m_first_step = false;
+            }
+            else
+            {
+                value_type fac_pred = ( m_dt_old / dt ) * pow( err * err / m_err_old , 0.25 ) / safe;
+                fac_pred = max BOOST_PREVENT_MACRO_SUBSTITUTION (
+                    fac2 , min BOOST_PREVENT_MACRO_SUBSTITUTION ( fac1 , fac_pred ) );
+                fac = max BOOST_PREVENT_MACRO_SUBSTITUTION ( fac , fac_pred );
+                dt_new = dt / fac;
+            }
+
+            m_dt_old = dt;
+            m_err_old = max BOOST_PREVENT_MACRO_SUBSTITUTION ( static_cast< value_type >( 0.01 ) , err );
+            if( m_last_rejected )
+                dt_new = ( dt >= 0.0 ?
+                min BOOST_PREVENT_MACRO_SUBSTITUTION ( dt_new , dt ) :
+                max BOOST_PREVENT_MACRO_SUBSTITUTION ( dt_new , dt ) );
+            t += dt;
+            // limit step size to max_dt
+            if( m_max_dt != static_cast<time_type>(0) )
+            {
+                dt = detail::min_abs(m_max_dt, dt_new);
+            } else {
+                dt = dt_new;
+            }
+            m_last_rejected = false;
+            return success;
+        }
+        else
+        {
+            dt = dt_new;
+            m_last_rejected = true;
+            return fail;
+        }
+    }
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_m_xerr( x );
+        resize_m_xnew( x );
+    }
+
+
+
+    stepper_type& stepper( void )
+    {
+        return m_stepper;
+    }
+
+    const stepper_type& stepper( void ) const
+    {
+        return m_stepper;
+    }
+
+
+
+
+private:
+
+    template< class StateIn >
+    bool resize_m_xerr( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_xerr , x , typename is_resizeable<state_type>::type() );
+    }
+
+    template< class StateIn >
+    bool resize_m_xnew( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_xnew , x , typename is_resizeable<state_type>::type() );
+    }
+
+
+    stepper_type m_stepper;
+    resizer_type m_xerr_resizer;
+    resizer_type m_xnew_resizer;
+    wrapped_state_type m_xerr;
+    wrapped_state_type m_xnew;
+    value_type m_atol , m_rtol;
+    time_type m_max_dt;
+    bool m_first_step;
+    value_type m_err_old , m_dt_old;
+    bool m_last_rejected;
+};
+
+
+
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_CONTROLLER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp b/include/boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp
new file mode 100644
index 0000000..6695ba6
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp
@@ -0,0 +1,199 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp
+
+ [begin_description]
+ Dense output for Rosenbrock 4.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2015 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_DENSE_OUTPUT_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_DENSE_OUTPUT_HPP_INCLUDED
+
+
+#include <utility>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/numeric/odeint/stepper/rosenbrock4_controller.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+
+#include <boost/numeric/odeint/integrate/max_step_checker.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class ControlledStepper >
+class rosenbrock4_dense_output
+{
+
+public:
+
+    typedef ControlledStepper controlled_stepper_type;
+    typedef typename controlled_stepper_type::stepper_type stepper_type;
+    typedef typename stepper_type::value_type value_type;
+    typedef typename stepper_type::state_type state_type;
+    typedef typename stepper_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_type::time_type time_type;
+    typedef typename stepper_type::deriv_type deriv_type;
+    typedef typename stepper_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_type::resizer_type resizer_type;
+    typedef dense_output_stepper_tag stepper_category;
+
+    typedef rosenbrock4_dense_output< ControlledStepper > dense_output_stepper_type;
+
+    rosenbrock4_dense_output( const controlled_stepper_type &stepper = controlled_stepper_type() )
+    : m_stepper( stepper ) ,
+      m_x1() , m_x2() , 
+      m_current_state_x1( true ) ,
+      m_t() , m_t_old() , m_dt()
+    {
+    }
+
+
+
+    template< class StateType >
+    void initialize( const StateType &x0 , time_type t0 , time_type dt0 )
+    {
+        m_resizer.adjust_size( x0 , detail::bind( &dense_output_stepper_type::template resize_impl< StateType > , detail::ref( *this ) , detail::_1 ) );
+        get_current_state() = x0;
+        m_t = t0;
+        m_dt = dt0;
+    }
+
+    template< class System >
+    std::pair< time_type , time_type > do_step( System system )
+    {
+        failed_step_checker fail_checker;  // to throw a runtime_error if step size adjustment fails
+        controlled_step_result res = fail;
+        m_t_old = m_t;
+        do
+        {
+            res = m_stepper.try_step( system , get_current_state() , m_t , get_old_state() , m_dt );
+            fail_checker();  // check for overflow of failed steps
+        }
+        while( res == fail );
+        m_stepper.stepper().prepare_dense_output();
+        this->toggle_current_state();
+        return std::make_pair( m_t_old , m_t );
+    }
+
+
+    /*
+     * The two overloads are needed in order to solve the forwarding problem.
+     */
+    template< class StateOut >
+    void calc_state( time_type t , StateOut &x )
+    {
+        m_stepper.stepper().calc_state( t , x , get_old_state() , m_t_old , get_current_state() , m_t );
+    }
+
+    template< class StateOut >
+    void calc_state( time_type t , const StateOut &x )
+    {
+        m_stepper.stepper().calc_state( t , x , get_old_state() , m_t_old , get_current_state() , m_t );
+    }
+
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        m_stepper.adjust_size( x );
+        resize_impl( x );
+    }
+
+
+
+
+    const state_type& current_state( void ) const
+    {
+        return get_current_state();
+    }
+
+    time_type current_time( void ) const
+    {
+        return m_t;
+    }
+
+    const state_type& previous_state( void ) const
+    {
+        return get_old_state();
+    }
+
+    time_type previous_time( void ) const
+    {
+        return m_t_old;
+    }
+
+    time_type current_time_step( void ) const
+    {
+        return m_dt;
+    }
+
+
+
+
+private:
+
+    state_type& get_current_state( void )
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    const state_type& get_current_state( void ) const
+    {
+        return m_current_state_x1 ? m_x1.m_v : m_x2.m_v ;
+    }
+    
+    state_type& get_old_state( void )
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+    
+    const state_type& get_old_state( void ) const
+    {
+        return m_current_state_x1 ? m_x2.m_v : m_x1.m_v ;
+    }
+
+    void toggle_current_state( void )
+    {
+        m_current_state_x1 = ! m_current_state_x1;
+    }
+
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() );
+        return resized;
+    }
+
+
+    controlled_stepper_type m_stepper;
+    resizer_type m_resizer;
+    wrapped_state_type m_x1 , m_x2;
+    bool m_current_state_x1;
+    time_type m_t , m_t_old , m_dt;
+};
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_ROSENBROCK4_DENSE_OUTPUT_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/runge_kutta4.hpp b/include/boost/numeric/odeint/stepper/runge_kutta4.hpp
new file mode 100644
index 0000000..2410774
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/runge_kutta4.hpp
@@ -0,0 +1,181 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/runge_kutta4.hpp
+
+ [begin_description]
+ Implementation of the classical Runge-Kutta stepper with the generic stepper.
+ [end_description]
+
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2011-2013 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_HPP_INCLUDED
+
+
+
+
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+
+#include <boost/numeric/odeint/stepper/explicit_generic_rk.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/array.hpp>
+
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+#ifndef DOXYGEN_SKIP
+template< class Value = double >
+struct rk4_coefficients_a1 : boost::array< Value , 1 >
+{
+    rk4_coefficients_a1( void )
+    {
+        (*this)[0] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
+    }
+};
+
+template< class Value = double >
+struct rk4_coefficients_a2 : boost::array< Value , 2 >
+{
+    rk4_coefficients_a2( void )
+    {
+        (*this)[0] = static_cast<Value>(0);
+        (*this)[1] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
+    }
+};
+
+
+template< class Value = double >
+struct rk4_coefficients_a3 : boost::array< Value , 3 >
+{
+    rk4_coefficients_a3( void )
+            {
+        (*this)[0] = static_cast<Value>(0);
+        (*this)[1] = static_cast<Value>(0);
+        (*this)[2] = static_cast<Value>(1);
+            }
+};
+
+template< class Value = double >
+struct rk4_coefficients_b : boost::array< Value , 4 >
+{
+    rk4_coefficients_b( void )
+    {
+        (*this)[0] = static_cast<Value>(1)/static_cast<Value>(6);
+        (*this)[1] = static_cast<Value>(1)/static_cast<Value>(3);
+        (*this)[2] = static_cast<Value>(1)/static_cast<Value>(3);
+        (*this)[3] = static_cast<Value>(1)/static_cast<Value>(6);
+    }
+};
+
+template< class Value = double >
+struct rk4_coefficients_c : boost::array< Value , 4 >
+{
+    rk4_coefficients_c( void )
+    {
+        (*this)[0] = static_cast<Value>(0);
+        (*this)[1] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
+        (*this)[2] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
+        (*this)[3] = static_cast<Value>(1);
+    }
+};
+#endif
+
+
+
+template<
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+#ifndef DOXYGEN_SKIP
+class runge_kutta4 : public explicit_generic_rk< 4 , 4 , State , Value , Deriv , Time ,
+Algebra , Operations , Resizer >
+#else
+class runge_kutta4 : public explicit_generic_rk
+#endif
+{
+
+public:
+
+#ifndef DOXYGEN_SKIP
+    typedef explicit_generic_rk< 4 , 4 , State , Value , Deriv , Time ,
+            Algebra , Operations , Resizer > stepper_base_type;
+#endif
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+
+    #ifndef DOXYGEN_SKIP
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_base_type::stepper_type stepper_type;
+    #endif
+
+    runge_kutta4( const algebra_type &algebra = algebra_type() ) : stepper_base_type(
+            boost::fusion::make_vector( rk4_coefficients_a1<Value>() , rk4_coefficients_a2<Value>() , rk4_coefficients_a3<Value>() ) ,
+            rk4_coefficients_b<Value>() , rk4_coefficients_c<Value>() , algebra )
+    { }
+
+};
+
+/**
+ * \class runge_kutta4
+ * \brief The classical Runge-Kutta stepper of fourth order.
+ *
+ * The Runge-Kutta method of fourth order is one standard method for
+ * solving ordinary differential equations and is widely used, see also
+ * <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods">en.wikipedia.org/wiki/Runge-Kutta_methods</a>
+ * The method is  explicit and fulfills the Stepper concept. Step size control
+ * or continuous output are not provided.
+ * 
+ * This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern).
+ * Furthermore, it derivs from explicit_generic_rk which is a generic Runge-Kutta algorithm. For more details see
+ * explicit_stepper_base and explicit_generic_rk.
+ *
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+/**
+ * \fn runge_kutta4::runge_kutta4( const algebra_type &algebra = algebra_type() )
+ * \brief Constructs the runge_kutta4 class. This constructor can be used as a default
+ * constructor if the algebra has a default constructor.
+ * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+ */
+
+}
+}
+}
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp b/include/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp
new file mode 100644
index 0000000..32bda0b
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp
@@ -0,0 +1,232 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/runge_kutta4_classic.hpp
+
+ [begin_description]
+ Implementation for the classical Runge Kutta stepper.
+ [end_description]
+
+ Copyright 2010-2013 Karsten Ahnert
+ Copyright 2010-2013 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_CLASSIC_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_CLASSIC_HPP_INCLUDED
+
+
+
+#include <boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template<
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+#ifndef DOXYGEN_SKIP
+class runge_kutta4_classic
+: public explicit_stepper_base<
+  runge_kutta4_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+  4 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
+#else
+class runge_kutta4_classic : public explicit_stepper_base
+#endif
+{
+
+public :
+
+    #ifndef DOXYGEN_SKIP
+    typedef explicit_stepper_base<
+    runge_kutta4_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+    4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type;
+    #else
+    typedef explicit_stepper_base< runge_kutta4_classic< ... > , ... > stepper_base_type;
+    #endif
+
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+
+    #ifndef DOXYGEN_SKIP
+    typedef typename stepper_base_type::stepper_type stepper_type;
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    #endif // DOXYGEN_SKIP
+
+
+
+    runge_kutta4_classic( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra )
+    { }
+
+
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+    {
+        // ToDo : check if size of in,dxdt,out are equal?
+
+        static const value_type val1 = static_cast< value_type >( 1 );
+
+        m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateIn > , detail::ref( *this ) , detail::_1 ) );
+
+        typename odeint::unwrap_reference< System >::type &sys = system;
+
+        const time_type dh = dt / static_cast< value_type >( 2 );
+        const time_type th = t + dh;
+
+        // dt * dxdt = k1
+        // m_x_tmp = x + dh*dxdt
+        stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , dxdt ,
+                typename operations_type::template scale_sum2< value_type , time_type >( val1 , dh ) );
+
+
+        // dt * m_dxt = k2
+        sys( m_x_tmp.m_v , m_dxt.m_v , th );
+
+        // m_x_tmp = x + dh*m_dxt
+        stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , m_dxt.m_v ,
+                typename operations_type::template scale_sum2< value_type , time_type >( val1 , dh ) );
+
+
+        // dt * m_dxm = k3
+        sys( m_x_tmp.m_v , m_dxm.m_v , th );
+        //m_x_tmp = x + dt*m_dxm
+        stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , m_dxm.m_v ,
+                typename operations_type::template scale_sum2< value_type , time_type >( val1 , dt ) );
+
+
+        // dt * m_dxh = k4
+        sys( m_x_tmp.m_v , m_dxh.m_v , t + dt );
+
+        //x += dt/6 * ( m_dxdt + m_dxt + val2*m_dxm )
+        time_type dt6 = dt / static_cast< value_type >( 6 );
+        time_type dt3 = dt / static_cast< value_type >( 3 );
+        stepper_base_type::m_algebra.for_each6( out , in , dxdt , m_dxt.m_v , m_dxm.m_v , m_dxh.m_v ,
+                                             typename operations_type::template scale_sum5< value_type , time_type , time_type , time_type , time_type >( 1.0 , dt6 , dt3 , dt3 , dt6 ) );
+        
+        // x += dt/6 * m_dxdt + dt/3 * m_dxt )
+        // stepper_base_type::m_algebra.for_each4( out , in , dxdt , m_dxt.m_v , 
+        //                                         typename operations_type::template scale_sum3< value_type , time_type , time_type >( 1.0 , dt6 , dt3 ) ); 
+        // // x += dt/3 * m_dxm + dt/6 * m_dxh )
+        // stepper_base_type::m_algebra.for_each4( out , out , m_dxm.m_v , m_dxh.m_v , 
+        //                                         typename operations_type::template scale_sum3< value_type , time_type , time_type >( 1.0 , dt3 , dt6 ) ); 
+
+    }
+
+    template< class StateType >
+    void adjust_size( const StateType &x )
+    {
+        resize_impl( x );
+        stepper_base_type::adjust_size( x );
+    }
+
+private:
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxm , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxt , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_dxh , x , typename is_resizeable<deriv_type>::type() );
+        return resized;
+    }
+
+
+    resizer_type m_resizer;
+
+    wrapped_deriv_type m_dxt;
+    wrapped_deriv_type m_dxm;
+    wrapped_deriv_type m_dxh;
+    wrapped_state_type m_x_tmp;
+
+};
+
+
+/********* DOXYGEN *********/
+
+/**
+ * \class runge_kutta4_classic
+ * \brief The classical Runge-Kutta stepper of fourth order.
+ *
+ * The Runge-Kutta method of fourth order is one standard method for
+ * solving ordinary differential equations and is widely used, see also
+ * <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods">en.wikipedia.org/wiki/Runge-Kutta_methods</a>
+ * The method is explicit and fulfills the Stepper concept. Step size control
+ * or continuous output are not provided.  This class implements the method directly, hence the 
+ * generic Runge-Kutta algorithm is not used.
+ * 
+ * This class derives from explicit_stepper_base and inherits its interface via
+ * CRTP (current recurring template pattern). For more details see
+ * explicit_stepper_base.
+ *
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+    /**
+     * \fn runge_kutta4_classic::runge_kutta4_classic( const algebra_type &algebra )
+     * \brief Constructs the runge_kutta4_classic class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor. 
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+
+    /**
+     * \fn runge_kutta4_classic::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+     * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
+     * The result is updated out of place, hence the input is in `in` and the output in `out`.
+     * Access to this step functionality is provided by explicit_stepper_base and 
+     * `do_step_impl` should not be called directly.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn runge_kutta4_classic::adjust_size( const StateType &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_CLASSIC_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp b/include/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp
new file mode 100644
index 0000000..beecb3f
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp
@@ -0,0 +1,231 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp
+ 
+ [begin_description]
+ Implementation of the Runge Kutta Cash Karp 5(4) method. It uses the generic error stepper.
+ [end_description]
+ 
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2011-2013 Karsten Ahnert
+ 
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED
+
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+
+#include <boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/array.hpp>
+
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+#ifndef DOXYGEN_SKIP
+template< class Value = double >
+struct rk54_ck_coefficients_a1 : boost::array< Value , 1 >
+{
+    rk54_ck_coefficients_a1( void )
+    {
+        (*this)[0] = static_cast< Value >( 1 )/static_cast< Value >( 5 );
+    }
+};
+
+template< class Value = double >
+struct rk54_ck_coefficients_a2 : boost::array< Value , 2 >
+{
+    rk54_ck_coefficients_a2( void )
+    {
+        (*this)[0] = static_cast<Value>( 3 )/static_cast<Value>( 40 );
+        (*this)[1] = static_cast<Value>( 9 )/static_cast<Value>( 40 );
+    }
+};
+
+
+template< class Value = double >
+struct rk54_ck_coefficients_a3 : boost::array< Value , 3 >
+{
+    rk54_ck_coefficients_a3( void )
+    {
+        (*this)[0] = static_cast<Value>( 3 )/static_cast<Value>( 10 );
+        (*this)[1] = static_cast<Value>( -9 )/static_cast<Value>( 10 );
+        (*this)[2] = static_cast<Value>( 6 )/static_cast<Value>( 5 );
+    }
+};
+
+template< class Value = double >
+struct rk54_ck_coefficients_a4 : boost::array< Value , 4 >
+{
+    rk54_ck_coefficients_a4( void )
+    {
+        (*this)[0] = static_cast<Value>( -11 )/static_cast<Value>( 54 );
+        (*this)[1] = static_cast<Value>( 5 )/static_cast<Value>( 2 );
+        (*this)[2] = static_cast<Value>( -70 )/static_cast<Value>( 27 );
+        (*this)[3] = static_cast<Value>( 35 )/static_cast<Value>( 27 );
+    }
+};
+
+template< class Value = double >
+struct rk54_ck_coefficients_a5 : boost::array< Value , 5 >
+{
+    rk54_ck_coefficients_a5( void )
+    {
+        (*this)[0] = static_cast<Value>( 1631 )/static_cast<Value>( 55296 );
+        (*this)[1] = static_cast<Value>( 175 )/static_cast<Value>( 512 );
+        (*this)[2] = static_cast<Value>( 575 )/static_cast<Value>( 13824 );
+        (*this)[3] = static_cast<Value>( 44275 )/static_cast<Value>( 110592 );
+        (*this)[4] = static_cast<Value>( 253 )/static_cast<Value>( 4096 );
+    }
+};
+
+template< class Value = double >
+struct rk54_ck_coefficients_b : boost::array< Value , 6 >
+{
+    rk54_ck_coefficients_b( void )
+    {
+        (*this)[0] = static_cast<Value>( 37 )/static_cast<Value>( 378 );
+        (*this)[1] = static_cast<Value>( 0 );
+        (*this)[2] = static_cast<Value>( 250 )/static_cast<Value>( 621 );
+        (*this)[3] = static_cast<Value>( 125 )/static_cast<Value>( 594 );
+        (*this)[4] = static_cast<Value>( 0 );
+        (*this)[5] = static_cast<Value>( 512 )/static_cast<Value>( 1771 );
+    }
+};
+
+template< class Value = double >
+struct rk54_ck_coefficients_db : boost::array< Value , 6 >
+{
+    rk54_ck_coefficients_db( void )
+    {
+        (*this)[0] = static_cast<Value>( 37 )/static_cast<Value>( 378 ) - static_cast<Value>( 2825 )/static_cast<Value>( 27648 );
+        (*this)[1] = static_cast<Value>( 0 );
+        (*this)[2] = static_cast<Value>( 250 )/static_cast<Value>( 621 ) - static_cast<Value>( 18575 )/static_cast<Value>( 48384 );
+        (*this)[3] = static_cast<Value>( 125 )/static_cast<Value>( 594 ) - static_cast<Value>( 13525 )/static_cast<Value>( 55296 );
+        (*this)[4] = static_cast<Value>( -277 )/static_cast<Value>( 14336 );
+        (*this)[5] = static_cast<Value>( 512 )/static_cast<Value>( 1771 ) - static_cast<Value>( 1 )/static_cast<Value>( 4 );
+    }
+};
+
+
+template< class Value = double >
+struct rk54_ck_coefficients_c : boost::array< Value , 6 >
+{
+    rk54_ck_coefficients_c( void )
+    {
+        (*this)[0] = static_cast<Value>(0);
+        (*this)[1] = static_cast<Value>( 1 )/static_cast<Value>( 5 );
+        (*this)[2] = static_cast<Value>( 3 )/static_cast<Value>( 10 );
+        (*this)[3] = static_cast<Value>( 3 )/static_cast<Value>( 5 );
+        (*this)[4] = static_cast<Value>( 1 );
+        (*this)[5] = static_cast<Value>( 7 )/static_cast<Value>( 8 );
+    }
+};
+#endif
+
+
+template<
+    class State ,
+    class Value = double ,
+    class Deriv = State ,
+    class Time = Value ,
+    class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+    class Operations = typename operations_dispatcher< State >::operations_type ,
+    class Resizer = initially_resizer
+    >
+#ifndef DOXYGEN_SKIP
+class runge_kutta_cash_karp54 : public explicit_error_generic_rk< 6 , 5 , 5 , 4 ,
+        State , Value , Deriv , Time , Algebra , Operations , Resizer >
+#else 
+class runge_kutta_cash_karp54 : public explicit_error_generic_rk
+#endif
+{
+
+public:
+#ifndef DOXYGEN_SKIP
+    typedef explicit_error_generic_rk< 6 , 5 , 5 , 4 , State , Value , Deriv , Time ,
+                               Algebra , Operations , Resizer > stepper_base_type;
+#endif
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_typ;
+
+    #ifndef DOXYGEN_SKIP
+    typedef typename stepper_base_type::stepper_type stepper_type;
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    #endif
+
+
+    runge_kutta_cash_karp54( const algebra_type &algebra = algebra_type() ) : stepper_base_type(
+        boost::fusion::make_vector( rk54_ck_coefficients_a1<Value>() ,
+                                 rk54_ck_coefficients_a2<Value>() ,
+                                 rk54_ck_coefficients_a3<Value>() ,
+                                 rk54_ck_coefficients_a4<Value>() ,
+                                 rk54_ck_coefficients_a5<Value>() ) ,
+            rk54_ck_coefficients_b<Value>() , rk54_ck_coefficients_db<Value>() , rk54_ck_coefficients_c<Value>() ,
+            algebra )
+    { }
+};
+
+
+/********** DOXYGEN **********/
+
+/**
+ * \class runge_kutta_cash_karp54
+ * \brief The Runge-Kutta Cash-Karp method.
+ *
+ * The Runge-Kutta Cash-Karp method is one of the standard methods for
+ * solving ordinary differential equations, see
+ * <a href="http://en.wikipedia.org/wiki/Cash%E2%80%93Karp_methods">en.wikipedia.org/wiki/Cash-Karp_methods</a>.
+ * The method is explicit and fulfills the Error Stepper concept. Step size control
+ * is provided but continuous output is not available for this method.
+ * 
+ * This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern).
+ * Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation.
+ * For more details see explicit_error_stepper_base and explicit_error_generic_rk.
+ *
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+
+    /**
+     * \fn runge_kutta_cash_karp54::runge_kutta_cash_karp54( const algebra_type &algebra )
+     * \brief Constructs the runge_kutta_cash_karp54 class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+}
+}
+}
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp b/include/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp
new file mode 100644
index 0000000..80f1a3c
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp
@@ -0,0 +1,289 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp
+
+ [begin_description]
+ Classical implementation of the Runge-Kutta Cash-Karp 5(4) method.
+ [end_description]
+
+ Copyright 2010-2013 Mario Mulansky
+ Copyright 2010-2013 Karsten Ahnert
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+
+template<
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+#ifndef DOXYGEN_SKIP
+class runge_kutta_cash_karp54_classic
+: public explicit_error_stepper_base<
+  runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+  5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
+#else
+class runge_kutta_cash_karp54_classic : public explicit_error_stepper_base
+#endif 
+{
+
+
+public :
+
+    #ifndef DOXYGEN_SKIP
+    typedef explicit_error_stepper_base<
+    runge_kutta_cash_karp54_classic< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+    5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type;
+    #else
+    typedef explicit_error_stepper_base< runge_kutta_cash_karp54_classic< ... > , ... > stepper_base_type;
+    #endif
+
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+
+    #ifndef DOXYGEN_SKIP
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    typedef typename stepper_base_type::stepper_type stepper_type;
+    #endif
+
+
+    runge_kutta_cash_karp54_classic( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra )
+    { }
+
+
+
+    template< class System , class StateIn , class DerivIn , class StateOut , class Err >
+    void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
+    {
+        const value_type c1 = static_cast<value_type> ( 37 ) / static_cast<value_type>( 378 );
+        const value_type c3 = static_cast<value_type> ( 250 ) / static_cast<value_type>( 621 );
+        const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 594 );
+        const value_type c6 = static_cast<value_type> ( 512 ) / static_cast<value_type>( 1771 );
+
+        const value_type dc1 = c1 - static_cast<value_type> ( 2825 ) / static_cast<value_type>( 27648 );
+        const value_type dc3 = c3 - static_cast<value_type> ( 18575 ) / static_cast<value_type>( 48384 );
+        const value_type dc4 = c4 - static_cast<value_type> ( 13525 ) / static_cast<value_type>( 55296 );
+        const value_type dc5 = static_cast<value_type> ( -277 ) / static_cast<value_type>( 14336 );
+        const value_type dc6 = c6 - static_cast<value_type> ( 1 ) / static_cast<value_type> ( 4 );
+
+        do_step_impl( system , in , dxdt , t , out , dt );
+
+        //error estimate
+        stepper_base_type::m_algebra.for_each6( xerr , dxdt , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v ,
+                typename operations_type::template scale_sum5< time_type , time_type , time_type , time_type , time_type >( dt*dc1 , dt*dc3 , dt*dc4 , dt*dc5 , dt*dc6 ));
+
+    }
+
+
+
+    template< class System , class StateIn , class DerivIn , class StateOut >
+    void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+    {
+        const value_type a2 = static_cast<value_type> ( 1 ) / static_cast<value_type> ( 5 );
+        const value_type a3 = static_cast<value_type> ( 3 ) / static_cast<value_type> ( 10 );
+        const value_type a4 = static_cast<value_type> ( 3 ) / static_cast<value_type> ( 5 );
+        const value_type a5 = static_cast<value_type> ( 1 );
+        const value_type a6 = static_cast<value_type> ( 7 ) / static_cast<value_type> ( 8 );
+
+        const value_type b21 = static_cast<value_type> ( 1 ) / static_cast<value_type> ( 5 );
+        const value_type b31 = static_cast<value_type> ( 3 ) / static_cast<value_type>( 40 );
+        const value_type b32 = static_cast<value_type> ( 9 ) / static_cast<value_type>( 40 );
+        const value_type b41 = static_cast<value_type> ( 3 ) / static_cast<value_type> ( 10 );
+        const value_type b42 = static_cast<value_type> ( -9 ) / static_cast<value_type> ( 10 );
+        const value_type b43 = static_cast<value_type> ( 6 ) / static_cast<value_type> ( 5 );
+        const value_type b51 = static_cast<value_type> ( -11 ) / static_cast<value_type>( 54 );
+        const value_type b52 = static_cast<value_type> ( 5 ) / static_cast<value_type> ( 2 );
+        const value_type b53 = static_cast<value_type> ( -70 ) / static_cast<value_type>( 27 );
+        const value_type b54 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 27 );
+        const value_type b61 = static_cast<value_type> ( 1631 ) / static_cast<value_type>( 55296 );
+        const value_type b62 = static_cast<value_type> ( 175 ) / static_cast<value_type>( 512 );
+        const value_type b63 = static_cast<value_type> ( 575 ) / static_cast<value_type>( 13824 );
+        const value_type b64 = static_cast<value_type> ( 44275 ) / static_cast<value_type>( 110592 );
+        const value_type b65 = static_cast<value_type> ( 253 ) / static_cast<value_type>( 4096 );
+
+        const value_type c1 = static_cast<value_type> ( 37 ) / static_cast<value_type>( 378 );
+        const value_type c3 = static_cast<value_type> ( 250 ) / static_cast<value_type>( 621 );
+        const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 594 );
+        const value_type c6 = static_cast<value_type> ( 512 ) / static_cast<value_type>( 1771 );
+
+        typename odeint::unwrap_reference< System >::type &sys = system;
+
+        m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
+
+        //m_x1 = x + dt*b21*dxdt
+        stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , dxdt ,
+                typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , dt*b21 ) );
+
+        sys( m_x_tmp.m_v , m_k2.m_v , t + dt*a2 );
+        // m_x_tmp = x + dt*b31*dxdt + dt*b32*m_x2
+        stepper_base_type::m_algebra.for_each4( m_x_tmp.m_v , in , dxdt , m_k2.m_v ,
+                typename operations_type::template scale_sum3< value_type , time_type , time_type >( 1.0 , dt*b31 , dt*b32 ));
+
+        sys( m_x_tmp.m_v , m_k3.m_v , t + dt*a3 );
+        // m_x_tmp = x + dt * (b41*dxdt + b42*m_x2 + b43*m_x3)
+        stepper_base_type::m_algebra.for_each5( m_x_tmp.m_v , in , dxdt , m_k2.m_v , m_k3.m_v ,
+                typename operations_type::template scale_sum4< value_type , time_type , time_type , time_type >( 1.0 , dt*b41 , dt*b42 , dt*b43 ));
+
+        sys( m_x_tmp.m_v, m_k4.m_v , t + dt*a4 );
+        stepper_base_type::m_algebra.for_each6( m_x_tmp.m_v , in , dxdt , m_k2.m_v , m_k3.m_v , m_k4.m_v ,
+                typename operations_type::template scale_sum5< value_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b51 , dt*b52 , dt*b53 , dt*b54 ));
+
+        sys( m_x_tmp.m_v , m_k5.m_v , t + dt*a5 );
+        stepper_base_type::m_algebra.for_each7( m_x_tmp.m_v , in , dxdt , m_k2.m_v , m_k3.m_v , m_k4.m_v , m_k5.m_v ,
+                typename operations_type::template scale_sum6< value_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b61 , dt*b62 , dt*b63 , dt*b64 , dt*b65 ));
+
+        sys( m_x_tmp.m_v , m_k6.m_v , t + dt*a6 );
+        stepper_base_type::m_algebra.for_each6( out , in , dxdt , m_k3.m_v , m_k4.m_v , m_k6.m_v ,
+                typename operations_type::template scale_sum5< value_type , time_type , time_type , time_type , time_type >( 1.0 , dt*c1 , dt*c3 , dt*c4 , dt*c6 ));
+
+    }
+
+    /**
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_impl( x );
+        stepper_base_type::adjust_size( x );
+    }
+
+private:
+
+    template< class StateIn >
+    bool resize_impl( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k2 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k3 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k4 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k5 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k6 , x , typename is_resizeable<deriv_type>::type() );
+        return resized;
+    }
+
+
+    wrapped_state_type m_x_tmp;
+    wrapped_deriv_type m_k2, m_k3, m_k4, m_k5, m_k6;
+    resizer_type m_resizer;
+
+};
+
+
+
+/************ DOXYGEN *************/
+
+/**
+ * \class runge_kutta_cash_karp54_classic
+ * \brief The Runge-Kutta Cash-Karp method implemented without the generic Runge-Kutta algorithm.
+ *
+ * The Runge-Kutta Cash-Karp method is one of the standard methods for
+ * solving ordinary differential equations, see
+ * <a href="http://en.wikipedia.org/wiki/Cash%E2%80%93Karp_method">en.wikipedia.org/wiki/Cash-Karp_method</a>.
+ * The method is explicit and fulfills the Error Stepper concept. Step size control
+ * is provided but continuous output is not available for this method.
+ * 
+ * This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring
+ * template pattern). This class implements the method directly, hence the generic Runge-Kutta algorithm is not used.
+ *
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+
+    /**
+     * \fn runge_kutta_cash_karp54_classic::runge_kutta_cash_karp54_classic( const algebra_type &algebra )
+     * \brief Constructs the runge_kutta_cash_karp54_classic class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+
+    /**
+     * \fn runge_kutta_cash_karp54_classic::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
+     * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
+     *
+     * The result is updated out-of-place, hence the input is in `in` and the output in `out`. Futhermore, an
+     * estimation of the error is stored in `xerr`. 
+     * Access to this step functionality is provided by explicit_error_stepper_base and 
+     * `do_step_impl` should not be called directly.
+
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     * \param xerr The result of the error estimation is written in xerr.
+     */
+
+    /**
+     * \fn runge_kutta_cash_karp54_classic::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
+     * \brief This method performs one step. The derivative `dxdt` of `in` at the time `t` is passed to the method.
+     * The result is updated out-of-place, hence the input is in `in` and the output in `out`.
+     * Access to this step functionality is provided by explicit_error_stepper_base and 
+     * `do_step_impl` should not be called directly.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt The derivative of x at t.
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dt The step size.
+     */
+
+} // odeint
+} // numeric
+} // boost
+
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_CASH_KARP54_CLASSIC_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp b/include/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp
new file mode 100644
index 0000000..260cd74
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp
@@ -0,0 +1,403 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp
+
+ [begin_description]
+ Implementation of the Dormand-Prince 5(4) method. This stepper can also be used with the dense-output controlled stepper.
+ [end_description]
+
+ Copyright 2010-2013 Karsten Ahnert
+ Copyright 2010-2013 Mario Mulansky
+ Copyright 2012 Christoph Koke
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/util/same_instance.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+template<
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+class runge_kutta_dopri5
+#ifndef DOXYGEN_SKIP
+: public explicit_error_stepper_fsal_base<
+  runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+  5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
+#else
+: public explicit_error_stepper_fsal_base
+#endif
+{
+
+public :
+
+    #ifndef DOXYGEN_SKIP
+    typedef explicit_error_stepper_fsal_base<
+    runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
+    5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type;
+    #else
+    typedef explicit_error_stepper_fsal_base< runge_kutta_dopri5< ... > , ... > stepper_base_type;
+    #endif
+    
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+
+    #ifndef DOXYGEN_SKIP
+    typedef typename stepper_base_type::stepper_type stepper_type;
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    #endif // DOXYGEN_SKIP
+
+
+    runge_kutta_dopri5( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra )
+    { }
+
+
+    template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut >
+    void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t ,
+            StateOut &out , DerivOut &dxdt_out , time_type dt )
+    {
+        const value_type a2 = static_cast<value_type> ( 1 ) / static_cast<value_type>( 5 );
+        const value_type a3 = static_cast<value_type> ( 3 ) / static_cast<value_type> ( 10 );
+        const value_type a4 = static_cast<value_type> ( 4 ) / static_cast<value_type> ( 5 );
+        const value_type a5 = static_cast<value_type> ( 8 )/static_cast<value_type> ( 9 );
+
+        const value_type b21 = static_cast<value_type> ( 1 ) / static_cast<value_type> ( 5 );
+
+        const value_type b31 = static_cast<value_type> ( 3 ) / static_cast<value_type>( 40 );
+        const value_type b32 = static_cast<value_type> ( 9 ) / static_cast<value_type>( 40 );
+
+        const value_type b41 = static_cast<value_type> ( 44 ) / static_cast<value_type> ( 45 );
+        const value_type b42 = static_cast<value_type> ( -56 ) / static_cast<value_type> ( 15 );
+        const value_type b43 = static_cast<value_type> ( 32 ) / static_cast<value_type> ( 9 );
+
+        const value_type b51 = static_cast<value_type> ( 19372 ) / static_cast<value_type>( 6561 );
+        const value_type b52 = static_cast<value_type> ( -25360 ) / static_cast<value_type> ( 2187 );
+        const value_type b53 = static_cast<value_type> ( 64448 ) / static_cast<value_type>( 6561 );
+        const value_type b54 = static_cast<value_type> ( -212 ) / static_cast<value_type>( 729 );
+
+        const value_type b61 = static_cast<value_type> ( 9017 ) / static_cast<value_type>( 3168 );
+        const value_type b62 = static_cast<value_type> ( -355 ) / static_cast<value_type>( 33 );
+        const value_type b63 = static_cast<value_type> ( 46732 ) / static_cast<value_type>( 5247 );
+        const value_type b64 = static_cast<value_type> ( 49 ) / static_cast<value_type>( 176 );
+        const value_type b65 = static_cast<value_type> ( -5103 ) / static_cast<value_type>( 18656 );
+
+        const value_type c1 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 384 );
+        const value_type c3 = static_cast<value_type> ( 500 ) / static_cast<value_type>( 1113 );
+        const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 192 );
+        const value_type c5 = static_cast<value_type> ( -2187 ) / static_cast<value_type>( 6784 );
+        const value_type c6 = static_cast<value_type> ( 11 ) / static_cast<value_type>( 84 );
+
+        typename odeint::unwrap_reference< System >::type &sys = system;
+
+        m_k_x_tmp_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_k_x_tmp_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
+
+        //m_x_tmp = x + dt*b21*dxdt
+        stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , dxdt_in ,
+                typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , dt*b21 ) );
+
+        sys( m_x_tmp.m_v , m_k2.m_v , t + dt*a2 );
+        // m_x_tmp = x + dt*b31*dxdt + dt*b32*m_k2
+        stepper_base_type::m_algebra.for_each4( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v ,
+                typename operations_type::template scale_sum3< value_type , time_type , time_type >( 1.0 , dt*b31 , dt*b32 ));
+
+        sys( m_x_tmp.m_v , m_k3.m_v , t + dt*a3 );
+        // m_x_tmp = x + dt * (b41*dxdt + b42*m_k2 + b43*m_k3)
+        stepper_base_type::m_algebra.for_each5( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , m_k3.m_v ,
+                typename operations_type::template scale_sum4< value_type , time_type , time_type , time_type >( 1.0 , dt*b41 , dt*b42 , dt*b43 ));
+
+        sys( m_x_tmp.m_v, m_k4.m_v , t + dt*a4 );
+        stepper_base_type::m_algebra.for_each6( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , m_k3.m_v , m_k4.m_v ,
+                typename operations_type::template scale_sum5< value_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b51 , dt*b52 , dt*b53 , dt*b54 ));
+
+        sys( m_x_tmp.m_v , m_k5.m_v , t + dt*a5 );
+        stepper_base_type::m_algebra.for_each7( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , m_k3.m_v , m_k4.m_v , m_k5.m_v ,
+                typename operations_type::template scale_sum6< value_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b61 , dt*b62 , dt*b63 , dt*b64 , dt*b65 ));
+
+        sys( m_x_tmp.m_v , m_k6.m_v , t + dt );
+        stepper_base_type::m_algebra.for_each7( out , in , dxdt_in , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v ,
+                typename operations_type::template scale_sum6< value_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt*c1 , dt*c3 , dt*c4 , dt*c5 , dt*c6 ));
+
+        // the new derivative
+        sys( out , dxdt_out , t + dt );
+    }
+
+
+
+    template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut , class Err >
+    void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t ,
+            StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr )
+    {
+        const value_type c1 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 384 );
+        const value_type c3 = static_cast<value_type> ( 500 ) / static_cast<value_type>( 1113 );
+        const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 192 );
+        const value_type c5 = static_cast<value_type> ( -2187 ) / static_cast<value_type>( 6784 );
+        const value_type c6 = static_cast<value_type> ( 11 ) / static_cast<value_type>( 84 );
+
+        const value_type dc1 = c1 - static_cast<value_type> ( 5179 ) / static_cast<value_type>( 57600 );
+        const value_type dc3 = c3 - static_cast<value_type> ( 7571 ) / static_cast<value_type>( 16695 );
+        const value_type dc4 = c4 - static_cast<value_type> ( 393 ) / static_cast<value_type>( 640 );
+        const value_type dc5 = c5 - static_cast<value_type> ( -92097 ) / static_cast<value_type>( 339200 );
+        const value_type dc6 = c6 - static_cast<value_type> ( 187 ) / static_cast<value_type>( 2100 );
+        const value_type dc7 = static_cast<value_type>( -1 ) / static_cast<value_type> ( 40 );
+
+        /* ToDo: copy only if &dxdt_in == &dxdt_out ? */
+        if( same_instance( dxdt_in , dxdt_out ) )
+        {
+            m_dxdt_tmp_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_dxdt_tmp_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
+            boost::numeric::odeint::copy( dxdt_in , m_dxdt_tmp.m_v );
+            do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt );
+            //error estimate
+            stepper_base_type::m_algebra.for_each7( xerr , m_dxdt_tmp.m_v , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , dxdt_out ,
+                                                    typename operations_type::template scale_sum6< time_type , time_type , time_type , time_type , time_type , time_type >( dt*dc1 , dt*dc3 , dt*dc4 , dt*dc5 , dt*dc6 , dt*dc7 ) );
+
+        }
+        else
+        {
+            do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt );
+            //error estimate
+            stepper_base_type::m_algebra.for_each7( xerr , dxdt_in , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , dxdt_out ,
+                                                    typename operations_type::template scale_sum6< time_type , time_type , time_type , time_type , time_type , time_type >( dt*dc1 , dt*dc3 , dt*dc4 , dt*dc5 , dt*dc6 , dt*dc7 ) );
+        
+        }
+
+    }
+
+
+    /*
+     * Calculates Dense-Output for Dopri5
+     *
+     * See Hairer, Norsett, Wanner: Solving Ordinary Differential Equations, Nonstiff Problems. I, p.191/192
+     *
+     * y(t+theta) = y(t) + h * sum_i^7 b_i(theta) * k_i
+     *
+     * A = theta^2 * ( 3 - 2 theta )
+     * B = theta^2 * ( theta - 1 )
+     * C = theta^2 * ( theta - 1 )^2
+     * D = theta   * ( theta - 1 )^2
+     *
+     * b_1( theta ) = A * b_1 - C * X1( theta ) + D
+     * b_2( theta ) = 0
+     * b_3( theta ) = A * b_3 + C * X3( theta )
+     * b_4( theta ) = A * b_4 - C * X4( theta )
+     * b_5( theta ) = A * b_5 + C * X5( theta )
+     * b_6( theta ) = A * b_6 - C * X6( theta )
+     * b_7( theta ) = B + C * X7( theta )
+     *
+     * An alternative Method is described in:
+     *
+     * www-m2.ma.tum.de/homepages/simeon/numerik3/kap3.ps
+     */
+    template< class StateOut , class StateIn1 , class DerivIn1 , class StateIn2 , class DerivIn2 >
+    void calc_state( time_type t , StateOut &x ,
+                     const StateIn1 &x_old , const DerivIn1 &deriv_old , time_type t_old ,
+                     const StateIn2 & /* x_new */ , const DerivIn2 &deriv_new , time_type t_new ) const
+    {
+        const value_type b1 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 384 );
+        const value_type b3 = static_cast<value_type> ( 500 ) / static_cast<value_type>( 1113 );
+        const value_type b4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 192 );
+        const value_type b5 = static_cast<value_type> ( -2187 ) / static_cast<value_type>( 6784 );
+        const value_type b6 = static_cast<value_type> ( 11 ) / static_cast<value_type>( 84 );
+
+        const time_type dt = ( t_new - t_old );
+        const value_type theta = ( t - t_old ) / dt;
+        const value_type X1 = static_cast< value_type >( 5 ) * ( static_cast< value_type >( 2558722523LL ) - static_cast< value_type >( 31403016 ) * theta ) / static_cast< value_type >( 11282082432LL );
+        const value_type X3 = static_cast< value_type >( 100 ) * ( static_cast< value_type >( 882725551 ) - static_cast< value_type >( 15701508 ) * theta ) / static_cast< value_type >( 32700410799LL );
+        const value_type X4 = static_cast< value_type >( 25 ) * ( static_cast< value_type >( 443332067 ) - static_cast< value_type >( 31403016 ) * theta ) / static_cast< value_type >( 1880347072LL ) ;
+        const value_type X5 = static_cast< value_type >( 32805 ) * ( static_cast< value_type >( 23143187 ) - static_cast< value_type >( 3489224 ) * theta ) / static_cast< value_type >( 199316789632LL );
+        const value_type X6 = static_cast< value_type >( 55 ) * ( static_cast< value_type >( 29972135 ) - static_cast< value_type >( 7076736 ) * theta ) / static_cast< value_type >( 822651844 );
+        const value_type X7 = static_cast< value_type >( 10 ) * ( static_cast< value_type >( 7414447 ) - static_cast< value_type >( 829305 ) * theta ) / static_cast< value_type >( 29380423 );
+
+        const value_type theta_m_1 = theta - static_cast< value_type >( 1 );
+        const value_type theta_sq = theta * theta;
+        const value_type A = theta_sq * ( static_cast< value_type >( 3 ) - static_cast< value_type >( 2 ) * theta );
+        const value_type B = theta_sq * theta_m_1;
+        const value_type C = theta_sq * theta_m_1 * theta_m_1;
+        const value_type D = theta * theta_m_1 * theta_m_1;
+
+        const value_type b1_theta = A * b1 - C * X1 + D;
+        const value_type b3_theta = A * b3 + C * X3;
+        const value_type b4_theta = A * b4 - C * X4;
+        const value_type b5_theta = A * b5 + C * X5;
+        const value_type b6_theta = A * b6 - C * X6;
+        const value_type b7_theta = B + C * X7;
+
+        // const state_type &k1 = *m_old_deriv;
+        // const state_type &k3 = dopri5().m_k3;
+        // const state_type &k4 = dopri5().m_k4;
+        // const state_type &k5 = dopri5().m_k5;
+        // const state_type &k6 = dopri5().m_k6;
+        // const state_type &k7 = *m_current_deriv;
+
+        stepper_base_type::m_algebra.for_each8( x , x_old , deriv_old , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , deriv_new ,
+                typename operations_type::template scale_sum7< value_type , time_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt * b1_theta , dt * b3_theta , dt * b4_theta , dt * b5_theta , dt * b6_theta , dt * b7_theta ) );
+    }
+
+
+    template< class StateIn >
+    void adjust_size( const StateIn &x )
+    {
+        resize_k_x_tmp_impl( x );
+        resize_dxdt_tmp_impl( x );
+        stepper_base_type::adjust_size( x );
+    }
+    
+
+private:
+
+    template< class StateIn >
+    bool resize_k_x_tmp_impl( const StateIn &x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k2 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k3 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k4 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k5 , x , typename is_resizeable<deriv_type>::type() );
+        resized |= adjust_size_by_resizeability( m_k6 , x , typename is_resizeable<deriv_type>::type() );
+        return resized;
+    }
+
+    template< class StateIn >
+    bool resize_dxdt_tmp_impl( const StateIn &x )
+    {
+        return adjust_size_by_resizeability( m_dxdt_tmp , x , typename is_resizeable<deriv_type>::type() );
+    }
+        
+
+
+    wrapped_state_type m_x_tmp;
+    wrapped_deriv_type m_k2 , m_k3 , m_k4 , m_k5 , m_k6 ;
+    wrapped_deriv_type m_dxdt_tmp;
+    resizer_type m_k_x_tmp_resizer;
+    resizer_type m_dxdt_tmp_resizer;
+};
+
+
+
+/************* DOXYGEN ************/
+/**
+ * \class runge_kutta_dopri5
+ * \brief The Runge-Kutta Dormand-Prince 5 method.
+ *
+ * The Runge-Kutta Dormand-Prince 5 method is a very popular method for solving ODEs, see
+ * <a href=""></a>.
+ * The method is explicit and fulfills the Error Stepper concept. Step size control
+ * is provided but continuous output is available which make this method favourable for many applications. 
+ * 
+ * This class derives from explicit_error_stepper_fsal_base and inherits its interface via CRTP (current recurring
+ * template pattern). The method possesses the FSAL (first-same-as-last) property. See
+ * explicit_error_stepper_fsal_base for more details.
+ *
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+
+    /**
+     * \fn runge_kutta_dopri5::runge_kutta_dopri5( const algebra_type &algebra )
+     * \brief Constructs the runge_kutta_dopri5 class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+    /**
+     * \fn runge_kutta_dopri5::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt )
+     * \brief This method performs one step. The derivative `dxdt_in` of `in` at the time `t` is passed to the
+     * method. The result is updated out-of-place, hence the input is in `in` and the output in `out`. Furthermore,
+     * the derivative is update out-of-place, hence the input is assumed to be in `dxdt_in` and the output in
+     * `dxdt_out`. 
+     * Access to this step functionality is provided by explicit_error_stepper_fsal_base and 
+     * `do_step_impl` should not be called directly.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt_in The derivative of x at t. dxdt_in is not modified by this method
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dxdt_out The result of the new derivative at time t+dt.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn runge_kutta_dopri5::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr )
+     * \brief This method performs one step. The derivative `dxdt_in` of `in` at the time `t` is passed to the
+     * method. The result is updated out-of-place, hence the input is in `in` and the output in `out`. Furthermore,
+     * the derivative is update out-of-place, hence the input is assumed to be in `dxdt_in` and the output in
+     * `dxdt_out`. 
+     * Access to this step functionality is provided by explicit_error_stepper_fsal_base and 
+     * `do_step_impl` should not be called directly.
+     * An estimation of the error is calculated.
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
+     *               Simple System concept.
+     * \param in The state of the ODE which should be solved. in is not modified in this method
+     * \param dxdt_in The derivative of x at t. dxdt_in is not modified by this method
+     * \param t The value of the time, at which the step should be performed.
+     * \param out The result of the step is written in out.
+     * \param dxdt_out The result of the new derivative at time t+dt.
+     * \param dt The step size.
+     * \param xerr An estimation of the error.
+     */
+
+    /**
+     * \fn runge_kutta_dopri5::calc_state( time_type t , StateOut &x , const StateIn1 &x_old , const DerivIn1 &deriv_old , time_type t_old , const StateIn2 &  , const DerivIn2 &deriv_new , time_type t_new ) const
+     * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the 
+     * knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`. It also uses
+     * internal variables to calculate the result. Hence this method must be called after two successful `do_step`
+     * calls.
+     */
+
+    /**
+     * \fn runge_kutta_dopri5::adjust_size( const StateIn &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp b/include/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp
new file mode 100644
index 0000000..f2f8251
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp
@@ -0,0 +1,374 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/runge_kutta_fehlberg87.hpp
+
+ [begin_description]
+ Implementation of the Runge-Kutta-Fehlberg stepper with the generic stepper.
+ [end_description]
+
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2012-2013 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_FEHLBERG87_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_FEHLBERG87_HPP_INCLUDED
+
+
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+
+#include <boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp>
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/array.hpp>
+
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+#ifndef DOXYGEN_SKIP
+template< class Value = double >
+struct rk78_coefficients_a1 : boost::array< Value , 1 >
+{
+    rk78_coefficients_a1( void )
+            {
+        (*this)[0] = static_cast< Value >( 2 )/static_cast< Value >( 27 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_a2 : boost::array< Value , 2 >
+{
+    rk78_coefficients_a2( void )
+            {
+        (*this)[0] = static_cast< Value >( 1 )/static_cast< Value >( 36 );
+        (*this)[1] = static_cast< Value >( 1 )/static_cast< Value >( 12 );
+            }
+};
+
+
+template< class Value = double >
+struct rk78_coefficients_a3 : boost::array< Value , 3 >
+{
+    rk78_coefficients_a3( void )
+            {
+        (*this)[0] = static_cast< Value >( 1 )/static_cast< Value >( 24 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 1 )/static_cast< Value >( 8 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_a4 : boost::array< Value , 4 >
+{
+    rk78_coefficients_a4( void )
+            {
+        (*this)[0] = static_cast< Value >( 5 )/static_cast< Value >( 12 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( -25 )/static_cast< Value >( 16 );
+        (*this)[3] = static_cast< Value >( 25 )/static_cast< Value >( 16 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_a5 : boost::array< Value , 5 >
+{
+    rk78_coefficients_a5( void )
+            {
+        (*this)[0] = static_cast< Value >( 1 )/static_cast< Value >( 20 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( 1 )/static_cast< Value >( 4 );
+        (*this)[4] = static_cast< Value >( 1 )/static_cast< Value >( 5 );
+            }
+};
+
+
+template< class Value = double >
+struct rk78_coefficients_a6 : boost::array< Value , 6 >
+{
+    rk78_coefficients_a6( void )
+            {
+        (*this)[0] = static_cast< Value >( -25 )/static_cast< Value >( 108 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( 125 )/static_cast< Value >( 108 );
+        (*this)[4] = static_cast< Value >( -65 )/static_cast< Value >( 27 );
+        (*this)[5] = static_cast< Value >( 125 )/static_cast< Value >( 54 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_a7 : boost::array< Value , 7 >
+{
+    rk78_coefficients_a7( void )
+            {
+        (*this)[0] = static_cast< Value >( 31 )/static_cast< Value >( 300 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( 0 );
+        (*this)[4] = static_cast< Value >( 61 )/static_cast< Value >( 225 );
+        (*this)[5] = static_cast< Value >( -2 )/static_cast< Value >( 9 );
+        (*this)[6] = static_cast< Value >( 13 )/static_cast< Value >( 900 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_a8 : boost::array< Value , 8 >
+{
+    rk78_coefficients_a8( void )
+            {
+        (*this)[0] = static_cast< Value >( 2 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( -53 )/static_cast< Value >( 6 );
+        (*this)[4] = static_cast< Value >( 704 )/static_cast< Value >( 45 );
+        (*this)[5] = static_cast< Value >( -107 )/static_cast< Value >( 9 );
+        (*this)[6] = static_cast< Value >( 67 )/static_cast< Value >( 90 );
+        (*this)[7] = static_cast< Value >( 3 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_a9 : boost::array< Value , 9 >
+{
+    rk78_coefficients_a9( void )
+            {
+        (*this)[0] = static_cast< Value >( -91 )/static_cast< Value >( 108 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( 23 )/static_cast< Value >( 108 );
+        (*this)[4] = static_cast< Value >( -976 )/static_cast< Value >( 135 );
+        (*this)[5] = static_cast< Value >( 311 )/static_cast< Value >( 54 );
+        (*this)[6] = static_cast< Value >( -19 )/static_cast< Value >( 60 );
+        (*this)[7] = static_cast< Value >( 17 )/static_cast< Value >( 6 );
+        (*this)[8] = static_cast< Value >( -1 )/static_cast< Value >( 12 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_a10 : boost::array< Value , 10 >
+{
+    rk78_coefficients_a10( void )
+            {
+        (*this)[0] = static_cast< Value >( 2383 )/static_cast< Value >( 4100 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( -341 )/static_cast< Value >( 164 );
+        (*this)[4] = static_cast< Value >( 4496 )/static_cast< Value >( 1025 );
+        (*this)[5] = static_cast< Value >( -301 )/static_cast< Value >( 82 );
+        (*this)[6] = static_cast< Value >( 2133 )/static_cast< Value >( 4100 );
+        (*this)[7] = static_cast< Value >( 45 )/static_cast< Value >( 82 );
+        (*this)[8] = static_cast< Value >( 45 )/static_cast< Value >( 164 );
+        (*this)[9] = static_cast< Value >( 18 )/static_cast< Value >( 41 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_a11 : boost::array< Value , 11 >
+{
+    rk78_coefficients_a11( void )
+            {
+        (*this)[0] = static_cast< Value >( 3 )/static_cast< Value >( 205 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( 0 );
+        (*this)[4] = static_cast< Value >( 0 );
+        (*this)[5] = static_cast< Value >( -6 )/static_cast< Value >( 41 );
+        (*this)[6] = static_cast< Value >( -3 )/static_cast< Value >( 205 );
+        (*this)[7] = static_cast< Value >( -3 )/static_cast< Value >( 41 );
+        (*this)[8] = static_cast< Value >( 3 )/static_cast< Value >( 41 );
+        (*this)[9] = static_cast< Value >( 6 )/static_cast< Value >( 41 );
+        (*this)[10] = static_cast< Value >( 0 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_a12 : boost::array< Value , 12 >
+{
+    rk78_coefficients_a12( void )
+            {
+        (*this)[0] = static_cast< Value >( -1777 )/static_cast< Value >( 4100 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( -341 )/static_cast< Value >( 164 );
+        (*this)[4] = static_cast< Value >( 4496 )/static_cast< Value >( 1025 );
+        (*this)[5] = static_cast< Value >( -289 )/static_cast< Value >( 82 );
+        (*this)[6] = static_cast< Value >( 2193 )/static_cast< Value >( 4100 );
+        (*this)[7] = static_cast< Value >( 51 )/static_cast< Value >( 82 );
+        (*this)[8] = static_cast< Value >( 33 )/static_cast< Value >( 164 );
+        (*this)[9] = static_cast< Value >( 12 )/static_cast< Value >( 41 );
+        (*this)[10] = static_cast< Value >( 0 );
+        (*this)[11] = static_cast< Value >( 1 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_b : boost::array< Value , 13 >
+{
+    rk78_coefficients_b( void )
+            {
+        (*this)[0] = static_cast< Value >( 0 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( 0 );
+        (*this)[4] = static_cast< Value >( 0 );
+        (*this)[5] = static_cast< Value >( 34 )/static_cast<Value>( 105 );
+        (*this)[6] = static_cast< Value >( 9 )/static_cast<Value>( 35 );
+        (*this)[7] = static_cast< Value >( 9 )/static_cast<Value>( 35 );
+        (*this)[8] = static_cast< Value >( 9 )/static_cast<Value>( 280 );
+        (*this)[9] = static_cast< Value >( 9 )/static_cast<Value>( 280 );
+        (*this)[10] = static_cast< Value >( 0 );
+        (*this)[11] = static_cast< Value >( 41 )/static_cast<Value>( 840 );
+        (*this)[12] = static_cast< Value >( 41 )/static_cast<Value>( 840 );
+            }
+};
+
+template< class Value = double >
+struct rk78_coefficients_db : boost::array< Value , 13 >
+{
+    rk78_coefficients_db( void )
+            {
+        (*this)[0] = static_cast< Value >( 0 ) - static_cast< Value >( 41 )/static_cast<Value>( 840 );
+        (*this)[1] = static_cast< Value >( 0 );
+        (*this)[2] = static_cast< Value >( 0 );
+        (*this)[3] = static_cast< Value >( 0 );
+        (*this)[4] = static_cast< Value >( 0 );
+        (*this)[5] = static_cast< Value >( 0 );
+        (*this)[6] = static_cast< Value >( 0 );
+        (*this)[7] = static_cast< Value >( 0 );
+        (*this)[8] = static_cast< Value >( 0 );
+        (*this)[9] = static_cast< Value >( 0 );
+        (*this)[10] = static_cast< Value >( 0 ) - static_cast< Value >( 41 )/static_cast<Value>( 840 );
+        (*this)[11] = static_cast< Value >( 41 )/static_cast<Value>( 840 );
+        (*this)[12] = static_cast< Value >( 41 )/static_cast<Value>( 840 );
+            }
+};
+
+
+template< class Value = double >
+struct rk78_coefficients_c : boost::array< Value , 13 >
+{
+    rk78_coefficients_c( void )
+            {
+        (*this)[0] = static_cast< Value >( 0 );
+        (*this)[1] = static_cast< Value >( 2 )/static_cast< Value >( 27 );
+        (*this)[2] = static_cast< Value >( 1 )/static_cast< Value >( 9 );
+        (*this)[3] = static_cast< Value >( 1 )/static_cast<Value>( 6 );
+        (*this)[4] = static_cast< Value >( 5 )/static_cast<Value>( 12 );
+        (*this)[5] = static_cast< Value >( 1 )/static_cast<Value>( 2 );
+        (*this)[6] = static_cast< Value >( 5 )/static_cast<Value>( 6 );
+        (*this)[7] = static_cast< Value >( 1 )/static_cast<Value>( 6 );
+        (*this)[8] = static_cast< Value >( 2 )/static_cast<Value>( 3 );
+        (*this)[9] = static_cast< Value >( 1 )/static_cast<Value>( 3 );
+        (*this)[10] = static_cast< Value >( 1 );
+        (*this)[11] = static_cast< Value >( 0 );
+        (*this)[12] = static_cast< Value >( 1 );
+            }
+};
+#endif // DOXYGEN_SKIP
+
+
+
+
+
+template<
+class State ,
+class Value = double ,
+class Deriv = State ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
+class Resizer = initially_resizer
+>
+#ifndef DOXYGEN_SKIP
+class runge_kutta_fehlberg78 : public explicit_error_generic_rk< 13 , 8 , 8 , 7 , State , Value , Deriv , Time ,
+Algebra , Operations , Resizer >
+#else
+class runge_kutta_fehlberg78 : public explicit_error_generic_rk
+#endif
+{
+
+public:
+#ifndef DOXYGEN_SKIP
+    typedef explicit_error_generic_rk< 13 , 8 , 8 , 7 , State , Value , Deriv , Time ,
+            Algebra , Operations , Resizer > stepper_base_type;
+#endif
+    typedef typename stepper_base_type::state_type state_type;
+    typedef typename stepper_base_type::value_type value_type;
+    typedef typename stepper_base_type::deriv_type deriv_type;
+    typedef typename stepper_base_type::time_type time_type;
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::operations_type operations_type;
+    typedef typename stepper_base_type::resizer_type resizer_type;
+
+    #ifndef DOXYGEN_SKIP
+    typedef typename stepper_base_type::stepper_type stepper_type;
+    typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
+    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
+    #endif // DOXYGEN_SKIP
+
+
+    runge_kutta_fehlberg78( const algebra_type &algebra = algebra_type() ) : stepper_base_type(
+            boost::fusion::make_vector( rk78_coefficients_a1<Value>() , rk78_coefficients_a2<Value>() , rk78_coefficients_a3<Value>() ,
+                    rk78_coefficients_a4<Value>() , rk78_coefficients_a5<Value>() , rk78_coefficients_a6<Value>() ,
+                    rk78_coefficients_a7<Value>() , rk78_coefficients_a8<Value>() , rk78_coefficients_a9<Value>() ,
+                    rk78_coefficients_a10<Value>() , rk78_coefficients_a11<Value>() , rk78_coefficients_a12<Value>() ) ,
+            rk78_coefficients_b<Value>() , rk78_coefficients_db<Value>() , rk78_coefficients_c<Value>() , algebra )
+    { }
+};
+
+
+
+/************* DOXYGEN *************/
+
+/**
+ * \class runge_kutta_fehlberg78
+ * \brief The Runge-Kutta Fehlberg 78 method.
+ *
+ * The Runge-Kutta Fehlberg 78 method is a standard method for high-precision applications.
+ * The method is explicit and fulfills the Error Stepper concept. Step size control
+ * is provided but continuous output is not available for this method.
+ * 
+ * This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern).
+ * Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation.
+ * For more details see explicit_error_stepper_base and explicit_error_generic_rk.
+ *
+ * \tparam State The state type.
+ * \tparam Value The value type.
+ * \tparam Deriv The type representing the time derivative of the state.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam Algebra The algebra type.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+
+    /**
+     * \fn runge_kutta_fehlberg78::runge_kutta_fehlberg78( const algebra_type &algebra )
+     * \brief Constructs the runge_kutta_cash_fehlberg78 class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+}
+}
+}
+
+#endif //BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_FEHLBERG87_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/stepper_categories.hpp b/include/boost/numeric/odeint/stepper/stepper_categories.hpp
new file mode 100644
index 0000000..9bc5372
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/stepper_categories.hpp
@@ -0,0 +1,68 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/stepper_categories.hpp
+
+ [begin_description]
+ Definition of all stepper categories.
+ [end_description]
+
+ Copyright 2010-2011 Mario Mulansky
+ Copyright 2010-2012 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_STEPPER_CATEGORIES_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_STEPPER_CATEGORIES_HPP_INCLUDED
+
+#include <boost/type_traits/integral_constant.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/*
+ * Tags to specify stepper types
+ *
+ * These tags are used by integrate() to choose which integration method is used
+ */
+
+struct stepper_tag {};
+// struct explicit_stepper_tag : stepper_tag {};
+// struct implicit_stepper_tag : stepper_tag {};
+
+
+struct error_stepper_tag : stepper_tag {};
+struct explicit_error_stepper_tag : error_stepper_tag {};
+struct explicit_error_stepper_fsal_tag : error_stepper_tag {};
+
+struct controlled_stepper_tag {};
+struct explicit_controlled_stepper_tag : controlled_stepper_tag {};
+struct explicit_controlled_stepper_fsal_tag : controlled_stepper_tag {};
+
+struct dense_output_stepper_tag {};
+
+
+template< class tag > struct base_tag ;
+template< > struct base_tag< stepper_tag > { typedef stepper_tag type; };
+template< > struct base_tag< error_stepper_tag > { typedef stepper_tag type; };
+template< > struct base_tag< explicit_error_stepper_tag > { typedef stepper_tag type; };
+template< > struct base_tag< explicit_error_stepper_fsal_tag > { typedef stepper_tag type; };
+
+template< > struct base_tag< controlled_stepper_tag > { typedef controlled_stepper_tag type; };
+template< > struct base_tag< explicit_controlled_stepper_tag > { typedef controlled_stepper_tag type; };
+template< > struct base_tag< explicit_controlled_stepper_fsal_tag > { typedef controlled_stepper_tag type; };
+
+template< > struct base_tag< dense_output_stepper_tag > { typedef dense_output_stepper_tag type; };
+
+
+} // odeint
+} // numeric
+} // boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_STEPPER_CATEGORIES_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/symplectic_euler.hpp b/include/boost/numeric/odeint/stepper/symplectic_euler.hpp
new file mode 100644
index 0000000..bd40860
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/symplectic_euler.hpp
@@ -0,0 +1,136 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/symplectic_euler.hpp
+
+ [begin_description]
+ Implementation of the symplectic Euler for separable Hamiltonian systems.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_EULER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_EULER_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp>
+
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/array.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+#ifndef DOXYGEN_SKIP
+namespace detail {
+namespace symplectic_euler_coef {
+
+template< class Value >
+struct coef_a_type : public boost::array< Value , 1 >
+{
+    coef_a_type( void )
+    {
+        (*this)[0] = static_cast< Value >( 1 );
+    }
+};
+
+template< class Value >
+struct coef_b_type : public boost::array< Value , 1 >
+{
+    coef_b_type( void )
+    {
+        (*this)[0] = static_cast< Value >( 1 );
+    }
+};
+
+} // namespace symplectic_euler_coef
+} // namespace detail
+#endif
+
+
+
+template<
+class Coor ,
+class Momentum = Coor ,
+class Value = double ,
+class CoorDeriv = Coor ,
+class MomentumDeriv = Coor ,
+class Time = Value ,
+class Algebra = typename algebra_dispatcher< Coor >::algebra_type ,
+class Operations = typename operations_dispatcher< Coor >::operations_type ,
+class Resizer = initially_resizer
+>
+#ifndef DOXYGEN_SKIP
+class symplectic_euler :
+public symplectic_nystroem_stepper_base
+<
+1 , 1 ,
+Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer
+>
+#else
+class symplectic_euler : public symplectic_nystroem_stepper_base
+#endif
+{
+public:
+
+#ifndef DOXYGEN_SKIP
+    typedef symplectic_nystroem_stepper_base<
+    1 , 1 , Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > stepper_base_type;
+#endif
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::value_type value_type;
+
+
+    symplectic_euler( const algebra_type &algebra = algebra_type() )
+    : stepper_base_type( detail::symplectic_euler_coef::coef_a_type< value_type >() ,
+            detail::symplectic_euler_coef::coef_b_type< value_type >() ,
+            algebra )
+    { }
+};
+
+
+/*************** DOXYGEN ***************/
+
+/**
+ * \class symplectic_euler
+ * \brief Implementation of the symplectic Euler method.
+ *
+ * The method is of first order and has one stage. It is described HERE.
+ *
+ * \tparam Order The order of the stepper.
+ * \tparam Coor The type representing the coordinates q.
+ * \tparam Momentum The type representing the coordinates p.
+ * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
+ * \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
+ * \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
+ * \tparam Time The type representing the time t.
+ * \tparam Algebra The algebra.
+ * \tparam Operations The operations.
+ * \tparam Resizer The resizer policy.
+ */
+
+    /**
+     * \fn symplectic_euler::symplectic_euler( const algebra_type &algebra )
+     * \brief Constructs the symplectic_euler. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_EULER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp b/include/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp
new file mode 100644
index 0000000..b33773e
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp
@@ -0,0 +1,160 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2012-2013 Karsten Ahnert
+  Copyright 2012-2013 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_M4_MCLACHLAN_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_M4_MCLACHLAN_HPP_DEFINED
+
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+#ifndef DOXYGEN_SKIP
+namespace detail {
+namespace symplectic_rkn_sb3a_m4_mclachlan {
+
+    /*
+      exp( a1 t A ) exp( b1 t B )
+      exp( a2 t A ) exp( b2 t B )
+      exp( a3 t A )
+      exp( b2 t B ) exp( a2 t A )
+      exp( b1 t B ) exp( a1 t A )
+    */
+
+
+
+    template< class Value >
+    struct coef_a_type : public boost::array< Value , 5 >
+    {
+        coef_a_type( void )
+        {
+            using std::sqrt;
+
+            Value z = sqrt( static_cast< Value >( 7 ) / static_cast< Value >( 8 ) ) / static_cast< Value >( 3 );
+            (*this)[0] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ) - z ;
+            (*this)[1] = static_cast< Value >( -1 ) / static_cast< Value >( 3 ) + z ;
+            (*this)[2] = static_cast< Value >( 2 ) / static_cast< Value >( 3 );
+            (*this)[3] = (*this)[1];
+            (*this)[4] = (*this)[0];
+        }
+    };
+
+    template< class Value >
+    struct coef_b_type : public boost::array< Value , 5 >
+    {
+        coef_b_type( void )
+        {
+            (*this)[0] = static_cast< Value >( 1 );
+            (*this)[1] = static_cast< Value >( -1 ) / static_cast< Value >( 2 );
+            (*this)[2] = (*this)[1];
+            (*this)[3] = (*this)[0];
+            (*this)[4] = static_cast< Value >( 0 );
+        }
+    };
+
+} // namespace symplectic_rkn_sb3a_m4_mclachlan
+} // namespace detail
+#endif // DOXYGEN_SKIP
+
+
+
+
+template<
+    class Coor ,
+    class Momentum = Coor ,
+    class Value = double ,
+    class CoorDeriv = Coor ,
+    class MomentumDeriv = Coor ,
+    class Time = Value ,
+    class Algebra = typename algebra_dispatcher< Coor >::algebra_type ,
+    class Operations = typename operations_dispatcher< Coor >::operations_type ,
+    class Resizer = initially_resizer
+    >
+#ifndef DOXYGEN_SKIP
+class symplectic_rkn_sb3a_m4_mclachlan :
+        public symplectic_nystroem_stepper_base
+<
+    5 , 4 ,
+    Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer
+    >
+#else
+class symplectic_rkn_sb3a_m4_mclachlan : public symplectic_nystroem_stepper_base
+#endif
+{
+public:
+#ifndef DOXYGEN_SKIP
+    typedef symplectic_nystroem_stepper_base
+    <
+    5 , 4 ,
+    Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer
+    > stepper_base_type;
+#endif
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::value_type value_type;
+
+
+    symplectic_rkn_sb3a_m4_mclachlan( const algebra_type &algebra = algebra_type() )
+        : stepper_base_type(
+            detail::symplectic_rkn_sb3a_m4_mclachlan::coef_a_type< value_type >() ,
+            detail::symplectic_rkn_sb3a_m4_mclachlan::coef_b_type< value_type >() ,
+            algebra )
+    { }
+};
+
+
+/***************** DOXYGEN ***************/
+
+/**
+ * \class symplectic_rkn_sb3a_m4_mclachlan
+ * \brief Implementation of the symmetric B3A Runge-Kutta Nystroem method of fifth order.
+ *
+ * The method is of fourth order and has five stages. It is described HERE. This method can be used
+ * with multiprecision types since the coefficients are defined analytically.
+ *
+ * ToDo: add reference to paper.
+ *
+ * \tparam Order The order of the stepper.
+ * \tparam Coor The type representing the coordinates q.
+ * \tparam Momentum The type representing the coordinates p.
+ * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
+ * \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
+ * \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
+ * \tparam Time The type representing the time t.
+ * \tparam Algebra The algebra.
+ * \tparam Operations The operations.
+ * \tparam Resizer The resizer policy.
+ */
+
+    /**
+     * \fn symplectic_rkn_sb3a_m4_mclachlan::symplectic_rkn_sb3a_m4_mclachlan( const algebra_type &algebra )
+     * \brief Constructs the symplectic_rkn_sb3a_m4_mclachlan. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_M4_MCLACHLAN_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp b/include/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp
new file mode 100644
index 0000000..d75c535
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp
@@ -0,0 +1,162 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp
+ 
+ [begin_description]
+ Implementation of the symplectic MacLachlan stepper for separable Hamiltonian system.
+ [end_description]
+ 
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2013 Mario Mulansky
+ 
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_MCLACHLAN_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_MCLACHLAN_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp>
+
+#include <boost/numeric/odeint/algebra/range_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <boost/numeric/odeint/util/resizer.hpp>
+
+#include <boost/array.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+#ifndef DOXYGEN_SKIP
+namespace detail {
+namespace symplectic_rkn_sb3a_mclachlan {
+
+    /*
+      exp( a1 t A ) exp( b1 t B )
+      exp( a2 t A ) exp( b2 t B )
+      exp( a3 t A ) exp( b3 t B ) exp( a3 t A )
+      exp( b2 t B ) exp( a2 t A )
+      exp( b1 t B ) exp( a1 t A )
+    */
+
+    template< class Value >
+    struct coef_a_type : public boost::array< Value , 6 >
+    {
+        coef_a_type( void )
+        {
+            (*this)[0] = static_cast< Value >( 0.40518861839525227722 );
+            (*this)[1] = static_cast< Value >( -0.28714404081652408900 );
+            (*this)[2] = static_cast< Value >( 1 ) / static_cast< Value >( 2 ) - ( (*this)[0] + (*this)[1] );
+            (*this)[3] = (*this)[2];
+            (*this)[4] = (*this)[1];
+            (*this)[5] = (*this)[0];
+
+        }
+    };
+
+    template< class Value >
+    struct coef_b_type : public boost::array< Value , 6 >
+    {
+        coef_b_type( void )
+        {
+            (*this)[0] = static_cast< Value >( -3 ) / static_cast< Value >( 73 );
+            (*this)[1] = static_cast< Value >( 17 ) / static_cast< Value >( 59 );
+            (*this)[2] = static_cast< Value >( 1 ) - static_cast< Value >( 2 ) * ( (*this)[0] + (*this)[1] );
+            (*this)[3] = (*this)[1];
+            (*this)[4] = (*this)[0];
+            (*this)[5] = static_cast< Value >( 0 );
+        }
+    };
+
+} // namespace symplectic_rkn_sb3a_mclachlan
+} // namespace detail
+#endif // DOXYGEN_SKIP
+
+
+
+template<
+    class Coor ,
+    class Momentum = Coor ,
+    class Value = double ,
+    class CoorDeriv = Coor ,
+    class MomentumDeriv = Coor ,
+    class Time = Value ,
+    class Algebra = typename algebra_dispatcher< Coor >::algebra_type ,
+    class Operations = typename operations_dispatcher< Coor >::operations_type ,
+    class Resizer = initially_resizer
+    >
+#ifndef DOXYGEN_SKIP
+class symplectic_rkn_sb3a_mclachlan :
+        public symplectic_nystroem_stepper_base
+<
+    6 , 4 ,
+    Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer
+    >
+#else
+class symplectic_rkn_sb3a_mclachlan : public symplectic_nystroem_stepper_base
+#endif
+{
+public:
+#ifndef DOXYGEN_SKIP
+    typedef symplectic_nystroem_stepper_base
+    <
+    6 , 4 ,
+    Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer
+    > stepper_base_type;
+#endif
+    typedef typename stepper_base_type::algebra_type algebra_type;
+    typedef typename stepper_base_type::value_type value_type;
+
+
+    symplectic_rkn_sb3a_mclachlan( const algebra_type &algebra = algebra_type() )
+        : stepper_base_type(
+            detail::symplectic_rkn_sb3a_mclachlan::coef_a_type< value_type >() ,
+            detail::symplectic_rkn_sb3a_mclachlan::coef_b_type< value_type >() ,
+            algebra )
+    { }
+};
+
+
+/************* DOXYGEN ***********/
+
+/**
+ * \class symplectic_rkn_sb3a_mclachlan
+ * \brief Implement of the symmetric B3A method of Runge-Kutta-Nystroem method of sixth order.
+ *
+ * The method is of fourth order and has six stages. It is described HERE. This method cannot be used
+ * with multiprecision types since the coefficients are not defined analytically.
+ *
+ * ToDo Add reference to the paper.
+ *
+ * \tparam Order The order of the stepper.
+ * \tparam Coor The type representing the coordinates q.
+ * \tparam Momentum The type representing the coordinates p.
+ * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
+ * \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
+ * \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
+ * \tparam Time The type representing the time t.
+ * \tparam Algebra The algebra.
+ * \tparam Operations The operations.
+ * \tparam Resizer The resizer policy.
+ */
+
+    /**
+     * \fn symplectic_rkn_sb3a_mclachlan::symplectic_rkn_sb3a_mclachlan( const algebra_type &algebra )
+     * \brief Constructs the symplectic_rkn_sb3a_mclachlan. This constructor can be used as a default
+     * constructor if the algebra has a default constructor.
+     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
+     */
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_RKN_SB3A_MCLACHLAN_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/stepper/velocity_verlet.hpp b/include/boost/numeric/odeint/stepper/velocity_verlet.hpp
new file mode 100644
index 0000000..3a20fc2
--- /dev/null
+++ b/include/boost/numeric/odeint/stepper/velocity_verlet.hpp
@@ -0,0 +1,381 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/stepper/velocity_verlet.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2009-2012 Karsten Ahnert
+  Copyright 2009-2012 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_VELOCITY_VERLET_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_STEPPER_VELOCITY_VERLET_HPP_DEFINED
+
+#include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
+#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
+
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+
+#include <boost/numeric/odeint/util/bind.hpp>
+#include <boost/numeric/odeint/util/copy.hpp>
+#include <boost/numeric/odeint/util/resizer.hpp>
+// #include <boost/numeric/odeint/util/is_pair.hpp>
+// #include <boost/array.hpp>
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+template <
+    class Coor ,
+    class Velocity = Coor ,
+    class Value = double ,
+    class Acceleration = Coor ,
+    class Time = Value ,
+    class TimeSq = Time ,
+    class Algebra = typename algebra_dispatcher< Coor >::algebra_type ,
+    class Operations = typename operations_dispatcher< Coor >::operations_type ,
+    class Resizer = initially_resizer
+      >
+class velocity_verlet : public algebra_stepper_base< Algebra , Operations >
+{
+public:
+
+    typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
+    typedef typename algebra_stepper_base_type::algebra_type algebra_type;
+    typedef typename algebra_stepper_base_type::operations_type operations_type;
+
+    typedef Coor coor_type;
+    typedef Velocity velocity_type;
+    typedef Acceleration acceleration_type;
+    typedef std::pair< coor_type , velocity_type > state_type;
+    typedef std::pair< velocity_type , acceleration_type > deriv_type;
+    typedef state_wrapper< acceleration_type > wrapped_acceleration_type;
+    typedef Value value_type;
+    typedef Time time_type;
+    typedef TimeSq time_square_type;
+    typedef Resizer resizer_type;
+    typedef stepper_tag stepper_category;
+
+    typedef unsigned short order_type;
+
+    static const order_type order_value = 1;
+
+    /**
+     * \return Returns the order of the stepper.
+     */
+    order_type order( void ) const
+    {
+        return order_value;
+    }
+
+
+    velocity_verlet( const algebra_type & algebra = algebra_type() )
+        : algebra_stepper_base_type( algebra ) , m_first_call( true )
+        , m_a1() , m_a2() , m_current_a1( true ) { }
+
+
+    template< class System , class StateInOut >
+    void do_step( System system , StateInOut & x , time_type t , time_type dt )
+    {
+        do_step_v1( system , x , t , dt );
+    }
+
+    
+    template< class System , class StateInOut >
+    void do_step( System system , const StateInOut & x , time_type t , time_type dt )
+    {
+        do_step_v1( system , x , t , dt );
+    }
+
+    
+    template< class System , class CoorIn , class VelocityIn , class AccelerationIn ,
+                             class CoorOut , class VelocityOut , class AccelerationOut >
+    void do_step( System system , CoorIn const & qin , VelocityIn const & pin , AccelerationIn const & ain ,
+                  CoorOut & qout , VelocityOut & pout , AccelerationOut & aout , time_type t , time_type dt )
+    {
+        const value_type one = static_cast< value_type >( 1.0 );
+        const value_type one_half = static_cast< value_type >( 0.5 );
+
+        algebra_stepper_base_type::m_algebra.for_each4(
+            qout , qin , pin , ain ,
+            typename operations_type::template scale_sum3< value_type , time_type , time_square_type >( one , one * dt , one_half * dt * dt ) );
+
+        typename odeint::unwrap_reference< System >::type & sys = system;
+
+        sys( qout , pin , aout , t + dt );
+
+        algebra_stepper_base_type::m_algebra.for_each4(
+            pout , pin , ain , aout ,
+            typename operations_type::template scale_sum3< value_type , time_type , time_type >( one , one_half * dt , one_half * dt ) );
+    }
+
+
+    template< class StateIn >
+    void adjust_size( const StateIn & x )
+    {
+        if( resize_impl( x ) )
+            m_first_call = true;
+    }
+
+    void reset( void )
+    {
+        m_first_call = true;
+    }
+
+    
+    /**
+     * \fn velocity_verlet::initialize( const AccelerationIn &qin )
+     * \brief Initializes the internal state of the stepper.
+     * \param deriv The acceleration of x. The next call of `do_step` expects that the acceleration of `x` passed to `do_step`
+     *              has the value of `qin`.
+     */
+    template< class AccelerationIn >
+    void initialize( const AccelerationIn & ain )
+    {
+        // alloc a
+        m_resizer.adjust_size( ain ,
+                               detail::bind( &velocity_verlet::template resize_impl< AccelerationIn > ,
+                                             detail::ref( *this ) , detail::_1 ) );
+        boost::numeric::odeint::copy( ain , get_current_acc() );
+        m_first_call = false;
+    }
+
+
+    template< class System , class CoorIn , class VelocityIn >
+    void initialize( System system , const CoorIn & qin , const VelocityIn & pin , time_type t )
+    {
+        m_resizer.adjust_size( qin ,
+                               detail::bind( &velocity_verlet::template resize_impl< CoorIn > ,
+                                             detail::ref( *this ) , detail::_1 ) );
+        initialize_acc( system , qin , pin , t );
+    }
+
+    bool is_initialized( void ) const
+    {
+        return ! m_first_call;
+    }
+
+
+private:
+    
+    template< class System , class CoorIn , class VelocityIn >
+    void initialize_acc( System system , const CoorIn & qin , const VelocityIn & pin , time_type t )
+    {
+        typename odeint::unwrap_reference< System >::type & sys = system;
+        sys( qin , pin , get_current_acc() , t );
+        m_first_call = false;
+    }
+    
+    template< class System , class StateInOut >
+    void do_step_v1( System system , StateInOut & x , time_type t , time_type dt )
+    {
+        typedef typename odeint::unwrap_reference< StateInOut >::type state_in_type;
+        typedef typename odeint::unwrap_reference< typename state_in_type::first_type >::type coor_in_type;
+        typedef typename odeint::unwrap_reference< typename state_in_type::second_type >::type momentum_in_type;
+        
+        typedef typename boost::remove_reference< coor_in_type >::type xyz_type;
+        state_in_type & statein = x;
+        coor_in_type & qinout = statein.first;
+        momentum_in_type & pinout = statein.second;
+
+        // alloc a
+        if( m_resizer.adjust_size( qinout ,
+                                   detail::bind( &velocity_verlet::template resize_impl< xyz_type > ,
+                                                 detail::ref( *this ) , detail::_1 ) )
+         || m_first_call )
+        {
+            initialize_acc( system , qinout , pinout , t );
+        }
+
+        // check first
+        do_step( system , qinout , pinout , get_current_acc() , qinout , pinout , get_old_acc() , t , dt );
+        toggle_current_acc();
+    }
+
+    template< class StateIn >
+    bool resize_impl( const StateIn & x )
+    {
+        bool resized = false;
+        resized |= adjust_size_by_resizeability( m_a1 , x , typename is_resizeable< acceleration_type >::type() );
+        resized |= adjust_size_by_resizeability( m_a2 , x , typename is_resizeable< acceleration_type >::type() );
+        return resized;
+    }
+
+    acceleration_type & get_current_acc( void )
+    {
+        return m_current_a1 ? m_a1.m_v : m_a2.m_v ;
+    }
+
+    const acceleration_type & get_current_acc( void ) const
+    {
+        return m_current_a1 ? m_a1.m_v : m_a2.m_v ;
+    }
+
+    acceleration_type & get_old_acc( void )
+    {
+        return m_current_a1 ? m_a2.m_v : m_a1.m_v ;
+    }
+
+    const acceleration_type & get_old_acc( void ) const
+    {
+        return m_current_a1 ? m_a2.m_v : m_a1.m_v ;
+    }
+
+    void toggle_current_acc( void )
+    {
+        m_current_a1 = ! m_current_a1;
+    }
+
+    resizer_type m_resizer;
+    bool m_first_call;
+    wrapped_acceleration_type m_a1 , m_a2;
+    bool m_current_a1;
+};
+
+/**
+ * \class velocity_verlet
+ * \brief The Velocity-Verlet algorithm.
+ *
+ * <a href="http://en.wikipedia.org/wiki/Verlet_integration" >The Velocity-Verlet algorithm</a> is a method for simulation of molecular dynamics systems. It solves the ODE
+ * a=f(r,v',t)  where r are the coordinates, v are the velocities and a are the accelerations, hence v = dr/dt, a=dv/dt.
+ * 
+ * \tparam Coor The type representing the coordinates.
+ * \tparam Velocity The type representing the velocities.
+ * \tparam Value The type value type.
+ * \tparam Acceleration The type representing the acceleration.
+ * \tparam Time The time representing the independent variable - the time.
+ * \tparam TimeSq The time representing the square of the time.
+ * \tparam Algebra The algebra.
+ * \tparam Operations The operations type.
+ * \tparam Resizer The resizer policy type.
+ */
+
+
+    /**
+     * \fn velocity_verlet::velocity_verlet( const algebra_type &algebra )
+     * \brief Constructs the velocity_verlet class. This constructor can be used as a default
+     * constructor if the algebra has a default constructor. 
+     * \param algebra A copy of algebra is made and stored.
+     */
+
+    
+    /**
+     * \fn velocity_verlet::do_step( System system , StateInOut &x , time_type t , time_type dt )
+     * \brief This method performs one step. It transforms the result in-place.
+     * 
+     * It can be used like
+     * \code
+     * pair< coordinates , velocities > state;
+     * stepper.do_step( sys , x , t , dt );
+     * \endcode
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Second Order System concept.
+     * \param x The state of the ODE which should be solved. The state is pair of Coor and Velocity.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+    /**
+     * \fn velocity_verlet::do_step( System system , const StateInOut &x , time_type t , time_type dt )
+     * \brief This method performs one step. It transforms the result in-place.
+     * 
+     * It can be used like
+     * \code
+     * pair< coordinates , velocities > state;
+     * stepper.do_step( sys , x , t , dt );
+     * \endcode
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Second Order System concept.
+     * \param x The state of the ODE which should be solved. The state is pair of Coor and Velocity.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */    
+
+    
+
+    /**
+     * \fn velocity_verlet::do_step( System system , CoorIn const & qin , VelocityIn const & pin , AccelerationIn const & ain , CoorOut & qout , VelocityOut & pout , AccelerationOut & aout , time_type t , time_type dt )
+     * \brief This method performs one step. It transforms the result in-place. Additionally to the other methods
+     * the coordinates, velocities and accelerations are passed directly to do_step and they are transformed out-of-place.
+     * 
+     * It can be used like
+     * \code
+     * coordinates qin , qout;
+     * velocities pin , pout;
+     * accelerations ain, aout;
+     * stepper.do_step( sys , qin , pin , ain , qout , pout , aout , t , dt );
+     * \endcode
+     *
+     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
+     *               Second Order System concept.
+     * \param x The state of the ODE which should be solved. The state is pair of Coor and Velocity.
+     * \param t The value of the time, at which the step should be performed.
+     * \param dt The step size.
+     */
+
+    
+    /**
+     * \fn void velocity_verlet::adjust_size( const StateIn &x )
+     * \brief Adjust the size of all temporaries in the stepper manually.
+     * \param x A state from which the size of the temporaries to be resized is deduced.
+     */
+
+
+    /**
+     * \fn velocity_verlet::reset( void )
+     * \brief Resets the internal state of this stepper. After calling this method it is safe to use all
+     * `do_step` method without explicitly initializing the stepper.
+     */
+
+    
+
+    /**
+     * \fn velocity_verlet::initialize( System system , const CoorIn &qin , const VelocityIn &pin , time_type t )
+     * \brief Initializes the internal state of the stepper.
+     *
+     * This method is equivalent to 
+     * \code
+     * Acceleration a;
+     * system( qin , pin , a , t );
+     * stepper.initialize( a );
+     * \endcode
+     *
+     * \param system The system function for the next calls of `do_step`.
+     * \param qin The current coordinates of the ODE.
+     * \param pin The current velocities of the ODE.
+     * \param t The current time of the ODE.
+     */
+    
+    
+    /**
+     * \fn velocity_verlet::is_initialized()
+     * \returns Returns if the stepper is initialized.
+    */
+    
+    
+    
+    
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_STEPPER_VELOCITY_VERLET_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/util/bind.hpp b/include/boost/numeric/odeint/util/bind.hpp
new file mode 100644
index 0000000..1201afa
--- /dev/null
+++ b/include/boost/numeric/odeint/util/bind.hpp
@@ -0,0 +1,101 @@
+/*
+ *     [begin_description]
+ *     Boost bind pull the placeholders, _1, _2, ... into global
+ *     namespace. This can conflict with the C++03 TR1 and C++11 
+ *     std::placeholders. This header provides a workaround for 
+ *     this problem.
+ *     [end_description]
+ *        
+ *     Copyright 2012 Christoph Koke
+ *     Copyright 2012 Karsten Ahnert
+ *           
+ *     Distributed under the Boost Software License, Version 1.0.
+ *     (See accompanying file LICENSE_1_0.txt or
+ *     copy at http://www.boost.org/LICENSE_1_0.txt)
+ * */
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_BIND_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_BIND_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/config.hpp>
+
+
+#if BOOST_NUMERIC_ODEINT_CXX11 
+    #include <functional>
+#else
+#define BOOST_BIND_NO_PLACEHOLDERS
+#include <boost/bind.hpp>
+#endif
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+#if BOOST_NUMERIC_ODEINT_CXX11 
+
+using ::std::bind;
+using namespace ::std::placeholders;
+
+
+#else
+
+// unnamed namespace to avoid multiple declarations (#138)
+namespace {
+using ::boost::bind;
+boost::arg<1> _1;
+boost::arg<2> _2;
+}
+// using ::boost::bind;
+// using ::_1;
+// using ::_2;
+
+#endif
+
+}
+}
+}
+}
+
+
+
+
+
+/*
+
+// the following is the suggested way. Unfortunately it does not work with all compilers.
+
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+#include <boost/bind.hpp>
+#else
+#include <functional>
+#endif
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+    
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+
+using ::boost::bind;
+using ::_1;
+using ::_2;
+
+#else
+
+using ::std::bind;
+using namespace ::std::placeholders;
+
+#endif
+
+
+}
+}
+}
+}*/
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_BIND_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/copy.hpp b/include/boost/numeric/odeint/util/copy.hpp
new file mode 100644
index 0000000..161f135
--- /dev/null
+++ b/include/boost/numeric/odeint/util/copy.hpp
@@ -0,0 +1,87 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/copy.hpp
+
+ [begin_description]
+ Copy abstraction for the usage in the steppers.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED
+
+
+#include <boost/range/algorithm/copy.hpp>
+
+#include <boost/utility/enable_if.hpp>
+
+#include <boost/numeric/odeint/util/detail/is_range.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+namespace detail {
+
+    template< class Container1 , class Container2 >
+    void do_copying( const Container1 &from , Container2 &to , boost::mpl::true_ )
+    {
+        boost::range::copy( from , boost::begin( to ) );
+    }
+
+    template< class Container1 , class Container2 >
+    void do_copying( const Container1 &from , Container2 &to , boost::mpl::false_ )
+    {
+        to = from;
+    }
+
+} // namespace detail
+
+
+
+/*
+ * Default implementation of the copy operation used the assign operator
+ * gsl_vector must copied differently
+ */
+template< class Container1 , class Container2 , class Enabler = void >
+struct copy_impl_sfinae
+{
+    static void copy( const Container1 &from , Container2 &to )
+    {
+        typedef typename boost::numeric::odeint::detail::is_range< Container1 >::type is_range_type;
+        detail::do_copying( from , to , is_range_type() );
+    }
+
+};
+
+template< class Container1, class Container2 >
+struct copy_impl
+{
+    static void copy( const Container1 &from , Container2 &to )
+    {
+        copy_impl_sfinae< Container1 , Container2 >::copy( from , to );
+    }
+};
+
+// ToDo: allow also to copy INTO a range, not only from a range! Needs "const Container2 &to"
+template< class Container1 , class Container2 >
+void copy( const Container1 &from , Container2 &to )
+{
+    copy_impl< Container1 , Container2 >::copy( from , to );
+}
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/detail/is_range.hpp b/include/boost/numeric/odeint/util/detail/is_range.hpp
new file mode 100644
index 0000000..a176855
--- /dev/null
+++ b/include/boost/numeric/odeint/util/detail/is_range.hpp
@@ -0,0 +1,134 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/detail/is_range.hpp
+
+ [begin_description]
+ is_range implementation. Taken from the boost::range library.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2013 Thorsten Ottosen
+
+
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_DETAIL_IS_RANGE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_DETAIL_IS_RANGE_HPP_INCLUDED
+
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <cstddef>
+#include <boost/range/config.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/and.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+
+namespace range_detail
+{
+BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator)
+    BOOST_MPL_HAS_XXX_TRAIT_DEF(const_iterator)
+}
+
+namespace detail
+{
+
+template< typename Range >
+struct is_range : boost::mpl::and_<range_detail::has_iterator<Range>, range_detail::has_const_iterator<Range> >
+{
+};
+
+//////////////////////////////////////////////////////////////////////////
+// pair
+//////////////////////////////////////////////////////////////////////////
+
+template< typename iteratorT >
+struct is_range< std::pair<iteratorT,iteratorT> > : boost::mpl::true_
+{
+};
+
+template< typename iteratorT >
+struct is_range< const std::pair<iteratorT,iteratorT> > : boost::mpl::true_
+{
+};
+
+//////////////////////////////////////////////////////////////////////////
+// array
+//////////////////////////////////////////////////////////////////////////
+
+template< typename elementT, std::size_t sz >
+struct is_range< elementT[sz] > : boost::mpl::true_
+{
+};
+
+template< typename elementT, std::size_t sz >
+struct is_range< const elementT[sz] > : boost::mpl::true_
+{
+};
+
+//////////////////////////////////////////////////////////////////////////
+// string
+//////////////////////////////////////////////////////////////////////////
+
+template<>
+struct is_range< char* > : boost::mpl::true_
+{
+};
+
+template<>
+struct is_range< wchar_t* > : boost::mpl::true_
+{
+};
+
+template<>
+struct is_range< const char* > : boost::mpl::true_
+{
+};
+
+template<>
+struct is_range< const wchar_t* > : boost::mpl::true_
+{
+};
+
+template<>
+struct is_range< char* const > : boost::mpl::true_
+{
+};
+
+template<>
+struct is_range< wchar_t* const > : boost::mpl::true_
+{
+};
+
+template<>
+struct is_range< const char* const > : boost::mpl::true_
+{
+};
+
+template<>
+struct is_range< const wchar_t* const > : boost::mpl::true_
+{
+};
+
+} // namespace detail
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_DETAIL_IS_RANGE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/detail/less_with_sign.hpp b/include/boost/numeric/odeint/util/detail/less_with_sign.hpp
new file mode 100644
index 0000000..3ffa7ca
--- /dev/null
+++ b/include/boost/numeric/odeint/util/detail/less_with_sign.hpp
@@ -0,0 +1,78 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/detail/less_with_sign.hpp
+
+ [begin_description]
+ Helper function to compare times taking into account the sign of dt
+ [end_description]
+
+ Copyright 2012-2015 Mario Mulansky
+ Copyright 2012 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_LESS_WITH_SIGN_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_LESS_WITH_SIGN_HPP_INCLUDED
+
+#include <limits>
+
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+/**
+ * return t1 < t2 if dt > 0 and t1 > t2 if dt < 0 with epsilon accuracy
+ */
+template< typename T >
+bool less_with_sign( T t1 , T t2 , T dt )
+{
+    if( get_unit_value(dt) > 0 )
+        //return t1 < t2;
+        return t2-t1 > std::numeric_limits<T>::epsilon();
+    else
+        //return t1 > t2;
+        return t1-t2 > std::numeric_limits<T>::epsilon();
+}
+
+/**
+ * return t1 <= t2 if dt > 0 and t1 => t2 if dt < 0 with epsilon accuracy
+ */
+template< typename T >
+bool less_eq_with_sign( T t1 , T t2 , T dt )
+{
+    if( get_unit_value(dt) > 0 )
+        return t1-t2 <= std::numeric_limits<T>::epsilon();
+    else
+        return t2-t1 <= std::numeric_limits<T>::epsilon();
+}
+
+template< typename T >
+T min_abs( T t1 , T t2 )
+{
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    if( get_unit_value(t1)>0 )
+        return min BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
+    else
+        return max BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
+}
+
+template< typename T >
+T max_abs( T t1 , T t2 )
+{
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    if( get_unit_value(t1)>0 )
+        return max BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
+    else
+        return min BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
+}
+} } } }
+
+#endif
diff --git a/include/boost/numeric/odeint/util/is_pair.hpp b/include/boost/numeric/odeint/util/is_pair.hpp
new file mode 100644
index 0000000..1827840
--- /dev/null
+++ b/include/boost/numeric/odeint/util/is_pair.hpp
@@ -0,0 +1,45 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/is_pair.hpp
+
+ [begin_description]
+ Metafunction to determine if a type is a std::pair<>.
+ [end_description]
+
+ Copyright 2011 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_IS_PAIR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_IS_PAIR_HPP_INCLUDED
+
+
+#include <boost/mpl/bool.hpp>
+#include <utility>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class T >
+struct is_pair : public boost::mpl::false_
+{
+};
+
+template< class T1 , class T2 >
+struct is_pair< std::pair< T1 , T2 > > : public boost::mpl::true_
+{
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_IS_PAIR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/is_resizeable.hpp b/include/boost/numeric/odeint/util/is_resizeable.hpp
new file mode 100644
index 0000000..ad7332d
--- /dev/null
+++ b/include/boost/numeric/odeint/util/is_resizeable.hpp
@@ -0,0 +1,83 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/is_resizeable.hpp
+
+ [begin_description]
+ Metafunction to determine if a state type can resized. For usage in the steppers.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_IS_RESIZEABLE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_IS_RESIZEABLE_HPP_INCLUDED
+
+
+#include <vector>
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/include/front.hpp>
+#include <boost/fusion/include/is_sequence.hpp>
+
+#include <boost/mpl/find_if.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+   
+/*
+ * by default any type is not resizable
+ */
+template< typename Container , typename Enabler = void >
+struct is_resizeable_sfinae : boost::false_type {};
+
+template< typename Container >
+struct is_resizeable : is_resizeable_sfinae< Container > {};
+
+
+
+/*
+ * specialization for std::vector
+ */
+template< class V, class A >
+struct is_resizeable< std::vector< V , A  > > : boost::true_type {};
+
+
+/*
+ * sfinae specialization for fusion sequences
+ */
+template< typename FusionSequence >
+struct is_resizeable_sfinae<
+    FusionSequence ,
+    typename boost::enable_if< typename boost::fusion::traits::is_sequence< FusionSequence >::type >::type >
+{
+    typedef typename boost::mpl::find_if< FusionSequence , is_resizeable< boost::mpl::_1 > >::type iter;
+    typedef typename boost::mpl::end< FusionSequence >::type last;
+
+    typedef typename boost::mpl::if_< boost::is_same< iter , last > , boost::false_type , boost::true_type >::type type;
+    const static bool value = type::value;
+};
+
+
+
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_IS_RESIZEABLE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/multi_array_adaption.hpp b/include/boost/numeric/odeint/util/multi_array_adaption.hpp
new file mode 100644
index 0000000..e2c0a48
--- /dev/null
+++ b/include/boost/numeric/odeint/util/multi_array_adaption.hpp
@@ -0,0 +1,130 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/util/multi_array_adaption.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2009-2012 Karsten Ahnert
+  Copyright 2009-2012 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED
+
+
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/multi_array.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+    
+template< typename T >
+struct is_multi_array
+{
+    typedef boost::false_type type;
+    const static bool value = type::value;
+};
+    
+template< typename T >
+struct is_resizeable_multi_array
+{
+    typedef boost::false_type type;
+    const static bool value = type::value;
+};
+
+
+
+template< typename V , size_t Dim , typename A >
+struct is_multi_array< boost::multi_array< V , Dim , A > >
+{
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+template< typename V , size_t Dim , typename A >
+struct is_resizeable_multi_array< boost::multi_array< V , Dim , A > >
+{
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+
+
+
+template< typename T  >
+struct is_resizeable_sfinae< T , typename boost::enable_if< typename is_resizeable_multi_array< T >::type >::type >
+{
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+
+
+
+
+template< typename T1 , typename T2  >
+struct same_size_impl_sfinae< T1 , T2 ,
+                       typename boost::enable_if<
+                           typename boost::mpl::and_< 
+                               is_multi_array< T1 > ,
+                               is_multi_array< T2 > ,
+                               boost::mpl::bool_< T1::dimensionality == T2::dimensionality >
+                           >::type
+                       >::type >
+{
+    static bool same_size( T1 const &x1 , T2 const &x2 )
+    {
+        for( size_t i=0 ; i<T1::dimensionality ; ++i )
+        {
+            if( x1.shape()[i] != x2.shape()[i] ) return false;
+            if( x1.index_bases()[i] != x2.index_bases()[i] ) return false;
+        }
+        return true;
+    }
+};
+
+
+template< typename T1 , typename T2 >
+struct resize_impl_sfinae< T1 , T2 ,
+                    typename boost::enable_if<
+                        typename boost::mpl::and_<
+                            is_resizeable_multi_array< T1 > ,
+                            is_multi_array< T2 > ,
+                            boost::mpl::bool_< T1::dimensionality == T2::dimensionality >
+                        >::type
+                    >::type >
+{
+    static void resize( T1 &x1 , const T2 &x2 )
+    {
+        boost::array< int , T1::dimensionality > extents;
+        for( size_t i=0 ; i<T1::dimensionality ; ++i ) extents[i] = x2.shape()[i];
+        x1.resize( extents );
+        boost::array< int , T1::dimensionality > origins;
+        for( size_t i=0 ; i<T1::dimensionality ; ++i ) origins[i] = x2.index_bases()[i];
+        x1.reindex( origins );
+    }
+};
+                            
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/util/n_ary_helper.hpp b/include/boost/numeric/odeint/util/n_ary_helper.hpp
new file mode 100644
index 0000000..6138074
--- /dev/null
+++ b/include/boost/numeric/odeint/util/n_ary_helper.hpp
@@ -0,0 +1,96 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/n_ary_helper.hpp
+
+ Macros to generate scale_sumN and for_eachN functors.
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+ Copyright 2013 Pascal Germroth
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_N_ARY_HELPER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_N_ARY_HELPER_HPP_INCLUDED
+
+#include <boost/preprocessor/repetition.hpp>
+
+// like BOOST_PP_ENUM_SHIFTED but with a comma in front like _TRAILING
+#define BOOST_ODEINT_ENUM_TRAILING_SHIFTED_PARAMS(count, param) \
+    BOOST_PP_COMMA_IF(BOOST_PP_DEC(count)) \
+    BOOST_PP_ENUM_SHIFTED_PARAMS(count, param)
+
+#define BOOST_ODEINT_ENUM_TRAILING_SHIFTED_BINARY_PARAMS(count, p1, p2) \
+    BOOST_PP_COMMA_IF(BOOST_PP_DEC(count)) \
+    BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(count, p1, p2)
+
+// like BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(n, p1, p2) but p2 is shifted left.
+// generate "p1 ## 0 = p2, p1 ## 1 = p3 ## 0, p1 ## 2 = p3 ## 1"
+#define BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS(count, p1, p2, p3) \
+    BOOST_PP_ENUM(count, BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS_, (p1, p2, p3))
+#define BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS_(z, n, data) \
+    BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, data), n) \
+    BOOST_PP_IF(n, \
+        BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 2, data), BOOST_PP_DEC(n)), \
+        BOOST_PP_TUPLE_ELEM(3, 1, data))
+
+// like BOOST_PP_ENUM_BINARY_PARAMS(n, p1, p2) but with statements.
+// "p1 ## 0 p2 ## 0 ; p1 ## 1 p2 ## 1 ; ..."
+#define BOOST_ODEINT_ENUM_BINARY_STATEMENTS(count, p1, p2) \
+    BOOST_PP_REPEAT(count, BOOST_ODEINT_ENUM_BINARY_STATEMENTS_, (p1, p2))
+#define BOOST_ODEINT_ENUM_BINARY_STATEMENTS_(z, n, data) \
+    BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n) \
+    BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n) ;
+
+// like BOOST_PP_ENUM_BINARY_PARAMS(n, p1, p2) but p2 is in parens.
+// "p1 ## 0 (p2 ## 0) , p1 ## 1 (p2 ## 1) , ..."
+#define BOOST_ODEINT_ENUM_UNARY_CALLS(count, p1, p2) \
+    BOOST_PP_ENUM(count, BOOST_ODEINT_ENUM_UNARY_CALLS_, (p1, p2))
+#define BOOST_ODEINT_ENUM_SHIFTED_UNARY_CALLS(count, p1, p2) \
+    BOOST_PP_ENUM_SHIFTED(count, BOOST_ODEINT_ENUM_UNARY_CALLS_, (p1, p2))
+#define BOOST_ODEINT_ENUM_TRAILING_SHIFTED_UNARY_CALLS(count, p1, p2) \
+    BOOST_PP_COMMA_IF(BOOST_PP_DEC(count)) \
+    BOOST_PP_ENUM_SHIFTED(count, BOOST_ODEINT_ENUM_UNARY_CALLS_, (p1, p2))
+#define BOOST_ODEINT_ENUM_UNARY_CALLS_(z, n, data) \
+      BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n) \
+    ( BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n) )
+
+
+// maximum arity + 1 for scale_sum and for_each
+#define BOOST_ODEINT_N_ARY_MAX 16
+
+
+// generate scale_sum1 to scale_sumN, operator body generated by macro(N)
+#define BOOST_ODEINT_GEN_SCALE_SUM(macro) \
+    BOOST_PP_REPEAT_FROM_TO(1, BOOST_ODEINT_N_ARY_MAX, BOOST_ODEINT_GEN_SCALE_SUM_, macro)
+#define BOOST_ODEINT_GEN_SCALE_SUM_(z, n, macro) \
+    template< BOOST_ODEINT_ENUM_LSHIFTED_BINARY_PARAMS(n, class Fac, = double, = Fac) > \
+    struct BOOST_PP_CAT(scale_sum, n) \
+    { \
+        BOOST_ODEINT_ENUM_BINARY_STATEMENTS(n, const Fac, m_alpha) \
+        \
+        BOOST_PP_CAT(scale_sum, n) \
+        ( BOOST_PP_ENUM_BINARY_PARAMS(n, Fac, alpha) ) \
+        : BOOST_ODEINT_ENUM_UNARY_CALLS(n, m_alpha, alpha) {} \
+        \
+        template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), class T) > \
+        void operator()( T0 &t0 \
+            BOOST_ODEINT_ENUM_TRAILING_SHIFTED_BINARY_PARAMS(BOOST_PP_INC(n), const T, &t) \
+        ) const \
+        { macro(n) } \
+        typedef void result_type; \
+    };
+
+// generate for_each1 to for_eachN, body generated by macro(N)
+#define BOOST_ODEINT_GEN_FOR_EACH(macro) \
+    BOOST_PP_REPEAT_FROM_TO(1, BOOST_ODEINT_N_ARY_MAX, BOOST_ODEINT_GEN_FOR_EACH_, macro)
+#define BOOST_ODEINT_GEN_FOR_EACH_(z, n, macro) \
+    template< BOOST_PP_ENUM_PARAMS(n, class S) , class Op > \
+    static void for_each##n ( BOOST_PP_ENUM_BINARY_PARAMS(n, S, &s) , Op op ) \
+    { macro(n) }
+
+
+#endif
diff --git a/include/boost/numeric/odeint/util/odeint_error.hpp b/include/boost/numeric/odeint/util/odeint_error.hpp
new file mode 100644
index 0000000..312e5b1
--- /dev/null
+++ b/include/boost/numeric/odeint/util/odeint_error.hpp
@@ -0,0 +1,77 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/odeint_error.hpp
+
+ [begin_description]
+ Runtime Exceptions thrown by odeint
+ [end_description]
+
+ Copyright 2015 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_ODEINT_ERROR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_ODEINT_ERROR_HPP_INCLUDED
+
+#include <stdexcept>
+#include <string>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+/**
+ * \brief Runtime error thrown by odeint
+ */
+class odeint_error : public std::runtime_error
+{
+public:
+    odeint_error(const std::string &s)
+            : std::runtime_error(s)
+    { }
+};
+
+
+/**
+ * \brief Runtime error thrown from integrate routines
+ *
+ * This Error occures when too many iterations are performed in between two
+ * observer calls in the integrate routines.
+ */
+class no_progress_error : public odeint_error
+{
+public:
+    no_progress_error(const std::string &s)
+            : odeint_error(s)
+    { }
+};
+
+
+/**
+ * \brief Runtime error thrown during stepsize adjustment
+ *
+ * This Error occures when too many iterations are performed without finding
+ * an appropriate new step size. This usually indicates non-continuous points
+ * in the ODE.
+ */
+class step_adjustment_error : public odeint_error
+{
+public:
+    step_adjustment_error(const std::string &s)
+            : odeint_error(s)
+    { }
+};
+
+}
+}
+}
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_ODEINT_ERROR_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/resize.hpp b/include/boost/numeric/odeint/util/resize.hpp
new file mode 100644
index 0000000..3645782
--- /dev/null
+++ b/include/boost/numeric/odeint/util/resize.hpp
@@ -0,0 +1,118 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/state_wrapper.hpp
+
+ [begin_description]
+ State wrapper for the state type in all stepper. The state wrappers are responsible for construction,
+ destruction, copying construction, assignment and resizing.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_RESIZE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_RESIZE_HPP_INCLUDED
+
+#include <boost/range.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/include/is_sequence.hpp>
+#include <boost/fusion/include/zip_view.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/make_fused.hpp>
+#include <boost/fusion/include/for_each.hpp>
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template< class StateOut , class StateIn , class Enabler = void >
+struct resize_impl_sfinae
+{
+    static void resize( StateOut &x1 , const StateIn &x2 )
+    {
+        x1.resize( boost::size( x2 ) );
+    }
+};
+
+// resize function
+// standard implementation relies on boost.range and resize member function
+template< class StateOut , class StateIn >
+struct resize_impl
+{
+    static void resize( StateOut &x1 , const StateIn &x2 )
+    {
+        resize_impl_sfinae< StateOut , StateIn >::resize( x1 , x2 );
+    }
+};
+
+
+// do not overload or specialize this function, specialize resize_impl<> instead
+template< class StateOut , class StateIn >
+void resize( StateOut &x1 , const StateIn &x2 )
+{
+    resize_impl< StateOut , StateIn >::resize( x1 , x2 );
+}
+
+
+namespace detail {
+
+    struct resizer
+    {
+        typedef void result_type;
+
+        template< class StateOut , class StateIn >
+        void operator()( StateOut &x1 , const StateIn &x2 ) const
+        {
+            resize_op( x1 , x2 , typename is_resizeable< StateOut >::type() );
+        }
+
+        template< class StateOut , class StateIn >
+        void resize_op( StateOut &x1 , const StateIn &x2 , boost::true_type ) const
+        {
+            resize( x1 , x2 );
+        }
+
+        template< class StateOut , class StateIn >
+        void resize_op( StateOut &/*x1*/ , const StateIn &/*x2*/ , boost::false_type ) const
+        {
+        }
+
+    };
+} // namespace detail
+
+
+/*
+ * specialization for fusion sequences
+ */
+template< class FusionSeq >
+struct resize_impl_sfinae< FusionSeq , FusionSeq ,
+    typename boost::enable_if< typename boost::fusion::traits::is_sequence< FusionSeq >::type >::type >
+{
+    static void resize( FusionSeq &x1 , const FusionSeq &x2 )
+    {
+        typedef boost::fusion::vector< FusionSeq& , const FusionSeq& > Sequences;
+        Sequences sequences( x1 , x2 );
+        boost::fusion::for_each( boost::fusion::zip_view< Sequences >( sequences ) , boost::fusion::make_fused( detail::resizer() ) );
+    }
+};
+
+
+
+
+}
+}
+}
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_RESIZE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/resizer.hpp b/include/boost/numeric/odeint/util/resizer.hpp
new file mode 100644
index 0000000..cd27990
--- /dev/null
+++ b/include/boost/numeric/odeint/util/resizer.hpp
@@ -0,0 +1,93 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/resizer.hpp
+
+ [begin_description]
+ Implementation of the resizers.
+ [end_description]
+
+ Copyright 2011-2012 Mario Mulansky
+ Copyright 2011 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_RESIZER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_RESIZER_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class ResizeWrappedState , class State >
+bool adjust_size_by_resizeability( ResizeWrappedState &x , const State &y , boost::true_type )
+{
+    if ( !same_size( x.m_v , y ) )
+    {
+        resize( x.m_v , y );
+        return true;
+    }
+    else
+        return false;
+}
+
+template< class ResizeWrappedState , class State >
+bool adjust_size_by_resizeability( ResizeWrappedState & /* x */ , const State & /* y */ , boost::false_type )
+{
+    return false;
+}
+
+struct always_resizer
+{
+    template< class State , class ResizeFunction >
+    bool adjust_size( const State &x , ResizeFunction f )
+    {
+        return f( x );
+    }
+};
+
+
+struct initially_resizer
+{
+
+    bool m_initialized;
+
+    initially_resizer() : m_initialized( false )
+    { }
+
+    template< class State , class ResizeFunction >
+    bool adjust_size( const State &x , ResizeFunction f )
+    {
+        if( !m_initialized )
+        {
+            m_initialized = true;
+            return f( x );
+        } else
+            return false;
+    }
+};
+
+
+struct never_resizer
+{
+    template< class State , class ResizeFunction >
+    bool adjust_size( const State &/*x*/ , ResizeFunction /*f*/ )
+    {
+        return false;
+    }
+};
+
+
+}
+}
+}
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_RESIZER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/same_instance.hpp b/include/boost/numeric/odeint/util/same_instance.hpp
new file mode 100644
index 0000000..a889ee1
--- /dev/null
+++ b/include/boost/numeric/odeint/util/same_instance.hpp
@@ -0,0 +1,56 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/same_instance.hpp
+
+ [begin_description]
+ Basic check if two variables are the same instance
+ [end_description]
+
+ Copyright 2012 Karsten Ahnert
+ Copyright 2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_SAME_INSTANCE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_SAME_INSTANCE_HPP_INCLUDED
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class T1 , class T2 , class Enabler=void >
+struct same_instance_impl
+{ 
+    static bool same_instance( const T1& /* x1 */ , const T2& /* x2 */ )
+    {
+        return false;
+    }
+};
+
+template< class T >
+struct same_instance_impl< T , T >
+{ 
+    static bool same_instance( const T &x1 , const T &x2 )
+    {
+        // check pointers
+        return (&x1 == &x2);
+    }
+};
+
+
+template< class T1 , class T2 >
+bool same_instance( const T1 &x1 , const T2 &x2 )
+{
+    return same_instance_impl< T1 , T2 >::same_instance( x1 , x2 );
+}
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+#endif
diff --git a/include/boost/numeric/odeint/util/same_size.hpp b/include/boost/numeric/odeint/util/same_size.hpp
new file mode 100644
index 0000000..81ae249
--- /dev/null
+++ b/include/boost/numeric/odeint/util/same_size.hpp
@@ -0,0 +1,115 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/state_wrapper.hpp
+
+ [begin_description]
+ State wrapper for the state type in all stepper. The state wrappers are responsible for construction,
+ destruction, copying construction, assignment and resizing.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_SAME_SIZE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_SAME_SIZE_HPP_INCLUDED
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/include/is_sequence.hpp>
+#include <boost/fusion/include/zip_view.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/make_fused.hpp>
+#include <boost/fusion/include/all.hpp>
+
+#include <boost/range.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+    
+template< typename State1 , typename State2 , class Enabler = void >
+struct same_size_impl_sfinae
+{
+    static bool same_size( const State1 &x1 , const State2 &x2 )
+    {
+        return ( boost::size( x1 ) == boost::size( x2 ) );
+    }
+
+};
+
+// same_size function
+// standard implementation relies on boost.range
+template< class State1 , class State2 >
+struct same_size_impl
+{
+    static bool same_size( const State1 &x1 , const State2 &x2 )
+    {
+        return same_size_impl_sfinae< State1 , State2 >::same_size( x1 , x2 );
+    }
+};
+
+
+// do not overload or specialize this function, specialize resize_impl<> instead
+template< class State1 , class State2 >
+bool same_size( const State1 &x1 , const State2 &x2 )
+{
+    return same_size_impl< State1 , State2 >::same_size( x1 , x2 );
+}
+
+namespace detail {
+
+struct same_size_fusion
+{
+    typedef bool result_type;
+
+    template< class S1 , class S2 >
+    bool operator()( const S1 &x1 , const S2 &x2 ) const
+    {
+        return same_size_op( x1 , x2 , typename is_resizeable< S1 >::type() );
+    }
+
+    template< class S1 , class S2 >
+    bool same_size_op( const S1 &x1 , const S2 &x2 , boost::true_type ) const
+    {
+        return same_size( x1 , x2 );
+    }
+
+    template< class S1 , class S2 >
+    bool same_size_op( const S1 &/*x1*/ , const S2 &/*x2*/ , boost::false_type ) const
+    {
+        return true;
+    }
+};
+
+} // namespace detail
+
+
+
+template< class FusionSeq >
+struct same_size_impl_sfinae< FusionSeq , FusionSeq , typename boost::enable_if< typename boost::fusion::traits::is_sequence< FusionSeq >::type >::type >
+{
+    static bool same_size( const FusionSeq &x1 , const FusionSeq &x2 )
+    {
+        typedef boost::fusion::vector< const FusionSeq& , const FusionSeq& > Sequences;
+        Sequences sequences( x1 , x2 );
+        return boost::fusion::all( boost::fusion::zip_view< Sequences >( sequences ) ,
+                                   boost::fusion::make_fused( detail::same_size_fusion() ) );
+    }
+};
+
+
+}
+}
+}
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_SAME_SIZE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/split.hpp b/include/boost/numeric/odeint/util/split.hpp
new file mode 100644
index 0000000..ba9875a
--- /dev/null
+++ b/include/boost/numeric/odeint/util/split.hpp
@@ -0,0 +1,64 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/split.hpp
+
+ [begin_description]
+ Split abstraction for parallel backends.
+ [end_description]
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+ Copyright 2013 Pascal Germroth
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_SPLIT_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_SPLIT_HPP_INCLUDED
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/*
+ * No default implementation of the split operation
+ */
+template< class Container1, class Container2 , class Enabler = void >
+struct split_impl
+{
+    static void split( const Container1 &from , Container2 &to );
+};
+
+template< class Container1 , class Container2 >
+void split( const Container1 &from , Container2 &to )
+{
+    split_impl< Container1 , Container2 >::split( from , to );
+}
+
+
+/*
+ * No default implementation of the unsplit operation
+ */
+template< class Container1, class Container2 , class Enabler = void >
+struct unsplit_impl
+{
+    static void unsplit( const Container1 &from , Container2 &to );
+};
+
+template< class Container1 , class Container2 >
+void unsplit( const Container1 &from , Container2 &to )
+{
+    unsplit_impl< Container1 , Container2 >::unsplit( from , to );
+}
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED
+
diff --git a/include/boost/numeric/odeint/util/split_adaptor.hpp b/include/boost/numeric/odeint/util/split_adaptor.hpp
new file mode 100644
index 0000000..cf0d623
--- /dev/null
+++ b/include/boost/numeric/odeint/util/split_adaptor.hpp
@@ -0,0 +1,102 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/split_adaptor.hpp
+
+ [begin_description]
+ A range adaptor which returns even-sized slices.
+ [end_description]
+
+ Copyright 2013 Karsten Ahnert
+ Copyright 2013 Mario Mulansky
+ Copyright 2013 Pascal Germroth
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_SPLIT_ADAPTOR_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_SPLIT_ADAPTOR_INCLUDED
+
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/size_type.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <algorithm>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+/** \brief Returns the begin and end offset for a sub-range */
+inline std::pair<std::size_t, std::size_t>
+split_offsets( std::size_t total_length, std::size_t index, std::size_t parts )
+{
+    BOOST_ASSERT( parts > 0 );
+    BOOST_ASSERT( index < parts );
+    const std::size_t
+        slice = total_length / parts,
+        partial = total_length % parts,
+        lo = (std::min)(index, partial),
+        hi = (std::max<std::ptrdiff_t>)(0, index - partial),
+        begin_offset = lo * (slice + 1) + hi * slice,
+        length = slice + (index < partial ? 1 : 0),
+        end_offset = begin_offset + length;
+    return std::make_pair( begin_offset, end_offset );
+}
+
+/** \brief Return the sub-range `index` from a range which is split into `parts`.
+ *
+ * For example, splitting a range into three about equal-sized sub-ranges:
+ * \code
+ * sub0 = make_split_range(rng, 0, 3);
+ * sub1 = rng | split(1, 3);
+ * sub2 = rng | split(2, 3);
+ * \endcode
+ */
+template< class RandomAccessRange >
+inline iterator_range< typename range_iterator<RandomAccessRange>::type >
+make_split_range( RandomAccessRange& rng, std::size_t index, std::size_t parts )
+{
+    const std::pair<std::size_t, std::size_t> off = split_offsets(boost::size(rng), index, parts);
+    return make_iterator_range( boost::begin(rng) + off.first, boost::begin(rng) + off.second );
+}
+
+template< class RandomAccessRange >
+inline iterator_range< typename range_iterator<const RandomAccessRange>::type >
+make_split_range( const RandomAccessRange& rng, std::size_t index, std::size_t parts )
+{
+    const std::pair<std::size_t, std::size_t> off = split_offsets(boost::size(rng), index, parts);
+    return make_iterator_range( boost::begin(rng) + off.first, boost::begin(rng) + off.second );
+}
+
+
+struct split
+{
+    split(std::size_t index, std::size_t parts)
+        : index(index), parts(parts) {}
+    std::size_t index, parts;
+};
+
+template< class RandomAccessRange >
+inline iterator_range< typename range_iterator<RandomAccessRange>::type >
+operator|( RandomAccessRange& rng, const split& f )
+{
+    return make_split_range( rng, f.index, f.parts );
+}
+
+template< class RandomAccessRange >
+inline iterator_range< typename range_iterator<const RandomAccessRange>::type >
+operator|( const RandomAccessRange& rng, const split& f )
+{
+    return make_split_range( rng, f.index, f.parts );
+}
+
+
+}
+}
+}
+}
+
+#endif
diff --git a/include/boost/numeric/odeint/util/state_wrapper.hpp b/include/boost/numeric/odeint/util/state_wrapper.hpp
new file mode 100644
index 0000000..10f8ecd
--- /dev/null
+++ b/include/boost/numeric/odeint/util/state_wrapper.hpp
@@ -0,0 +1,50 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/state_wrapper.hpp
+
+ [begin_description]
+ State wrapper for the state type in all stepper. The state wrappers are responsible for construction,
+ destruction, copying construction, assignment and resizing.
+ [end_description]
+
+ Copyright 2011-2012 Mario Mulansky
+ Copyright 2011-2013 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_STATE_WRAPPER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_STATE_WRAPPER_HPP_INCLUDED
+
+
+#include <boost/type_traits/integral_constant.hpp>
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+template< class V , class Enabler = void >
+struct state_wrapper
+{
+    typedef state_wrapper< V > state_wrapper_type;
+
+    V m_v;
+};
+
+
+}
+}
+}
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_STATE_WRAPPER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/stepper_traits.hpp b/include/boost/numeric/odeint/util/stepper_traits.hpp
new file mode 100644
index 0000000..5d1d31a
--- /dev/null
+++ b/include/boost/numeric/odeint/util/stepper_traits.hpp
@@ -0,0 +1,63 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/util/stepper_traits.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2013 Karsten Ahnert
+  Copyright 2013 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_STEPPER_TRAITS_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_UTIL_STEPPER_TRAITS_HPP_DEFINED
+
+#include <boost/numeric/odeint/util/unwrap_reference.hpp>
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace traits {
+
+template< class Stepper >
+struct state_type
+{
+    typedef typename boost::numeric::odeint::unwrap_reference< Stepper >::type stepper_type;
+    typedef typename stepper_type::state_type type;
+};
+
+template< class Stepper >
+struct time_type
+{
+    typedef typename boost::numeric::odeint::unwrap_reference< Stepper >::type stepper_type;
+    typedef typename stepper_type::time_type type;
+};
+
+template< class Stepper >
+struct stepper_category
+{
+    typedef typename boost::numeric::odeint::unwrap_reference< Stepper >::type stepper_type;
+    typedef typename stepper_type::stepper_category type;
+};
+
+template< class Stepper >
+struct value_type
+{
+    typedef typename boost::numeric::odeint::unwrap_reference< Stepper >::type stepper_type;
+    typedef typename stepper_type::value_type type;
+};
+
+} // namespace traits
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_STEPPER_TRAITS_HPP_DEFINED
diff --git a/include/boost/numeric/odeint/util/ublas_matrix_expression.patch b/include/boost/numeric/odeint/util/ublas_matrix_expression.patch
new file mode 100644
index 0000000..4e8ac6c
--- /dev/null
+++ b/include/boost/numeric/odeint/util/ublas_matrix_expression.patch
@@ -0,0 +1,6 @@
+3390,3392c3390
+<     typename enable_if< is_convertible<typename E1::value_type , T2>,
+<                         typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type 
+<                         > ::result_type
+---
+>     typename matrix_binary_scalar2_traits<E1, const T2, scalar_divides<typename E1::value_type, T2> >::result_type
diff --git a/include/boost/numeric/odeint/util/ublas_wrapper.hpp b/include/boost/numeric/odeint/util/ublas_wrapper.hpp
new file mode 100644
index 0000000..c8facfc
--- /dev/null
+++ b/include/boost/numeric/odeint/util/ublas_wrapper.hpp
@@ -0,0 +1,297 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/ublas_wrapper.hpp
+
+ [begin_description]
+ Resizing for ublas::vector and ublas::matrix
+ [end_description]
+
+ Copyright 2011-2013 Mario Mulansky
+ Copyright 2011-2013 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED
+
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/matrix.hpp>
+#include <boost/numeric/ublas/lu.hpp>
+#include <boost/numeric/ublas/vector_expression.hpp>
+#include <boost/numeric/ublas/matrix_expression.hpp>
+
+#include <boost/numeric/odeint/algebra/vector_space_algebra.hpp>
+#include <boost/numeric/odeint/algebra/default_operations.hpp>
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/state_wrapper.hpp>
+
+
+/* extend ublas by a few operations */
+
+/* map norm_inf onto reduce( v , default_operations::maximum ) */
+namespace boost { namespace numeric { namespace odeint {
+
+    template< typename T , typename A >
+    struct vector_space_norm_inf< boost::numeric::ublas::vector<T,A> >
+    {
+        typedef T result_type;
+
+        result_type operator()( const boost::numeric::ublas::vector<T,A> &x ) const
+        {
+            return boost::numeric::ublas::norm_inf( x );
+        }
+    };
+
+
+    template< class T , class L , class A >
+    struct vector_space_norm_inf< boost::numeric::ublas::matrix<T,L,A> >
+    {
+        typedef T result_type;
+
+        result_type operator()( const boost::numeric::ublas::matrix<T,L,A> &x ) const
+        {
+            return boost::numeric::ublas::norm_inf( x );
+        }
+    };
+} } }
+
+/* additional operations:
+ * abs( v )
+ * v / w
+ * a + v
+ */
+namespace boost { namespace numeric { namespace ublas {
+
+
+    // elementwise abs - calculates absolute values of the elements
+    template<class T>
+    struct scalar_abs: public scalar_unary_functor<T> {
+        typedef typename scalar_unary_functor<T>::value_type value_type;
+        typedef typename scalar_unary_functor<T>::argument_type argument_type;
+        typedef typename scalar_unary_functor<T>::result_type result_type;
+
+        static BOOST_UBLAS_INLINE
+        result_type apply (argument_type t) {
+            using std::abs;
+            return abs (t);
+        }
+    };
+
+
+    // (abs v) [i] = abs (v [i])
+    template<class E>
+    BOOST_UBLAS_INLINE
+    typename vector_unary_traits<E, scalar_abs<typename E::value_type> >::result_type
+    abs (const vector_expression<E> &e) {
+        typedef typename vector_unary_traits<E, scalar_abs<typename E::value_type> >::expression_type expression_type;
+        return expression_type (e ());
+    }
+
+    // (abs m) [i] = abs (m [i])
+    template<class E>
+    BOOST_UBLAS_INLINE
+    typename matrix_unary1_traits<E, scalar_abs<typename E::value_type> >::result_type
+    abs (const matrix_expression<E> &e) {
+        typedef typename matrix_unary1_traits<E, scalar_abs<typename E::value_type> >::expression_type expression_type;
+        return expression_type (e ());
+    }
+
+
+    // elementwise division (v1 / v2) [i] = v1 [i] / v2 [i]
+    template<class E1, class E2>
+    BOOST_UBLAS_INLINE
+    typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
+                                                         typename E2::value_type> >::result_type
+    operator / (const vector_expression<E1> &e1,
+                const vector_expression<E2> &e2) {
+        typedef typename vector_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
+                                                                     typename E2::value_type> >::expression_type expression_type;
+        return expression_type (e1 (), e2 ());
+    }
+
+
+    // elementwise division (m1 / m2) [i] = m1 [i] / m2 [i]
+    template<class E1, class E2>
+    BOOST_UBLAS_INLINE
+    typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
+    typename E2::value_type> >::result_type
+    operator / (const matrix_expression<E1> &e1,
+                const matrix_expression<E2> &e2) {
+        typedef typename matrix_binary_traits<E1, E2, scalar_divides<typename E1::value_type,
+                                                                     typename E2::value_type> >::expression_type expression_type;
+        return expression_type (e1 (), e2 ());
+    }
+
+    // addition with scalar
+    // (t + v) [i] = t + v [i]
+    template<class T1, class E2>
+    BOOST_UBLAS_INLINE
+    typename enable_if< is_convertible<T1, typename E2::value_type >,
+    typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::result_type
+    >::type
+    operator + (const T1 &e1,
+                const vector_expression<E2> &e2) {
+        typedef typename vector_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::expression_type expression_type;
+        return expression_type (e1, e2 ());
+    }
+
+    // addition with scalar
+    // (t + m) [i] = t + m [i]
+    template<class T1, class E2>
+    BOOST_UBLAS_INLINE
+    typename enable_if< is_convertible<T1, typename E2::value_type >,
+    typename matrix_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::result_type
+    >::type
+    operator + (const T1 &e1,
+                const matrix_expression<E2> &e2) {
+        typedef typename matrix_binary_scalar1_traits<const T1, E2, scalar_plus<T1, typename E2::value_type> >::expression_type expression_type;
+        return expression_type (e1, e2 ());
+    }
+
+} } }
+
+
+
+
+/* add resize functionality */
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+/*
+ * resizeable specialization for boost::numeric::ublas::vector
+ */
+template< class T , class A >
+struct is_resizeable< boost::numeric::ublas::vector< T , A > >
+{
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+
+/*
+ * resizeable specialization for boost::numeric::ublas::matrix
+ */
+template< class T , class L , class A >
+struct is_resizeable< boost::numeric::ublas::matrix< T , L , A > >
+{
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+
+/*
+ * resizeable specialization for boost::numeric::ublas::permutation_matrix
+ */
+template< class T , class A >
+struct is_resizeable< boost::numeric::ublas::permutation_matrix< T , A > >
+{
+    typedef boost::true_type type;
+    const static bool value = type::value;
+};
+
+
+// specialization for ublas::matrix
+// same size and resize specialization for matrix-matrix resizing
+template< class T , class L , class A , class T2 , class L2 , class A2 >
+struct same_size_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::matrix< T2 , L2 , A2 > >
+{
+    static bool same_size( const boost::numeric::ublas::matrix< T , L , A > &m1 ,
+                           const boost::numeric::ublas::matrix< T2 , L2 , A2 > &m2 )
+    {
+        return ( ( m1.size1() == m2.size1() ) && ( m1.size2() == m2.size2() ) );
+    }
+};
+
+template< class T , class L , class A , class T2 , class L2 , class A2 >
+struct resize_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::matrix< T2 , L2 , A2 > >
+{
+    static void resize( boost::numeric::ublas::matrix< T , L , A > &m1 ,
+                        const boost::numeric::ublas::matrix< T2 , L2 , A2 > &m2 )
+    {
+        m1.resize( m2.size1() , m2.size2() );
+    }
+};
+
+
+
+// same size and resize specialization for matrix-vector resizing
+template< class T , class L , class A , class T_V , class A_V >
+struct same_size_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::vector< T_V , A_V > >
+{
+    static bool same_size( const boost::numeric::ublas::matrix< T , L , A > &m ,
+                           const boost::numeric::ublas::vector< T_V , A_V > &v )
+    {
+        return ( ( m.size1() == v.size() ) && ( m.size2() == v.size() ) );
+    }
+};
+
+template< class T , class L , class A , class T_V , class A_V >
+struct resize_impl< boost::numeric::ublas::matrix< T , L , A > , boost::numeric::ublas::vector< T_V , A_V > >
+{
+    static void resize( boost::numeric::ublas::matrix< T , L , A > &m ,
+                        const boost::numeric::ublas::vector< T_V , A_V > &v )
+    {
+        m.resize( v.size() , v.size() );
+    }
+};
+
+
+
+// specialization for ublas::permutation_matrix
+// same size and resize specialization for matrix-vector resizing
+template< class T , class A , class T_V , class A_V >
+struct same_size_impl< boost::numeric::ublas::permutation_matrix< T , A > ,
+                       boost::numeric::ublas::vector< T_V , A_V > >
+{
+    static bool same_size( const boost::numeric::ublas::permutation_matrix< T , A > &m ,
+                           const boost::numeric::ublas::vector< T_V , A_V > &v )
+    {
+        return ( m.size() == v.size() ); // && ( m.size2() == v.size() ) );
+    }
+};
+
+template< class T , class A , class T_V , class A_V >
+struct resize_impl< boost::numeric::ublas::vector< T_V , A_V > ,
+                    boost::numeric::ublas::permutation_matrix< T , A > >
+{
+    static void resize( const boost::numeric::ublas::vector< T_V , A_V > &v,
+                        boost::numeric::ublas::permutation_matrix< T , A > &m )
+    {
+        m.resize( v.size() , v.size() );
+    }
+};
+
+
+
+
+
+
+
+template< class T , class A >
+struct state_wrapper< boost::numeric::ublas::permutation_matrix< T , A > > // with resizing
+{
+    typedef boost::numeric::ublas::permutation_matrix< T , A > state_type;
+    typedef state_wrapper< state_type > state_wrapper_type;
+
+    state_type m_v;
+
+    state_wrapper() : m_v( 1 ) // permutation matrix constructor requires a size, choose 1 as default
+    { }
+
+};
+
+
+
+
+} } }
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/unit_helper.hpp b/include/boost/numeric/odeint/util/unit_helper.hpp
new file mode 100644
index 0000000..736b3e5
--- /dev/null
+++ b/include/boost/numeric/odeint/util/unit_helper.hpp
@@ -0,0 +1,151 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/util/unit_helper.hpp
+
+  [begin_description]
+  Get and set the value of a unit.
+  [end_description]
+
+  Copyright 2012-2013 Karsten Ahnert
+  Copyright 2012-2013 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_UNIT_HELPER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_UNIT_HELPER_HPP_INCLUDED
+
+
+#ifndef __CUDACC__
+#include <boost/units/quantity.hpp>
+#include <boost/units/get_dimension.hpp>
+#include <boost/units/get_system.hpp>
+#endif
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+namespace detail {
+
+    template<class T , class Enabler = void >
+    struct get_unit_value_impl
+    {
+        static T value(const T &t)
+        {
+            return t;
+        }
+        typedef T result_type;
+    };
+    
+#ifndef __CUDACC__
+    template<class Unit , class T>
+    struct get_unit_value_impl< boost::units::quantity< Unit , T> >
+    {
+        static T value( const boost::units::quantity< Unit , T> &t )
+        {
+            return t.value();
+        }
+        typedef T result_type;
+    };
+#endif
+
+
+
+
+
+    template<class T , class V , class Enabler = void >
+    struct set_unit_value_impl
+    {
+        static void set_value(T &t , const V &v)
+        {
+            t = v;
+        }
+    };
+
+#ifndef __CUDACC__
+    template<class Unit , class T , class V>
+    struct set_unit_value_impl<boost::units::quantity<Unit , T> , V>
+    {
+        static void set_value(boost::units::quantity<Unit , T> &t , const V &v)
+        {
+            t = boost::units::quantity<Unit , T>::from_value(v);
+        }
+    };
+#endif
+
+
+
+} // namespace detail
+
+
+    template<class T>
+    typename detail::get_unit_value_impl<T>::result_type get_unit_value(const T &t)
+    {
+        return detail::get_unit_value_impl<T>::value(t);
+    }
+
+
+    template<class T , class V>
+    void set_unit_value(T &t , const V &v)
+    {
+        return detail::set_unit_value_impl<T , V>::set_value(t , v);
+    }
+
+
+
+    template< class T >
+    struct unit_value_type
+    {
+        typedef T type;
+    };
+
+#ifndef __CUDACC__
+    template< class Unit , class Y >
+    struct unit_value_type< boost::units::quantity< Unit , Y > >
+    {
+        typedef Y type;
+    };
+#endif
+
+
+
+
+
+
+
+
+
+
+    template< typename Time >
+    struct inverse_time
+    {
+        typedef Time type;
+    };
+
+#ifndef __CUDACC__
+    template< typename Unit , typename Value >
+    struct inverse_time< boost::units::quantity< Unit , Value > >
+    {
+        typedef boost::units::quantity< Unit , Value > time_type;
+        typedef typename boost::units::get_dimension< time_type >::type dimension;
+        typedef typename boost::units::get_system< time_type >::type system;
+        typedef typename boost::mpl::divides< boost::units::dimensionless_type , dimension >::type inv_dimension;
+        typedef boost::units::unit< inv_dimension , system > inv_unit;
+        typedef boost::units::quantity< inv_unit , Value > type;
+    };
+#endif
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_UNIT_HELPER_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/util/unwrap_reference.hpp b/include/boost/numeric/odeint/util/unwrap_reference.hpp
new file mode 100644
index 0000000..e160878
--- /dev/null
+++ b/include/boost/numeric/odeint/util/unwrap_reference.hpp
@@ -0,0 +1,166 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/unwrap_reference.hpp
+
+ [begin_description]
+ unwrap_reference
+ [end_description]
+
+ Copyright 2012-2013 Karsten Ahnert
+ Copyright 2012-2013 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_UNWRAP_REFERENCE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_UNWRAP_REFERENCE_HPP_INCLUDED
+
+
+#include <boost/numeric/odeint/config.hpp>
+
+
+#if BOOST_NUMERIC_ODEINT_CXX11
+#include <functional>
+#else
+#include <boost/ref.hpp>
+#endif
+
+namespace boost {
+
+#if BOOST_NUMERIC_ODEINT_CXX11
+template<typename T> class reference_wrapper;
+
+template<typename T> struct unwrap_reference;
+#endif
+
+namespace numeric {
+namespace odeint {
+
+
+#if BOOST_NUMERIC_ODEINT_CXX11
+
+template<typename T>
+struct unwrap_reference
+{
+    typedef typename std::remove_reference<T>::type type;
+};
+
+template<typename T>
+struct unwrap_reference< std::reference_wrapper<T> >
+{
+    typedef typename std::remove_reference<T>::type type;
+};
+
+template<typename T>
+struct unwrap_reference< boost::reference_wrapper<T> >
+{
+    typedef typename boost::unwrap_reference<T>::type type;
+};
+
+#else
+
+using ::boost::unwrap_reference;
+
+#endif
+
+namespace detail
+{
+
+#if BOOST_NUMERIC_ODEINT_CXX11
+
+using ::std::ref;
+
+#else
+
+using ::boost::ref;
+
+#endif
+}
+
+}
+}
+}
+
+
+
+/*
+ * 
+ * the following is the suggested way, but unfortunately it does not work with all compilers.
+ */
+
+/*
+
+#include <boost/config.hpp>
+
+
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+#include <boost/ref.hpp>
+#else
+#include <functional>
+#endif
+
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+
+#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
+
+template<typename T>
+struct unwrap_reference
+{
+    typedef typename std::remove_reference<T>::type type;
+};
+
+template<typename T>
+struct unwrap_reference< std::reference_wrapper<T> >
+{
+    typedef typename std::remove_reference<T>::type type;
+};
+
+template<typename T>
+struct unwrap_reference< boost::reference_wrapper<T> >
+{
+    typedef typename boost::unwrap_reference<T>::type type;
+};
+
+#else
+
+using ::boost::unwrap_reference;
+
+#endif
+
+}
+}
+}
+
+namespace boost {
+namespace numeric {
+namespace odeint {  
+namespace detail {
+
+
+#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
+
+using ::std::ref;
+
+#else
+
+using ::boost::ref;
+
+#endif
+
+
+}
+}
+}
+}
+
+*/
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_UNWRAP_REFERENCE_HPP_INCLUDED
diff --git a/include/boost/numeric/odeint/version.hpp b/include/boost/numeric/odeint/version.hpp
new file mode 100644
index 0000000..379c906
--- /dev/null
+++ b/include/boost/numeric/odeint/version.hpp
@@ -0,0 +1,55 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/version.hpp
+
+ [begin_description]
+ Defines the current version of odeint.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_VERSION_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_VERSION_HPP_INCLUDED
+
+#include <string>
+#include <sstream>
+
+
+#define ODEINT_MAJOR_VERSION 2
+#define ODEINT_MINOR_VERSION 2
+#define ODEINT_PATCH_LEVEL 0
+#define ODEINT_VERSION ( ODEINT_MAJOR_VERSION * 100000 + ODEINT_MINOR_VERSION * 100 + ODEINT_PATCH_LEVEL )
+
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+namespace version {
+
+const int major = ODEINT_MAJOR_VERSION ;
+const int minor = ODEINT_MINOR_VERSION ;
+const int patch_level = ODEINT_PATCH_LEVEL ;
+
+}
+
+inline std::string get_version_string( void )
+{
+    std::ostringstream str;
+    str << "v" << version::major << "." << version::minor;
+    if( version::patch_level != 0 ) str << "_" << version::patch_level;
+    return str.str();
+}
+
+
+}
+}
+}
+
+#endif // BOOST_NUMERIC_ODEINT_VERSION_HPP_INCLUDED