• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  [auto_generated]
3  boost/numeric/odeint/stepper/adams_moulton.hpp
4 
5  [begin_description]
6  Implementation of the Adams-Moulton method. This is method is not a real stepper, it is more a helper class
7  which computes the corrector step in the Adams-Bashforth-Moulton method.
8  [end_description]
9 
10  Copyright 2011-2012 Karsten Ahnert
11  Copyright 2011-2013 Mario Mulansky
12  Copyright 2012 Christoph Koke
13 
14  Distributed under the Boost Software License, Version 1.0.
15  (See accompanying file LICENSE_1_0.txt or
16  copy at http://www.boost.org/LICENSE_1_0.txt)
17  */
18 
19 
20 #ifndef BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_MOULTON_HPP_INCLUDED
21 #define BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_MOULTON_HPP_INCLUDED
22 
23 
24 #include <boost/numeric/odeint/util/bind.hpp>
25 
26 #include <boost/numeric/odeint/algebra/range_algebra.hpp>
27 #include <boost/numeric/odeint/algebra/default_operations.hpp>
28 #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
29 #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
30 
31 #include <boost/numeric/odeint/util/state_wrapper.hpp>
32 #include <boost/numeric/odeint/util/is_resizeable.hpp>
33 #include <boost/numeric/odeint/util/resizer.hpp>
34 
35 #include <boost/numeric/odeint/stepper/stepper_categories.hpp>
36 #include <boost/numeric/odeint/stepper/runge_kutta4_classic.hpp>
37 
38 #include <boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp>
39 #include <boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp>
40 #include <boost/numeric/odeint/stepper/detail/rotating_buffer.hpp>
41 
42 
43 
44 
45 namespace boost {
46 namespace numeric {
47 namespace odeint {
48 
49 
50 /*
51  * Static implicit Adams-Moulton multistep-solver without step size control and without dense output.
52  */
53 template<
54 size_t Steps ,
55 class State ,
56 class Value = double ,
57 class Deriv = State ,
58 class Time = Value ,
59 class Algebra = typename algebra_dispatcher< State >::algebra_type ,
60 class Operations = typename operations_dispatcher< State >::operations_type ,
61 class Resizer = initially_resizer
62 >
63 class adams_moulton
64 {
65 private:
66 
67 
68 public :
69 
70     typedef State state_type;
71     typedef state_wrapper< state_type > wrapped_state_type;
72     typedef Value value_type;
73     typedef Deriv deriv_type;
74     typedef state_wrapper< deriv_type > wrapped_deriv_type;
75     typedef Time time_type;
76     typedef Algebra algebra_type;
77     typedef Operations operations_type;
78     typedef Resizer resizer_type;
79     typedef stepper_tag stepper_category;
80 
81     typedef adams_moulton< Steps , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_type;
82 
83     static const size_t steps = Steps;
84 
85     typedef unsigned short order_type;
86     static const order_type order_value = steps + 1;
87 
88     typedef detail::rotating_buffer< wrapped_deriv_type , steps > step_storage_type;
89 
adams_moulton()90     adams_moulton( )
91     : m_coefficients() , m_dxdt() , m_resizer() ,
92       m_algebra_instance() , m_algebra( m_algebra_instance )
93     { }
94 
adams_moulton(algebra_type & algebra)95     adams_moulton( algebra_type &algebra )
96     : m_coefficients() , m_dxdt() , m_resizer() ,
97       m_algebra_instance() , m_algebra( algebra )
98     { }
99 
operator =(const adams_moulton & stepper)100     adams_moulton& operator=( const adams_moulton &stepper )
101     {
102         m_dxdt = stepper.m_dxdt;
103         m_resizer = stepper.m_resizer;
104         m_algebra = stepper.m_algebra;
105         return *this;
106     }
107 
order(void) const108     order_type order( void ) const { return order_value; }
109 
110 
111     /*
112      * Version 1 : do_step( system , x , t , dt , buf );
113      *
114      * solves the forwarding problem
115      */
116     template< class System , class StateInOut , class StateIn , class ABBuf >
do_step(System system,StateInOut & x,StateIn const & pred,time_type t,time_type dt,const ABBuf & buf)117     void do_step( System system , StateInOut &x , StateIn const & pred , time_type t , time_type dt , const ABBuf &buf )
118     {
119         do_step( system , x , pred , t , x , dt , buf );
120     }
121 
122     template< class System , class StateInOut , class StateIn , class ABBuf >
do_step(System system,const StateInOut & x,StateIn const & pred,time_type t,time_type dt,const ABBuf & buf)123     void do_step( System system , const StateInOut &x , StateIn const & pred , time_type t , time_type dt , const ABBuf &buf )
124     {
125         do_step( system , x , pred , t , x , dt , buf );
126     }
127 
128 
129 
130     /*
131      * Version 2 : do_step( system , in , t , out , dt , buf );
132      *
133      * solves the forwarding problem
134      */
135     template< class System , class StateIn , class PredIn , class StateOut , class ABBuf >
do_step(System system,const StateIn & in,const PredIn & pred,time_type t,StateOut & out,time_type dt,const ABBuf & buf)136     void do_step( System system , const StateIn &in , const PredIn &pred , time_type t , StateOut &out , time_type dt , const ABBuf &buf )
137     {
138         do_step_impl( system , in , pred , t , out , dt , buf );
139     }
140 
141     template< class System , class StateIn , class PredIn , class StateOut , class ABBuf >
do_step(System system,const StateIn & in,const PredIn & pred,time_type t,const StateOut & out,time_type dt,const ABBuf & buf)142     void do_step( System system , const StateIn &in , const PredIn &pred , time_type t , const StateOut &out , time_type dt , const ABBuf &buf )
143     {
144         do_step_impl( system , in , pred , t , out , dt , buf );
145     }
146 
147 
148 
149     template< class StateType >
adjust_size(const StateType & x)150     void adjust_size( const StateType &x )
151     {
152         resize_impl( x );
153     }
154 
algebra()155     algebra_type& algebra()
156     {   return m_algebra; }
157 
algebra() const158     const algebra_type& algebra() const
159     {   return m_algebra; }
160 
161 
162 private:
163 
164 
165     template< class System , class StateIn , class PredIn , class StateOut , class ABBuf >
do_step_impl(System system,const StateIn & in,const PredIn & pred,time_type t,StateOut & out,time_type dt,const ABBuf & buf)166     void do_step_impl( System system , const StateIn &in , const PredIn &pred , time_type t , StateOut &out , time_type dt , const ABBuf &buf )
167     {
168         typename odeint::unwrap_reference< System >::type &sys = system;
169         m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
170         sys( pred , m_dxdt.m_v , t );
171         detail::adams_moulton_call_algebra< steps , algebra_type , operations_type >()( m_algebra , in , out , m_dxdt.m_v , buf , m_coefficients , dt );
172     }
173 
174 
175     template< class StateIn >
resize_impl(const StateIn & x)176     bool resize_impl( const StateIn &x )
177     {
178         return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
179     }
180 
181 
182     const detail::adams_moulton_coefficients< value_type , steps > m_coefficients;
183     wrapped_deriv_type m_dxdt;
184     resizer_type m_resizer;
185 
186 protected:
187 
188     algebra_type m_algebra_instance;
189     algebra_type &m_algebra;
190 };
191 
192 
193 
194 
195 } // odeint
196 } // numeric
197 } // boost
198 
199 
200 
201 #endif // BOOST_NUMERIC_ODEINT_STEPPER_ADAMS_MOULTON_HPP_INCLUDED
202