comparison DEPENDENCIES/generic/include/boost/numeric/odeint/stepper/adams_moulton.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

  [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 2009-2011 Karsten Ahnert
- Copyright 2009-2011 Mario Mulansky
+ 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)
  */

 
 #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/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 {

 size_t Steps ,
 class State ,
 class Value = double ,
 class Deriv = State ,
 class Time = Value ,
-class Algebra = range_algebra ,
-class Operations = default_operations ,
+class Algebra = typename algebra_dispatcher< State >::algebra_type ,
+class Operations = typename operations_dispatcher< State >::operations_type ,
 class Resizer = initially_resizer
 >
 class adams_moulton
 {
 private:

     /*
      * Version 1 : do_step( system , x , t , dt , buf );
      *
      * solves the forwarding problem
      */
-    template< class System , class StateInOut , class ABBuf >
-    void do_step( System system , StateInOut &in , time_type t , time_type dt , const ABBuf &buf )
-    {
-        do_step( system , in , t , in , dt , buf );
-    }
-
-    template< class System , class StateInOut , class ABBuf >
-    void do_step( System system , const StateInOut &in , time_type t , time_type dt , const ABBuf &buf )
-    {
-        do_step( system , in , t , in , dt , buf );
+    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 StateOut , class ABBuf >
-    void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , const ABBuf &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 , 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( in , m_dxdt.m_v , t );
+        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 System , class StateIn , class StateOut , class ABBuf >
-    void do_step( System system , const StateIn &in , time_type t , const 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( in , 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 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 StateIn >
     bool resize_impl( const StateIn &x )
     {
         return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );