]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /* |
2 | [auto_generated] | |
3 | libs/numeric/odeint/test/integrate_stepper_refs.cpp | |
4 | ||
5 | [begin_description] | |
6 | Tests the integrate functions with boost::ref( stepper) | |
7 | [end_description] | |
8 | ||
9 | Copyright 2009-2013 Karsten Ahnert | |
10 | Copyright 2009-2013 Mario Mulansky | |
11 | ||
12 | Distributed under the Boost Software License, Version 1.0. | |
13 | (See accompanying file LICENSE_1_0.txt or | |
14 | copy at http://www.boost.org/LICENSE_1_0.txt) | |
15 | */ | |
16 | ||
17 | ||
18 | #define BOOST_TEST_MODULE odeint_integrate_stepper_refs | |
19 | ||
20 | #include <vector> | |
21 | #include <cmath> | |
22 | #include <iostream> | |
23 | ||
24 | #include <boost/numeric/odeint/config.hpp> | |
25 | ||
26 | #include <boost/noncopyable.hpp> | |
27 | #include <boost/test/unit_test.hpp> | |
28 | #include <boost/iterator/counting_iterator.hpp> | |
29 | ||
30 | #include <boost/mpl/vector.hpp> | |
31 | ||
32 | #include <boost/numeric/odeint/integrate/integrate_const.hpp> | |
33 | #include <boost/numeric/odeint/integrate/integrate_adaptive.hpp> | |
34 | #include <boost/numeric/odeint/integrate/integrate_times.hpp> | |
35 | #include <boost/numeric/odeint/integrate/integrate_n_steps.hpp> | |
36 | #include <boost/numeric/odeint/stepper/controlled_step_result.hpp> | |
37 | ||
38 | ||
39 | using namespace boost::unit_test; | |
40 | using namespace boost::numeric::odeint; | |
41 | namespace mpl = boost::mpl; | |
42 | ||
43 | typedef double value_type; | |
44 | typedef std::vector< value_type > state_type; | |
45 | ||
46 | // minimal non-copyable basic stepper | |
47 | template< | |
48 | class State | |
49 | > | |
50 | class simple_stepper_nc : boost::noncopyable | |
51 | { | |
52 | public : | |
53 | typedef State state_type; | |
54 | typedef double value_type; | |
55 | typedef state_type deriv_type; | |
56 | typedef double time_type; | |
57 | typedef size_t order_type; | |
58 | typedef stepper_tag stepper_category; | |
59 | ||
60 | template< class System > | |
61 | void do_step( System system , state_type &in , time_type t , time_type dt ) | |
62 | { | |
63 | // empty | |
64 | ||
65 | } | |
66 | }; | |
67 | ||
68 | // minimal non-copyable controlled stepper | |
69 | template< | |
70 | class State | |
71 | > | |
72 | class controlled_stepper_nc : boost::noncopyable | |
73 | { | |
74 | public : | |
75 | typedef State state_type; | |
76 | typedef double value_type; | |
77 | typedef state_type deriv_type; | |
78 | typedef double time_type; | |
79 | typedef size_t order_type; | |
80 | typedef controlled_stepper_tag stepper_category; | |
81 | ||
82 | template< class System > | |
83 | controlled_step_result try_step( System system , state_type &in , time_type &t , time_type &dt ) | |
84 | { | |
85 | std::cout << "dense out stepper: " << t << " , " << dt << std::endl; | |
86 | t += dt; | |
87 | return success; | |
88 | } | |
89 | }; | |
90 | ||
91 | // minimal non-copyable dense_output stepper | |
92 | template< | |
93 | class State | |
94 | > | |
95 | class dense_out_stepper_nc : boost::noncopyable | |
96 | { | |
97 | public : | |
98 | typedef State state_type; | |
99 | typedef double value_type; | |
100 | typedef state_type deriv_type; | |
101 | typedef double time_type; | |
102 | typedef size_t order_type; | |
103 | typedef dense_output_stepper_tag stepper_category; | |
104 | ||
105 | void initialize( const state_type &x0 , const time_type t0 , const time_type dt0 ) | |
106 | { | |
107 | m_x = x0; | |
108 | m_t = t0; | |
109 | m_dt = dt0; | |
110 | std::cout << "initialize: " << m_t << " , " << m_dt << std::endl; | |
111 | } | |
112 | ||
113 | template< class System > | |
114 | void do_step( System system ) | |
115 | { | |
116 | std::cout << "dense out stepper: " << m_t << " , " << m_dt << std::endl; | |
117 | m_t += m_dt; | |
118 | } | |
119 | ||
120 | void calc_state( const time_type t_inter , state_type &x ) | |
121 | { | |
122 | x = m_x; | |
123 | } | |
124 | ||
125 | const state_type& current_state() const | |
126 | { return m_x; } | |
127 | ||
128 | time_type current_time() const | |
129 | { return m_t; } | |
130 | ||
131 | time_type current_time_step() const | |
132 | { return m_dt; } | |
133 | ||
134 | ||
135 | private : | |
136 | time_type m_t; | |
137 | time_type m_dt; | |
138 | state_type m_x; | |
139 | }; | |
140 | ||
141 | ||
142 | void lorenz( const state_type &x , state_type &dxdt , const value_type t ) | |
143 | { | |
144 | //const value_type sigma( 10.0 ); | |
145 | const value_type R( 28.0 ); | |
146 | const value_type b( value_type( 8.0 ) / value_type( 3.0 ) ); | |
147 | ||
148 | // first component trivial | |
149 | dxdt[0] = 1.0; //sigma * ( x[1] - x[0] ); | |
150 | dxdt[1] = R * x[0] - x[1] - x[0] * x[2]; | |
151 | dxdt[2] = -b * x[2] + x[0] * x[1]; | |
152 | } | |
153 | ||
154 | struct push_back_time | |
155 | { | |
156 | std::vector< double >& m_times; | |
157 | ||
158 | state_type& m_x; | |
159 | ||
160 | push_back_time( std::vector< double > × , state_type &x ) | |
161 | : m_times( times ) , m_x( x ) { } | |
162 | ||
163 | void operator()( const state_type &x , double t ) | |
164 | { | |
165 | m_times.push_back( t ); | |
166 | boost::numeric::odeint::copy( x , m_x ); | |
167 | } | |
168 | }; | |
169 | ||
170 | template< class Stepper > | |
171 | struct perform_integrate_const_test | |
172 | { | |
173 | void operator()() | |
174 | { | |
175 | state_type x( 3 , 10.0 ) , x_end( 3 ); | |
176 | ||
177 | std::vector< value_type > times; | |
178 | ||
179 | Stepper stepper; | |
180 | ||
181 | integrate_const( boost::ref(stepper) , lorenz , x , 0.0 , 1.0 , | |
182 | 0.1, push_back_time( times , x_end ) ); | |
183 | } | |
184 | }; | |
185 | ||
186 | template< class Stepper > | |
187 | struct perform_integrate_adaptive_test | |
188 | { | |
189 | void operator()() | |
190 | { | |
191 | state_type x( 3 , 10.0 ) , x_end( 3 ); | |
192 | ||
193 | std::vector< value_type > times; | |
194 | ||
195 | Stepper stepper; | |
196 | ||
197 | integrate_adaptive( boost::ref(stepper) , lorenz , x , 0.0 , 1.0 , | |
198 | 0.1, push_back_time( times , x_end ) ); | |
199 | } | |
200 | }; | |
201 | ||
202 | template< class Stepper > | |
203 | struct perform_integrate_n_steps_test | |
204 | { | |
205 | void operator()() | |
206 | { | |
207 | state_type x( 3 , 10.0 ) , x_end( 3 ); | |
208 | ||
209 | std::vector< value_type > times; | |
210 | ||
211 | Stepper stepper; | |
212 | ||
213 | integrate_n_steps( boost::ref(stepper) , lorenz , x , 0.0 , 0.1 , | |
214 | 10 , push_back_time( times , x_end ) ); | |
215 | } | |
216 | }; | |
217 | ||
218 | template< class Stepper > | |
219 | struct perform_integrate_times_test | |
220 | { | |
221 | void operator()() | |
222 | { | |
223 | state_type x( 3 , 10.0 ) , x_end( 3 ); | |
224 | ||
225 | std::vector< value_type > times; | |
226 | ||
227 | Stepper stepper; | |
228 | ||
229 | integrate_times( boost::ref(stepper) , lorenz , x , | |
230 | boost::counting_iterator<int>(0) , boost::counting_iterator<int>(10) , 0.1 , | |
231 | push_back_time( times , x_end ) ); | |
232 | } | |
233 | }; | |
234 | ||
235 | class stepper_methods : public mpl::vector< | |
236 | simple_stepper_nc< state_type > , | |
237 | controlled_stepper_nc< state_type >, | |
238 | dense_out_stepper_nc< state_type > > { }; | |
239 | ||
240 | BOOST_AUTO_TEST_SUITE( integrate_stepper_refs ) | |
241 | ||
242 | BOOST_AUTO_TEST_CASE_TEMPLATE( integrate_const_test_case , Stepper, stepper_methods ) | |
243 | { | |
244 | std::cout << "integrate const" << std::endl; | |
245 | perform_integrate_const_test< Stepper > tester; | |
246 | tester(); | |
247 | } | |
248 | ||
249 | ||
250 | BOOST_AUTO_TEST_CASE_TEMPLATE( integrate_adaptive_test_case , Stepper, stepper_methods ) | |
251 | { | |
252 | std::cout << "integrate adaptive" << std::endl; | |
253 | perform_integrate_adaptive_test< Stepper > tester; | |
254 | tester(); | |
255 | } | |
256 | ||
257 | BOOST_AUTO_TEST_CASE_TEMPLATE( integrate_n_steps_test_case , Stepper, stepper_methods ) | |
258 | { | |
259 | std::cout << "integrate n steps" << std::endl; | |
260 | perform_integrate_n_steps_test< Stepper > tester; | |
261 | tester(); | |
262 | } | |
263 | ||
264 | BOOST_AUTO_TEST_CASE_TEMPLATE( integrate_times_test_case , Stepper, stepper_methods ) | |
265 | { | |
266 | std::cout << "integrate times" << std::endl; | |
267 | perform_integrate_times_test< Stepper > tester; | |
268 | tester(); | |
269 | } | |
270 | ||
271 | BOOST_AUTO_TEST_SUITE_END() |