boost.cxx 0.0.2 → 1.90.1

package/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 <array>
+
+
+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 std::array< Value , 1 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : std::array< Value , 1 >()
+      {
+        (*this)[0] = static_cast< Value >( 1 );
+      }
+};
+
+
+template< class Value >
+class adams_bashforth_coefficients< Value , 2 > : public std::array< Value , 2 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : std::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 std::array< Value , 3 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : std::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 std::array< Value , 4 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : std::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 std::array< Value , 5 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : std::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 std::array< Value , 6 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : std::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 std::array< Value , 7 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : std::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 std::array< Value , 8 >
+{
+public:
+    adams_bashforth_coefficients( void )
+    : std::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

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

package/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 <array>
+
+
+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 std::array< Value , 1 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : std::array< Value , 1 >()
+      {
+        (*this)[0] = static_cast< Value >( 1 );
+      }
+};
+
+
+template< class Value >
+class adams_moulton_coefficients< Value , 2 > : public std::array< Value , 2 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : std::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 std::array< Value , 3 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : std::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 std::array< Value , 4 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : std::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 std::array< Value , 5 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : std::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 std::array< Value , 6 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : std::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 std::array< Value , 7 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : std::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 std::array< Value , 8 >
+{
+public:
+    adams_moulton_coefficients( void )
+    : std::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

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

@@ -0,0 +1,207 @@
+/*
+ boost/numeric/odeint/stepper/detail/adaptive_adams_coefficients.hpp
+
+ [begin_description]
+ Calculation of the coefficients for the adaptive adams 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_ADAPTIVE_ADAMS_COEFFICIENTS_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_STEPPER_DETAIL_ADAPTIVE_ADAMS_COEFFICIENTS_HPP_INCLUDED
+
+#include <boost/numeric/odeint/stepper/detail/rotating_buffer.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/unwrap_reference.hpp>
+#include <boost/numeric/odeint/util/bind.hpp>
+
+#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
+#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
+
+#include <array>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+template<
+size_t Steps,
+class Deriv,
+class Value = double,
+class Time = double,
+class Algebra = typename algebra_dispatcher< Deriv >::algebra_type,
+class Operations = typename operations_dispatcher< Deriv >::operations_type,
+class Resizer = initially_resizer
+>
+class adaptive_adams_coefficients
+{
+public:
+    static const size_t steps = Steps;
+
+    typedef unsigned short order_type;
+    static const order_type order_value = steps;
+
+    typedef Value value_type;
+    typedef Deriv deriv_type;
+    typedef Time time_type;
+
+    typedef state_wrapper< deriv_type > wrapped_deriv_type;
+    typedef rotating_buffer< time_type , steps+1 > time_storage_type;
+
+    typedef Algebra algebra_type;
+    typedef Operations operations_type;
+    typedef Resizer resizer_type;
+
+    typedef adaptive_adams_coefficients< Steps , Deriv , Value , Time , Algebra , Operations , Resizer > aac_type;
+
+    adaptive_adams_coefficients( const algebra_type &algebra = algebra_type())
+    :m_eo(1), m_steps_init(1), beta(), phi(), m_ns(0), m_time_storage(),
+    m_algebra(algebra),
+    m_phi_resizer()
+    {
+        for (size_t i=0; i<order_value+2; ++i)
+        {
+            c[i] = 1.0/(i+1);
+            c[c_size+i] = 1.0/((i+1)*(i+2));
+        }
+
+        g[0] = c[0];
+        g[1] = c[c_size];
+
+        beta[0][0] = 1;
+        beta[1][0] = 1;
+
+        gs[0] = 1.0;
+        gs[1] = -1.0/2;
+        gs[2] = -1.0/12;
+        gs[3] = -1.0/24;
+        gs[4] = -19.0/720;
+        gs[5] = -3.0/160;
+        gs[6] = -863.0/60480;
+        gs[7] = -275.0/24192;
+        gs[8] = -33953.0/3628800;
+        gs[9] = 35.0/4436;
+        gs[10] =  40.0/5891;
+        gs[11] = 37.0/6250;
+        gs[12] = 25.0/4771;
+        gs[13] = 40.0/8547;
+    };
+
+    void predict(time_type t, time_type dt)
+    {
+        using std::abs;
+
+        m_time_storage[0] = t;
+
+        if (abs(m_time_storage[0] - m_time_storage[1] - dt) > 1e-16 || m_eo >= m_ns)
+        {
+            m_ns = 0;
+        }
+        else if (m_ns < order_value + 2)
+        {
+            m_ns++;
+        }
+
+        for(size_t i=1+m_ns; i<m_eo+1 && i<m_steps_init; ++i)
+        {
+            time_type diff = m_time_storage[0] - m_time_storage[i];
+            beta[0][i] = beta[0][i-1]*(m_time_storage[0] + dt - m_time_storage[i-1])/diff;
+        }
+
+        for(size_t i=2+m_ns; i<m_eo+2 && i<m_steps_init+1; ++i)
+        {
+            time_type diff = m_time_storage[0] + dt - m_time_storage[i-1];
+            for(size_t j=0; j<m_eo+1-i+1; ++j)
+            {
+                c[c_size*i+j] = c[c_size*(i-1)+j] - c[c_size*(i-1)+j+1]*dt/diff;
+            }
+
+            g[i] = c[c_size*i];
+        }
+    };
+
+    void do_step(const deriv_type &dxdt, const int o = 0)
+    {
+        m_phi_resizer.adjust_size(dxdt, [this](auto&& arg) { return this->resize_phi_impl<deriv_type>(std::forward<decltype(arg)>(arg)); });
+
+        phi[o][0].m_v = dxdt;
+
+        for(size_t i=1; i<m_eo+3 && i<m_steps_init+2 && i<order_value+2; ++i)
+        {
+            if (o == 0)
+            {
+                this->m_algebra.for_each3(phi[o][i].m_v, phi[o][i-1].m_v, phi[o+1][i-1].m_v,
+                    typename Operations::template scale_sum2<value_type, value_type>(1.0, -beta[o][i-1]));
+            }
+            else
+            {
+                this->m_algebra.for_each2(phi[o][i].m_v, phi[o][i-1].m_v,
+                    typename Operations::template scale_sum1<value_type>(1.0));
+            }
+        }
+    };
+
+    void confirm()
+    {
+        beta.rotate();
+        phi.rotate();
+        m_time_storage.rotate();
+
+        if(m_steps_init < order_value+1)
+        {
+            ++m_steps_init;
+        }
+    };
+
+    void reset() { m_eo = 1; m_steps_init = 1; };
+
+    size_t m_eo;
+    size_t m_steps_init;
+
+    rotating_buffer<std::array<value_type, order_value+1>, 2> beta; // beta[0] = beta(n)
+    rotating_buffer<std::array<wrapped_deriv_type, order_value+2>, 3> phi; // phi[0] = phi(n+1)
+    std::array<value_type, order_value + 2> g;
+    std::array<value_type, 14> gs;
+
+private:
+    template< class StateType >
+    bool resize_phi_impl( const StateType &x )
+    {
+        bool resized( false );
+
+        for(size_t i=0; i<(order_value + 2); ++i)
+        {
+            resized |= adjust_size_by_resizeability( phi[0][i], x, typename is_resizeable<deriv_type>::type() );
+            resized |= adjust_size_by_resizeability( phi[1][i], x, typename is_resizeable<deriv_type>::type() );
+            resized |= adjust_size_by_resizeability( phi[2][i], x, typename is_resizeable<deriv_type>::type() );
+        }
+        return resized;
+    };
+
+    size_t m_ns;
+
+    time_storage_type m_time_storage;
+    static const size_t c_size = order_value + 2;
+    std::array<value_type, c_size*c_size> c;
+
+    algebra_type m_algebra;
+
+    resizer_type m_phi_resizer;
+};
+
+} // detail
+} // odeint
+} // numeric
+} // boost
+
+#endif