boost.cxx 0.0.2 → 1.90.1

package/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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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 std::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

package/boost/numeric/odeint/stepper/detail/pid_step_adjuster.hpp

@@ -0,0 +1,199 @@
+/*
+ boost/numeric/odeint/stepper/detail/pid_step_adjuster.hpp
+
+ [begin_description]
+ Implementation of the stepsize controller for the controlled adams bashforth moulton stepper.
+ [end_description]
+
+ Copyright 2017 Valentin Noah Hartmann
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_PID_STEP_ADJUSTER_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_PID_STEP_ADJUSTER_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/detail/rotating_buffer.hpp>
+#include <boost/numeric/odeint/stepper/detail/pid_step_adjuster_coefficients.hpp>
+
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <math.h>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template<
+class Value = double,
+class Time = double
+>
+struct pid_op
+{
+public:
+    typedef Value value_type;
+    typedef Time time_type;
+
+    const double beta1;
+    const double beta2;
+    const double beta3;
+    const double alpha1;
+    const double alpha2;
+
+    const time_type dt1;
+    const time_type dt2;
+    const time_type dt3;
+
+    const size_t m_steps;
+
+    pid_op(const size_t steps, const double _dt1, const double _dt2, const double _dt3,
+        const double b1 = 1, const double b2 = 0, const double b3 = 0, const double a1 = 0, const double a2 = 0)
+    :beta1(b1), beta2(b2), beta3(b3), alpha1(a1), alpha2(a2),
+    dt1(_dt1), dt2(_dt2), dt3(_dt3),
+    m_steps(steps)
+    {};
+
+    template<class T1, class T2, class T3, class T4>
+    void operator()(T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
+    {
+        using std::abs;
+
+        t1 = adapted_pow(abs(t2), -beta1/(m_steps + 1)) *
+            adapted_pow(abs(t3), -beta2/(m_steps + 1)) *
+            adapted_pow(abs(t4), -beta3/(m_steps + 1)) *
+            adapted_pow(abs(dt1/dt2), -alpha1/(m_steps + 1))*
+            adapted_pow(abs(dt2/dt3), -alpha2/(m_steps + 1));
+
+        t1 = 1/t1;
+    };
+
+    template<class T1, class T2>
+    void operator()(T1 &t1, const T2 &t2)
+    {
+        using std::abs;
+
+        t1 = adapted_pow(abs(t2), -beta1/(m_steps + 1));
+
+        t1 = 1/t1;
+    };
+
+private:
+    template<class T>
+    inline value_type adapted_pow(T base, double exp)
+    {
+        if(exp == 0)
+        {
+            return 1;
+        }
+        else if (exp > 0)
+        {
+            return pow(base, exp);
+        }
+        else
+        {
+            return 1/pow(base, -exp);
+        }
+    };
+};
+
+template<
+class State,
+class Value = double,
+class Deriv = State,
+class Time = double,
+class Algebra = typename algebra_dispatcher< State >::algebra_type,
+class Operations = typename operations_dispatcher< Deriv >::operations_type,
+size_t Type = BASIC
+>
+struct pid_step_adjuster
+{
+public:
+    static double threshold() { return 0.9; };
+
+    typedef State state_type;
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef Time time_type;
+
+    typedef Algebra algebra_type;
+    typedef Operations operations_type;
+
+    typedef rotating_buffer<state_type, 3> error_storage_type;
+    typedef rotating_buffer<time_type, 3> time_storage_type;
+    typedef pid_step_adjuster_coefficients<Type> coeff_type;
+
+    pid_step_adjuster(double abs_tol = 1e-6, double rel_tol = 1e-6, time_type dtmax = 1.0)
+    :m_dtmax(dtmax), m_error_storage(), m_dt_storage(), m_init(0),
+    m_abs_tol(abs_tol), m_rel_tol(rel_tol)
+    {};
+
+    time_type adjust_stepsize(const size_t steps, time_type dt, state_type &err, const state_type &x, const deriv_type &dxdt)
+    {
+        using std::abs;
+        m_algebra.for_each3( err , x , dxdt ,
+                typename operations_type::template rel_error< value_type >( m_abs_tol , m_rel_tol , 1.0 , 1.0 * abs(get_unit_value( dt )) ) );
+
+        m_error_storage[0] = err;
+        m_dt_storage[0] = dt;
+
+        if(m_init >= 2)
+        {
+            m_algebra.for_each4(err, m_error_storage[0], m_error_storage[1], m_error_storage[2],
+                pid_op<>(steps, m_dt_storage[0], m_dt_storage[1], m_dt_storage[2],
+                    m_coeff[0], m_coeff[1], m_coeff[2], m_coeff[3], m_coeff[4]));
+        }
+        else
+        {
+            m_algebra.for_each2(err, m_error_storage[0],
+                pid_op<>(steps, m_dt_storage[0], m_dt_storage[1], m_dt_storage[2], 0.7));
+        }
+
+        value_type ratio = 1 / m_algebra.norm_inf(err);
+
+        value_type kappa = 1.0;
+        ratio = 1.0 + kappa*atan((ratio - 1) / kappa);
+
+        if(ratio*dt >= m_dtmax)
+        {
+            ratio = m_dtmax / dt;
+        }
+
+        if(ratio >= threshold())
+        {
+            m_error_storage.rotate();
+            m_dt_storage.rotate();
+
+            ++m_init;
+        }
+        else
+        {
+            m_init = 0;
+        }
+
+        return dt * static_cast<time_type>(ratio);
+    };
+
+private:
+    algebra_type m_algebra;
+
+    time_type m_dtmax;
+    error_storage_type m_error_storage;
+    time_storage_type m_dt_storage;
+
+    size_t m_init;
+    double m_abs_tol;
+    double m_rel_tol;
+
+    coeff_type m_coeff;
+};
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+#endif

package/boost/numeric/odeint/stepper/detail/pid_step_adjuster_coefficients.hpp

@@ -0,0 +1,180 @@
+/*
+ boost/numeric/odeint/stepper/detail/pid_step_adjuster_coefficients.hpp
+
+ [begin_description]
+ Coefficients for the PID stepsize controller.
+ [end_description]
+
+ Copyright 2017 Valentin Noah Hartmann
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_PID_STEP_ADJUSTER_COEFFICIENTS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_PID_STEP_ADJUSTER_COEFFICIENTS_HPP_INCLUDED
+
+#include <array>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+enum adjuster_type{
+    BASIC,
+    H0211,
+    H211b,
+    H211PI,
+    H0312,
+    H312b,
+    H312PID,
+    H0321,
+    H321
+};
+
+template<int Type>
+class pid_step_adjuster_coefficients;
+
+template<>
+class pid_step_adjuster_coefficients<BASIC> : public std::array<double, 5>
+{
+public:
+    pid_step_adjuster_coefficients()
+    : std::array<double, 5>()
+    {
+        (*this)[0] = 1.0;
+        (*this)[1] = 0.0;
+        (*this)[2] = 0.0;
+        (*this)[3] = 0.0;
+        (*this)[4] = 0.0;
+    }
+};
+
+template<>
+class pid_step_adjuster_coefficients<H0211> : public std::array<double, 5>
+{
+public:
+    pid_step_adjuster_coefficients()
+    : std::array<double, 5>()
+    {
+        (*this)[0] = 1.0 / 2.0;
+        (*this)[1] = 1.0 / 2.0;
+        (*this)[2] = 0.0;
+        (*this)[3] = 1.0 / 2.0;
+        (*this)[4] = 0.0;
+    }
+};
+
+template<>
+class pid_step_adjuster_coefficients<H211b> : public std::array<double, 5>
+{
+public:
+    pid_step_adjuster_coefficients()
+    : std::array<double, 5>()
+    {
+        (*this)[0] = 1.0 / 5.0;
+        (*this)[1] = 2.0 / 5.0;
+        (*this)[2] = 0.0;
+        (*this)[3] = 1.0 / 5.0;
+        (*this)[4] = 0.0;
+    }
+};
+
+template<>
+class pid_step_adjuster_coefficients<H211PI> : public std::array<double, 5>
+{
+public:
+    pid_step_adjuster_coefficients()
+    : std::array<double, 5>()
+    {
+        (*this)[0] = 1.0 / 6.0;
+        (*this)[1] = 2.0 / 6.0;
+        (*this)[2] = 0.0;
+        (*this)[3] = 0.0;
+        (*this)[4] = 0.0;
+    }
+};
+
+template<>
+class pid_step_adjuster_coefficients<H0312> : public std::array<double, 5>
+{
+public:
+    pid_step_adjuster_coefficients()
+    : std::array<double, 5>()
+    {
+        (*this)[0] = 1.0 / 4.0;
+        (*this)[1] = 2.0 / 2.0;
+        (*this)[2] = 1.0 / 4.0;
+        (*this)[3] = 3.0 / 4.0;
+        (*this)[4] = 1.0 / 4.0;
+    }
+};
+
+template<>
+class pid_step_adjuster_coefficients<H312b> : public std::array<double, 5>
+{
+public:
+    pid_step_adjuster_coefficients()
+    : std::array<double, 5>()
+    {
+        (*this)[0] = 1.0 / 6.0;
+        (*this)[1] = 2.0 / 6.0;
+        (*this)[2] = 1.0 / 6.0;
+        (*this)[3] = 3.0 / 6.0;
+        (*this)[4] = 1.0 / 6.0;
+    }
+};
+
+template<>
+class pid_step_adjuster_coefficients<H312PID> : public std::array<double, 5>
+{
+public:
+    pid_step_adjuster_coefficients()
+    : std::array<double, 5>()
+    {
+        (*this)[0] = 1.0 / 18.0;
+        (*this)[1] = 2.0 / 9.0;
+        (*this)[2] = 1.0 / 18.0;
+        (*this)[3] = 0.0;
+        (*this)[4] = 0.0;
+    }
+};
+
+template<>
+class pid_step_adjuster_coefficients<H0321> : public std::array<double, 5>
+{
+public:
+    pid_step_adjuster_coefficients()
+    : std::array<double, 5>()
+    {
+        (*this)[0] =  5.0 / 4.0;
+        (*this)[1] =  1.0 / 2.0;
+        (*this)[2] = -3.0 / 4.0;
+        (*this)[3] = -1.0 / 4.0;
+        (*this)[4] = -3.0 / 4.0;
+    }
+};
+
+template<>
+class pid_step_adjuster_coefficients<H321> : public std::array<double, 5>
+{
+public:
+    pid_step_adjuster_coefficients()
+    : std::array<double, 5>()
+    {
+        (*this)[0] =  1.0 / 3.0;
+        (*this)[1] =  1.0 / 18.0;
+        (*this)[2] = -5.0 / 18.0;
+        (*this)[3] = -5.0 / 16.0;
+        (*this)[4] = -1.0 / 6.0;
+    }
+};
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+#endif

package/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 <array>
+
+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