1 | #ifndef LIB_MODELS_ODE_BOOST_TUPLE_HPP_
|
---|
2 | #define LIB_MODELS_ODE_BOOST_TUPLE_HPP_
|
---|
3 |
|
---|
4 | //Author : pierre blavy
|
---|
5 |
|
---|
6 |
|
---|
7 |
|
---|
8 |
|
---|
9 | #include <tuple>
|
---|
10 | #include <type_traits>
|
---|
11 |
|
---|
12 |
|
---|
13 |
|
---|
14 |
|
---|
15 | namespace boost {
|
---|
16 | namespace numeric {
|
---|
17 | namespace odeint {
|
---|
18 |
|
---|
19 | //user may specialize (entry point to make boost units works)
|
---|
20 | template<typename T>
|
---|
21 | struct std_tuple_algebra_to_double_t{
|
---|
22 | static double run(const T&t){return static_cast<double>(t);}
|
---|
23 | };
|
---|
24 |
|
---|
25 |
|
---|
26 |
|
---|
27 |
|
---|
28 | template<typename T> double std_tuple_algebra_to_double(const T&t) {return std_tuple_algebra_to_double_t<T>::run(t);}
|
---|
29 | inline const double& std_tuple_algebra_to_double(const double&t){return t;}
|
---|
30 |
|
---|
31 |
|
---|
32 | namespace std_tuple_algebra_impl{
|
---|
33 |
|
---|
34 |
|
---|
35 | struct Observer_nothing{
|
---|
36 | template<typename T, typename U>
|
---|
37 | void operator()(const T&t, const U&){}
|
---|
38 | };
|
---|
39 |
|
---|
40 |
|
---|
41 | //--- norm inf ---
|
---|
42 | template<size_t Index>
|
---|
43 | struct norm_inf_t{
|
---|
44 | template<typename T>
|
---|
45 | static void run_r(const T&t, double& write_here){
|
---|
46 | norm_inf_t<Index-1>::run_r(t,write_here);
|
---|
47 | double d = std_tuple_algebra_to_double(std::get<Index-1>(t));
|
---|
48 | if(d<0){d= -d;}
|
---|
49 | if(d>write_here){write_here=d;}
|
---|
50 | }
|
---|
51 | };
|
---|
52 |
|
---|
53 | template <>
|
---|
54 | struct norm_inf_t<0>{
|
---|
55 | template<typename... stuff>
|
---|
56 | static void run_r(stuff...){}
|
---|
57 | };
|
---|
58 |
|
---|
59 |
|
---|
60 |
|
---|
61 |
|
---|
62 |
|
---|
63 | //--- 1 ---
|
---|
64 | template <size_t Index>
|
---|
65 | struct apply1_t{
|
---|
66 | template<typename Op, typename T1>
|
---|
67 | static void run_r(Op op, T1 &t1){
|
---|
68 | apply1_t<Index-1>::run_r(std::forward<Op>(op),(t1));
|
---|
69 | op(std::get<Index-1>(t1));
|
---|
70 | }
|
---|
71 | };
|
---|
72 |
|
---|
73 | template <>
|
---|
74 | struct apply1_t<0>{
|
---|
75 | template<typename Op, typename... stuff>
|
---|
76 | static void run_r(Op op, stuff...){}
|
---|
77 | };
|
---|
78 |
|
---|
79 | //--- 2 ---
|
---|
80 | template <size_t Index>
|
---|
81 | struct apply2_t{
|
---|
82 | template<typename Op, typename T1, typename T2>
|
---|
83 | static void run_r(Op op, T1 &t1, T2 &t2){
|
---|
84 | apply2_t<Index-1>::run_r(std::forward<Op>(op),(t1),(t2));
|
---|
85 | op(std::get<Index-1>(t1), std::get<Index-1>(t2));
|
---|
86 | }
|
---|
87 | };
|
---|
88 |
|
---|
89 | template <>
|
---|
90 | struct apply2_t<0>{
|
---|
91 | template<typename Op, typename... stuff>
|
---|
92 | static void run_r(Op op, stuff...){}
|
---|
93 | };
|
---|
94 |
|
---|
95 |
|
---|
96 |
|
---|
97 |
|
---|
98 | //--- 3 ---
|
---|
99 | template <size_t Index>
|
---|
100 | struct apply3_t{
|
---|
101 | template<typename Op, typename T1, typename T2, typename T3>
|
---|
102 | static void run_r(Op op, T1 &t1, T2 &t2, T3 &t3){
|
---|
103 | apply3_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
104 | (t1),
|
---|
105 | (t2),
|
---|
106 | (t3)
|
---|
107 | );
|
---|
108 | op(std::get<Index-1>(t1), std::get<Index-1>(t2), std::get<Index-1>(t3));
|
---|
109 | }
|
---|
110 | };
|
---|
111 |
|
---|
112 | template <>
|
---|
113 | struct apply3_t<0>{
|
---|
114 | template<typename Op, typename... stuff>
|
---|
115 | static void run_r(Op op, stuff...){}
|
---|
116 | };
|
---|
117 |
|
---|
118 |
|
---|
119 | //--- 4 ---
|
---|
120 | template <size_t Index>
|
---|
121 | struct apply4_t{
|
---|
122 | template<typename Op,
|
---|
123 | typename T1, typename T2, typename T3, typename T4
|
---|
124 | >
|
---|
125 | static void run_r(Op op,
|
---|
126 | T1 &t1, T2 &t2, T3 &t3,T4 &t4){
|
---|
127 | apply4_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
128 | (t1),
|
---|
129 | (t2),
|
---|
130 | (t3),
|
---|
131 | (t4));
|
---|
132 | op(std::get<Index-1>(t1), std::get<Index-1>(t2), std::get<Index-1>(t3),std::get<Index-1>(t4)
|
---|
133 | );
|
---|
134 | }
|
---|
135 | };
|
---|
136 |
|
---|
137 | template <>
|
---|
138 | struct apply4_t<0>{
|
---|
139 | template<typename Op, typename... stuff>
|
---|
140 | static void run_r(Op op, stuff...){}
|
---|
141 | };
|
---|
142 |
|
---|
143 | //--- 5 ---
|
---|
144 | template <size_t Index>
|
---|
145 | struct apply5_t{
|
---|
146 | template<typename Op,
|
---|
147 | typename T1, typename T2, typename T3, typename T4, typename T5
|
---|
148 | >
|
---|
149 | static void run_r(Op op,
|
---|
150 | T1 &t1, T2 &t2, T3 &t3,T4 &t4, T5 &t5){
|
---|
151 | apply5_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
152 | (t1),
|
---|
153 | (t2),
|
---|
154 | (t3),
|
---|
155 | (t4),
|
---|
156 | (t5)
|
---|
157 | );
|
---|
158 | op(std::get<Index-1>(t1), std::get<Index-1>(t2), std::get<Index-1>(t3),std::get<Index-1>(t4),std::get<Index-1>(t5));
|
---|
159 | }
|
---|
160 | };
|
---|
161 |
|
---|
162 | template <>
|
---|
163 | struct apply5_t<0>{
|
---|
164 | template<typename Op, typename... stuff>
|
---|
165 | static void run_r(Op op, stuff...){}
|
---|
166 | };
|
---|
167 |
|
---|
168 | //--- 6 ---
|
---|
169 | template <size_t Index>
|
---|
170 | struct apply6_t{
|
---|
171 | template<typename Op,
|
---|
172 | typename T1, typename T2, typename T3, typename T4, typename T5,
|
---|
173 | typename T6
|
---|
174 | >
|
---|
175 | static void run_r(
|
---|
176 | Op op,
|
---|
177 | T1 &t1, T2 &t2, T3 &t3,T4 &t4, T5 &t5,
|
---|
178 | T6 &t6){
|
---|
179 | apply6_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
180 | (t1),
|
---|
181 | (t2),
|
---|
182 | (t3),
|
---|
183 | (t4),
|
---|
184 | (t5),
|
---|
185 | (t6)
|
---|
186 | );
|
---|
187 | op(std::get<Index-1>(t1), std::get<Index-1>(t2), std::get<Index-1>(t3),std::get<Index-1>(t4),std::get<Index-1>(t5),
|
---|
188 | std::get<Index-1>(t6)
|
---|
189 | );
|
---|
190 | }
|
---|
191 | };
|
---|
192 |
|
---|
193 | template <>
|
---|
194 | struct apply6_t<0>{
|
---|
195 | template<typename Op, typename... stuff>
|
---|
196 | static void run_r(Op op, stuff...){}
|
---|
197 | };
|
---|
198 |
|
---|
199 |
|
---|
200 | //--- 7 ---
|
---|
201 | template <size_t Index>
|
---|
202 | struct apply7_t{
|
---|
203 | template<typename Op,
|
---|
204 | typename T1, typename T2, typename T3, typename T4, typename T5,
|
---|
205 | typename T6, typename T7
|
---|
206 | >
|
---|
207 | static void run_r(Op op,
|
---|
208 | T1 &t1, T2 &t2, T3 &t3,T4 &t4, T5 &t5,
|
---|
209 | T6 &t6, T7 &t7){
|
---|
210 | apply7_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
211 | (t1),
|
---|
212 | (t2),
|
---|
213 | (t3),
|
---|
214 | (t4),
|
---|
215 | (t5),
|
---|
216 | (t6),
|
---|
217 | (t7)
|
---|
218 | );
|
---|
219 | op(std::get<Index-1>(t1), std::get<Index-1>(t2), std::get<Index-1>(t3),std::get<Index-1>(t4),std::get<Index-1>(t5),
|
---|
220 | std::get<Index-1>(t6), std::get<Index-1>(t7)
|
---|
221 | );
|
---|
222 | }
|
---|
223 | };
|
---|
224 |
|
---|
225 | template <>
|
---|
226 | struct apply7_t<0>{
|
---|
227 | template<typename Op, typename... stuff>
|
---|
228 | static void run_r(Op op, stuff...){}
|
---|
229 | };
|
---|
230 |
|
---|
231 | //--- 8 ---
|
---|
232 | template <size_t Index>
|
---|
233 | struct apply8_t{
|
---|
234 | template<typename Op,
|
---|
235 | typename T1, typename T2, typename T3, typename T4, typename T5,
|
---|
236 | typename T6, typename T7, typename T8
|
---|
237 | >
|
---|
238 | static void run_r(Op op,
|
---|
239 | T1 &t1, T2 &t2, T3 &t3,T4 &t4, T5 &t5,
|
---|
240 | T6 &t6, T7 &t7, T8 &t8){
|
---|
241 | apply8_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
242 | (t1),
|
---|
243 | (t2),
|
---|
244 | (t3),
|
---|
245 | (t4),
|
---|
246 | (t5),
|
---|
247 | (t6),
|
---|
248 | (t7),
|
---|
249 | (t8)
|
---|
250 | );
|
---|
251 | op(std::get<Index-1>(t1), std::get<Index-1>(t2), std::get<Index-1>(t3),std::get<Index-1>(t4),std::get<Index-1>(t5),
|
---|
252 | std::get<Index-1>(t6), std::get<Index-1>(t7), std::get<Index-1>(t8)
|
---|
253 | );
|
---|
254 | }
|
---|
255 | };
|
---|
256 |
|
---|
257 | template <>
|
---|
258 | struct apply8_t<0>{
|
---|
259 | template<typename Op, typename... stuff>
|
---|
260 | static void run_r(Op op, stuff...){}
|
---|
261 | };
|
---|
262 |
|
---|
263 |
|
---|
264 | //--- 9 ---
|
---|
265 | template <size_t Index>
|
---|
266 | struct apply9_t{
|
---|
267 | template<typename Op,
|
---|
268 | typename T1, typename T2, typename T3, typename T4, typename T5,
|
---|
269 | typename T6, typename T7, typename T8, typename T9
|
---|
270 | >
|
---|
271 | static void run_r(Op op,
|
---|
272 | T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5,
|
---|
273 | T6 &t6, T7 &t7, T8 &t8, T9 &t9){
|
---|
274 | apply9_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
275 | (t1),
|
---|
276 | (t2),
|
---|
277 | (t3),
|
---|
278 | (t4),
|
---|
279 | (t5),
|
---|
280 | (t6),
|
---|
281 | (t7),
|
---|
282 | (t8),
|
---|
283 | (t9)
|
---|
284 | );
|
---|
285 | op(std::get<Index-1>(t1), std::get<Index-1>(t2), std::get<Index-1>(t3), std::get<Index-1>(t4),std::get<Index-1>(t5),
|
---|
286 | std::get<Index-1>(t6), std::get<Index-1>(t7), std::get<Index-1>(t8), std::get<Index-1>(t9)
|
---|
287 | );
|
---|
288 | }
|
---|
289 | };
|
---|
290 |
|
---|
291 | template <>
|
---|
292 | struct apply9_t<0>{
|
---|
293 | template<typename Op, typename... stuff>
|
---|
294 | static void run_r(Op op, stuff...){}
|
---|
295 | };
|
---|
296 |
|
---|
297 |
|
---|
298 | //--- 10 ---
|
---|
299 | template <size_t Index>
|
---|
300 | struct apply10_t{
|
---|
301 | template<typename Op,
|
---|
302 | typename T1, typename T2, typename T3, typename T4, typename T5,
|
---|
303 | typename T6, typename T7, typename T8, typename T9, typename T10
|
---|
304 | >
|
---|
305 | static void run_r(Op op,
|
---|
306 | T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5,
|
---|
307 | T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10){
|
---|
308 | apply10_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
309 | (t1),
|
---|
310 | (t2),
|
---|
311 | (t3),
|
---|
312 | (t4),
|
---|
313 | (t5),
|
---|
314 | (t6),
|
---|
315 | (t7),
|
---|
316 | (t8),
|
---|
317 | (t9),
|
---|
318 | (t10)
|
---|
319 | );
|
---|
320 | op(std::get<Index-1>(t1), std::get<Index-1>(t2), std::get<Index-1>(t3), std::get<Index-1>(t4),std::get<Index-1>(t5),
|
---|
321 | std::get<Index-1>(t6), std::get<Index-1>(t7), std::get<Index-1>(t8), std::get<Index-1>(t9),std::get<Index-1>(t10)
|
---|
322 | );
|
---|
323 | }
|
---|
324 | };
|
---|
325 |
|
---|
326 | template <>
|
---|
327 | struct apply10_t<0>{
|
---|
328 | template<typename Op, typename... stuff>
|
---|
329 | static void run_r(Op op, stuff...){}
|
---|
330 | };
|
---|
331 |
|
---|
332 | //--- 11 ---
|
---|
333 | template <size_t Index>
|
---|
334 | struct apply11_t{
|
---|
335 | template<typename Op,
|
---|
336 | typename T1, typename T2, typename T3, typename T4, typename T5,
|
---|
337 | typename T6, typename T7, typename T8, typename T9, typename T10,
|
---|
338 | typename T11
|
---|
339 | >
|
---|
340 | static void run_r(Op op,
|
---|
341 | T1 &t1 , T2 &t2, T3 &t3, T4 &t4, T5 &t5,
|
---|
342 | T6 &t6 , T7 &t7, T8 &t8, T9 &t9, T10 &t10,
|
---|
343 | T11 t11){
|
---|
344 | apply11_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
345 | (t1),
|
---|
346 | (t2),
|
---|
347 | (t3),
|
---|
348 | (t4),
|
---|
349 | (t5),
|
---|
350 | (t6),
|
---|
351 | (t7),
|
---|
352 | (t8),
|
---|
353 | (t9),
|
---|
354 | (t10),
|
---|
355 | (t11)
|
---|
356 | );
|
---|
357 | op(std::get<Index-1>(t1) , std::get<Index-1>(t2) , std::get<Index-1>(t3) , std::get<Index-1>(t4),std::get<Index-1>(t5),
|
---|
358 | std::get<Index-1>(t6) , std::get<Index-1>(t7) , std::get<Index-1>(t8) , std::get<Index-1>(t9),std::get<Index-1>(t10),
|
---|
359 | std::get<Index-1>(t11)
|
---|
360 | );
|
---|
361 | }
|
---|
362 | };
|
---|
363 |
|
---|
364 | template <>
|
---|
365 | struct apply11_t<0>{
|
---|
366 | template<typename Op, typename... stuff>
|
---|
367 | static void run_r(Op op, stuff...){}
|
---|
368 | };
|
---|
369 |
|
---|
370 | //--- 12 ---
|
---|
371 | template <size_t Index>
|
---|
372 | struct apply12_t{
|
---|
373 | template<typename Op,
|
---|
374 | typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
|
---|
375 | typename T6 , typename T7 , typename T8 , typename T9 , typename T10,
|
---|
376 | typename T11, typename T12
|
---|
377 | >
|
---|
378 | static void run_r(Op op,
|
---|
379 | T1 &t1 , T2 &t2 , T3 &t3, T4 &t4, T5 &t5,
|
---|
380 | T6 &t6 , T7 &t7 , T8 &t8, T9 &t9, T10 &t10,
|
---|
381 | T11 &t11, T12 &t12){
|
---|
382 | apply12_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
383 | (t1),
|
---|
384 | (t2),
|
---|
385 | (t3),
|
---|
386 | (t4),
|
---|
387 | (t5),
|
---|
388 | (t6),
|
---|
389 | (t7),
|
---|
390 | (t8),
|
---|
391 | (t9),
|
---|
392 | (t10),
|
---|
393 | (t11),
|
---|
394 | (t12)
|
---|
395 | );
|
---|
396 | op(std::get<Index-1>(t1) , std::get<Index-1>(t2) , std::get<Index-1>(t3) , std::get<Index-1>(t4),std::get<Index-1>(t5),
|
---|
397 | std::get<Index-1>(t6) , std::get<Index-1>(t7) , std::get<Index-1>(t8) , std::get<Index-1>(t9),std::get<Index-1>(t10),
|
---|
398 | std::get<Index-1>(t11), std::get<Index-1>(t12)
|
---|
399 | );
|
---|
400 | }
|
---|
401 | };
|
---|
402 |
|
---|
403 | template <>
|
---|
404 | struct apply12_t<0>{
|
---|
405 | template<typename Op, typename... stuff>
|
---|
406 | static void run_r(Op op, stuff...){}
|
---|
407 | };
|
---|
408 |
|
---|
409 |
|
---|
410 | //--- 13 ---
|
---|
411 | template <size_t Index>
|
---|
412 | struct apply13_t{
|
---|
413 | template<typename Op,
|
---|
414 | typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
|
---|
415 | typename T6 , typename T7 , typename T8 , typename T9 , typename T10,
|
---|
416 | typename T11, typename T12, typename T13
|
---|
417 | >
|
---|
418 | static void run_r(Op op,
|
---|
419 | T1 &t1 , T2 &t2 , T3 &t3, T4 &t4, T5 &t5,
|
---|
420 | T6 &t6 , T7 &t7 , T8 &t8, T9 &t9, T10 &t10,
|
---|
421 | T11 &t11, T12 &t12, T13 &t13){
|
---|
422 | apply13_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
423 | (t1),
|
---|
424 | (t2),
|
---|
425 | (t3),
|
---|
426 | (t4),
|
---|
427 | (t5),
|
---|
428 | (t6),
|
---|
429 | (t7),
|
---|
430 | (t8),
|
---|
431 | (t9),
|
---|
432 | (t10),
|
---|
433 | (t11),
|
---|
434 | (t12),
|
---|
435 | (t13)
|
---|
436 | );
|
---|
437 | op(std::get<Index-1>(t1) , std::get<Index-1>(t2) , std::get<Index-1>(t3) , std::get<Index-1>(t4),std::get<Index-1>(t5),
|
---|
438 | std::get<Index-1>(t6) , std::get<Index-1>(t7) , std::get<Index-1>(t8) , std::get<Index-1>(t9),std::get<Index-1>(t10),
|
---|
439 | std::get<Index-1>(t11), std::get<Index-1>(t12), std::get<Index-1>(t13)
|
---|
440 | );
|
---|
441 | }
|
---|
442 | };
|
---|
443 |
|
---|
444 | template <>
|
---|
445 | struct apply13_t<0>{
|
---|
446 | template<typename Op, typename... stuff>
|
---|
447 | static void run_r(Op op, stuff...){}
|
---|
448 | };
|
---|
449 |
|
---|
450 |
|
---|
451 | //--- 14 ---
|
---|
452 | template <size_t Index>
|
---|
453 | struct apply14_t{
|
---|
454 | template<typename Op,
|
---|
455 | typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
|
---|
456 | typename T6 , typename T7 , typename T8 , typename T9 , typename T10,
|
---|
457 | typename T11, typename T12, typename T13, typename T14
|
---|
458 | >
|
---|
459 | static void run_r(Op op,
|
---|
460 | T1 &t1 , T2 &t2 , T3 &t3, T4 &t4, T5 &t5,
|
---|
461 | T6 &t6 , T7 &t7 , T8 &t8, T9 &t9, T10 &t10,
|
---|
462 | T11 &t11, T12 &t12, T13 &t13,T14 &t14){
|
---|
463 | apply14_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
464 | (t1),
|
---|
465 | (t2),
|
---|
466 | (t3),
|
---|
467 | (t4),
|
---|
468 | (t5),
|
---|
469 | (t6),
|
---|
470 | (t7),
|
---|
471 | (t8),
|
---|
472 | (t9),
|
---|
473 | (t10),
|
---|
474 | (t11),
|
---|
475 | (t12),
|
---|
476 | (t13),
|
---|
477 | (t14)
|
---|
478 | );
|
---|
479 | op(std::get<Index-1>(t1) , std::get<Index-1>(t2) , std::get<Index-1>(t3) , std::get<Index-1>(t4) ,std::get<Index-1>(t5),
|
---|
480 | std::get<Index-1>(t6) , std::get<Index-1>(t7) , std::get<Index-1>(t8) , std::get<Index-1>(t9) ,std::get<Index-1>(t10),
|
---|
481 | std::get<Index-1>(t11), std::get<Index-1>(t12), std::get<Index-1>(t13), std::get<Index-1>(t14)
|
---|
482 | );
|
---|
483 | }
|
---|
484 | };
|
---|
485 |
|
---|
486 | template <>
|
---|
487 | struct apply14_t<0>{
|
---|
488 | template<typename Op, typename... stuff>
|
---|
489 | static void run_r(Op op, stuff...){}
|
---|
490 | };
|
---|
491 |
|
---|
492 | //--- 15 ---
|
---|
493 | template <size_t Index>
|
---|
494 | struct apply15_t{
|
---|
495 | template<typename Op,
|
---|
496 | typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
|
---|
497 | typename T6 , typename T7 , typename T8 , typename T9 , typename T10,
|
---|
498 | typename T11, typename T12, typename T13, typename T14, typename T15
|
---|
499 | >
|
---|
500 | static void run_r(Op op,
|
---|
501 | T1 &t1 , T2 &t2 , T3 &t3, T4 &t4, T5 &t5,
|
---|
502 | T6 &t6 , T7 &t7 , T8 &t8, T9 &t9, T10 &t10,
|
---|
503 | T11 &t11, T12 &t12, T13 &t13,T14 &t14, T15 &t15){
|
---|
504 | apply15_t<Index-1>::run_r(std::forward<Op>(op),
|
---|
505 | (t1),
|
---|
506 | (t2),
|
---|
507 | (t3),
|
---|
508 | (t4),
|
---|
509 | (t5),
|
---|
510 | (t6),
|
---|
511 | (t7),
|
---|
512 | (t8),
|
---|
513 | (t9),
|
---|
514 | (t10),
|
---|
515 | (t11),
|
---|
516 | (t12),
|
---|
517 | (t13),
|
---|
518 | (t14),
|
---|
519 | (t15)
|
---|
520 | );
|
---|
521 | op(std::get<Index-1>(t1) , std::get<Index-1>(t2) , std::get<Index-1>(t3) , std::get<Index-1>(t4) ,std::get<Index-1>(t5),
|
---|
522 | std::get<Index-1>(t6) , std::get<Index-1>(t7) , std::get<Index-1>(t8) , std::get<Index-1>(t9) ,std::get<Index-1>(t10),
|
---|
523 | std::get<Index-1>(t11), std::get<Index-1>(t12), std::get<Index-1>(t13), std::get<Index-1>(t14),std::get<Index-1>(t15)
|
---|
524 | );
|
---|
525 | }
|
---|
526 | };
|
---|
527 |
|
---|
528 | template <>
|
---|
529 | struct apply15_t<0>{
|
---|
530 | template<typename Op, typename... stuff>
|
---|
531 | static void run_r(Op op, stuff...){}
|
---|
532 | };
|
---|
533 |
|
---|
534 |
|
---|
535 | }
|
---|
536 |
|
---|
537 |
|
---|
538 |
|
---|
539 |
|
---|
540 | struct std_tuple_algebra{
|
---|
541 |
|
---|
542 | template<typename... Args>
|
---|
543 | static double norm_inf(const std::tuple<Args...> &t){
|
---|
544 | double sum=0;
|
---|
545 | std_tuple_algebra_impl::norm_inf_t<sizeof...(Args)>::run_r(t,sum);
|
---|
546 | return sum;
|
---|
547 | }
|
---|
548 |
|
---|
549 |
|
---|
550 |
|
---|
551 |
|
---|
552 | //--- 1 ---
|
---|
553 | template<typename T1, class Operation>
|
---|
554 | static void for_each1(
|
---|
555 | T1 &t1,
|
---|
556 | Operation op )
|
---|
557 | {
|
---|
558 | std_tuple_algebra_impl::apply1_t<std::tuple_size<T1>::value>::run_r(std::forward<Operation>(op),(t1));
|
---|
559 | }
|
---|
560 |
|
---|
561 | //--- 2 ---
|
---|
562 | template<
|
---|
563 | typename T1, typename T2,
|
---|
564 | class Operation
|
---|
565 | >
|
---|
566 | static void for_each2(
|
---|
567 | T1 &t1 , T2 &t2,
|
---|
568 | Operation op )
|
---|
569 | {
|
---|
570 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2>::value, "size mismatch in for_each2 for t2");
|
---|
571 | std_tuple_algebra_impl::apply2_t<std::tuple_size<T1>::value>::run_r(std::forward<Operation>(op),(t1),(t2));
|
---|
572 | }
|
---|
573 |
|
---|
574 |
|
---|
575 |
|
---|
576 | //---3---
|
---|
577 | template<
|
---|
578 | typename T1, typename T2, typename T3,
|
---|
579 | class Operation
|
---|
580 | >
|
---|
581 | static void for_each3(
|
---|
582 | T1 &t1 , T2 &t2 , T3 &t3 ,
|
---|
583 | Operation op )
|
---|
584 | {
|
---|
585 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2>::value, "size mismatch in for_each3 for t2");
|
---|
586 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3>::value, "size mismatch in for_each3 for t3");
|
---|
587 | std_tuple_algebra_impl::apply3_t<std::tuple_size<T1>::value>::run_r(std::forward<Operation>(op),t1,t2,t3);
|
---|
588 | }
|
---|
589 |
|
---|
590 | //---4---
|
---|
591 | template<
|
---|
592 | typename T1, typename T2, typename T3, typename T4,
|
---|
593 | class Operation
|
---|
594 | >
|
---|
595 | static void for_each4(
|
---|
596 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 ,
|
---|
597 | Operation op )
|
---|
598 | {
|
---|
599 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2>::value, "size mismatch in for_each4 for t2");
|
---|
600 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3>::value, "size mismatch in for_each4 for t3");
|
---|
601 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4>::value, "size mismatch in for_each4 for t4");
|
---|
602 |
|
---|
603 | std_tuple_algebra_impl::apply4_t<std::tuple_size<T1>::value>::run_r(std::forward<Operation>(op),(t1),(t2),(t3),(t4));
|
---|
604 | }
|
---|
605 |
|
---|
606 | //---5---
|
---|
607 | template<
|
---|
608 | typename T1, typename T2, typename T3, typename T4,typename T5,
|
---|
609 | class Operation
|
---|
610 | >
|
---|
611 | static void for_each5(
|
---|
612 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
613 | Operation op )
|
---|
614 | {
|
---|
615 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2>::value, "size mismatch in for_each5 for t2");
|
---|
616 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3>::value, "size mismatch in for_each5 for t3");
|
---|
617 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4>::value, "size mismatch in for_each5 for t4");
|
---|
618 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5>::value, "size mismatch in for_each5 for t5");
|
---|
619 |
|
---|
620 | std_tuple_algebra_impl::apply5_t<std::tuple_size<T1>::value>::run_r(std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5));
|
---|
621 | }
|
---|
622 |
|
---|
623 | //---6---
|
---|
624 | template<
|
---|
625 | typename T1, typename T2, typename T3, typename T4,typename T5,
|
---|
626 | typename T6,
|
---|
627 | class Operation
|
---|
628 | >
|
---|
629 | static void for_each6(
|
---|
630 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
631 | T6 &t6 ,
|
---|
632 | Operation op )
|
---|
633 | {
|
---|
634 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2>::value, "size mismatch in for_each6 for t2");
|
---|
635 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3>::value, "size mismatch in for_each6 for t3");
|
---|
636 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4>::value, "size mismatch in for_each6 for t4");
|
---|
637 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5>::value, "size mismatch in for_each6 for t5");
|
---|
638 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6>::value, "size mismatch in for_each6 for t6");
|
---|
639 |
|
---|
640 | std_tuple_algebra_impl::apply6_t<std::tuple_size<T1>::value>::run_r(
|
---|
641 | std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5),
|
---|
642 | (t6)
|
---|
643 | );
|
---|
644 | }
|
---|
645 |
|
---|
646 | //---7---
|
---|
647 | template<
|
---|
648 | typename T1, typename T2, typename T3, typename T4,typename T5,
|
---|
649 | typename T6, typename T7,
|
---|
650 | class Operation
|
---|
651 | >
|
---|
652 | static void for_each7(
|
---|
653 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
654 | T6 &t6 , T7 &t7 ,
|
---|
655 | Operation op )
|
---|
656 | {
|
---|
657 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2>::value, "size mismatch in for_each7 for t2");
|
---|
658 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3>::value, "size mismatch in for_each7 for t3");
|
---|
659 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4>::value, "size mismatch in for_each7 for t4");
|
---|
660 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5>::value, "size mismatch in for_each7 for t5");
|
---|
661 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6>::value, "size mismatch in for_each7 for t6");
|
---|
662 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T7>::value, "size mismatch in for_each7 for t7");
|
---|
663 |
|
---|
664 | std_tuple_algebra_impl::apply7_t<std::tuple_size<T1>::value>::run_r(
|
---|
665 | std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5),
|
---|
666 | (t6),(t7)
|
---|
667 | );
|
---|
668 | }
|
---|
669 |
|
---|
670 |
|
---|
671 | //---8---
|
---|
672 | template<
|
---|
673 | typename T1, typename T2, typename T3, typename T4,typename T5,
|
---|
674 | typename T6, typename T7, typename T8,
|
---|
675 | class Operation
|
---|
676 | >
|
---|
677 | static void for_each8(
|
---|
678 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
679 | T6 &t6 , T7 &t7 , T8 &t8 ,
|
---|
680 | Operation op )
|
---|
681 | {
|
---|
682 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2>::value, "size mismatch in for_each8 for t2");
|
---|
683 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3>::value, "size mismatch in for_each8 for t3");
|
---|
684 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4>::value, "size mismatch in for_each8 for t4");
|
---|
685 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5>::value, "size mismatch in for_each8 for t5");
|
---|
686 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6>::value, "size mismatch in for_each8 for t6");
|
---|
687 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T7>::value, "size mismatch in for_each8 for t7");
|
---|
688 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T8>::value, "size mismatch in for_each8 for t8");
|
---|
689 |
|
---|
690 | std_tuple_algebra_impl::apply8_t<std::tuple_size<T1>::value>::run_r(
|
---|
691 | std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5),
|
---|
692 | (t6),(t7),(t8)
|
---|
693 | );
|
---|
694 | }
|
---|
695 |
|
---|
696 | //---9---
|
---|
697 | template<
|
---|
698 | typename T1, typename T2, typename T3, typename T4,typename T5,
|
---|
699 | typename T6, typename T7, typename T8, typename T9,
|
---|
700 | class Operation
|
---|
701 | >
|
---|
702 | static void for_each9(
|
---|
703 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
704 | T6 &t6 , T7 &t7 , T8 &t8 , T9 &t9,
|
---|
705 | Operation op )
|
---|
706 | {
|
---|
707 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2>::value, "size mismatch in for_each9 for t2");
|
---|
708 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3>::value, "size mismatch in for_each9 for t3");
|
---|
709 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4>::value, "size mismatch in for_each9 for t4");
|
---|
710 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5>::value, "size mismatch in for_each9 for t5");
|
---|
711 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6>::value, "size mismatch in for_each9 for t6");
|
---|
712 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T7>::value, "size mismatch in for_each9 for t7");
|
---|
713 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T8>::value, "size mismatch in for_each9 for t8");
|
---|
714 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T9>::value, "size mismatch in for_each9 for t9");
|
---|
715 |
|
---|
716 | std_tuple_algebra_impl::apply9_t<std::tuple_size<T1>::value>::run_r(
|
---|
717 | std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5),
|
---|
718 | (t6),(t7),(t8),(t9)
|
---|
719 | );
|
---|
720 | }
|
---|
721 |
|
---|
722 | //---10---
|
---|
723 | template<
|
---|
724 | typename T1, typename T2, typename T3, typename T4,typename T5,
|
---|
725 | typename T6, typename T7, typename T8, typename T9,typename T10,
|
---|
726 | class Operation
|
---|
727 | >
|
---|
728 | static void for_each10(
|
---|
729 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
730 | T6 &t6 , T7 &t7 , T8 &t8 , T9 &t9 , T10 &t10,
|
---|
731 | Operation op )
|
---|
732 | {
|
---|
733 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2 >::value, "size mismatch in for_each10 for t2");
|
---|
734 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3 >::value, "size mismatch in for_each10 for t3");
|
---|
735 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4 >::value, "size mismatch in for_each10 for t4");
|
---|
736 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5 >::value, "size mismatch in for_each10 for t5");
|
---|
737 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6 >::value, "size mismatch in for_each10 for t6");
|
---|
738 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T7 >::value, "size mismatch in for_each10 for t7");
|
---|
739 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T8 >::value, "size mismatch in for_each10 for t8");
|
---|
740 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T9 >::value, "size mismatch in for_each10 for t9");
|
---|
741 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T10>::value, "size mismatch in for_each10 for t10");
|
---|
742 |
|
---|
743 | std_tuple_algebra_impl::apply10_t<std::tuple_size<T1>::value>::run_r(
|
---|
744 | std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5),
|
---|
745 | (t6),(t7),(t8),(t9),(t10)
|
---|
746 | );
|
---|
747 | }
|
---|
748 |
|
---|
749 | //---11---
|
---|
750 | template<
|
---|
751 | typename T1 , typename T2 , typename T3 , typename T4 ,typename T5 ,
|
---|
752 | typename T6 , typename T7 , typename T8 , typename T9 ,typename T10,
|
---|
753 | typename T11,
|
---|
754 | class Operation
|
---|
755 | >
|
---|
756 | static void for_each11(
|
---|
757 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
758 | T6 &t6 , T7 &t7 , T8 &t8 , T9 &t9 , T10 &t10,
|
---|
759 | T11 &t11,
|
---|
760 | Operation op )
|
---|
761 | {
|
---|
762 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2 >::value, "size mismatch in for_each11 for t2");
|
---|
763 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3 >::value, "size mismatch in for_each11 for t3");
|
---|
764 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4 >::value, "size mismatch in for_each11 for t4");
|
---|
765 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5 >::value, "size mismatch in for_each11 for t5");
|
---|
766 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6 >::value, "size mismatch in for_each11 for t6");
|
---|
767 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T7 >::value, "size mismatch in for_each11 for t7");
|
---|
768 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T8 >::value, "size mismatch in for_each11 for t8");
|
---|
769 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T9 >::value, "size mismatch in for_each11 for t9");
|
---|
770 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T10>::value, "size mismatch in for_each11 for t10");
|
---|
771 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T11>::value, "size mismatch in for_each11 for t11");
|
---|
772 |
|
---|
773 | std_tuple_algebra_impl::apply11_t<std::tuple_size<T1>::value>::run_r(
|
---|
774 | std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5),
|
---|
775 | (t6),(t7),(t8),(t9),(t10),
|
---|
776 | (t11)
|
---|
777 | );
|
---|
778 | }
|
---|
779 |
|
---|
780 | //---12---
|
---|
781 | template<
|
---|
782 | typename T1 , typename T2 , typename T3 , typename T4 ,typename T5 ,
|
---|
783 | typename T6 , typename T7 , typename T8 , typename T9 ,typename T10,
|
---|
784 | typename T11, typename T12,
|
---|
785 | class Operation
|
---|
786 | >
|
---|
787 | static void for_each12(
|
---|
788 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
789 | T6 &t6 , T7 &t7 , T8 &t8 , T9 &t9 , T10 &t10,
|
---|
790 | T11 &t11, T12 &t12,
|
---|
791 | Operation op )
|
---|
792 | {
|
---|
793 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2 >::value, "size mismatch in for_each12 for t2");
|
---|
794 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3 >::value, "size mismatch in for_each12 for t3");
|
---|
795 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4 >::value, "size mismatch in for_each12 for t4");
|
---|
796 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5 >::value, "size mismatch in for_each12 for t5");
|
---|
797 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6 >::value, "size mismatch in for_each12 for t6");
|
---|
798 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T7 >::value, "size mismatch in for_each12 for t7");
|
---|
799 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T8 >::value, "size mismatch in for_each12 for t8");
|
---|
800 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T9 >::value, "size mismatch in for_each12 for t9");
|
---|
801 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T10>::value, "size mismatch in for_each12 for t10");
|
---|
802 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T11>::value, "size mismatch in for_each12 for t11");
|
---|
803 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T12>::value, "size mismatch in for_each12 for t12");
|
---|
804 |
|
---|
805 |
|
---|
806 | std_tuple_algebra_impl::apply12_t<std::tuple_size<T1>::value>::run_r(
|
---|
807 | std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5),
|
---|
808 | (t6),(t7),(t8),(t9),(t10),
|
---|
809 | (t11), (t12)
|
---|
810 | );
|
---|
811 | }
|
---|
812 |
|
---|
813 |
|
---|
814 | //---13---
|
---|
815 | template<
|
---|
816 | typename T1 , typename T2 , typename T3 , typename T4 ,typename T5 ,
|
---|
817 | typename T6 , typename T7 , typename T8 , typename T9 ,typename T10,
|
---|
818 | typename T11, typename T12, typename T13,
|
---|
819 | class Operation
|
---|
820 | >
|
---|
821 | static void for_each13(
|
---|
822 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
823 | T6 &t6 , T7 &t7 , T8 &t8 , T9 &t9 , T10 &t10,
|
---|
824 | T11 &t11, T12 &t12, T13 &t13,
|
---|
825 | Operation op )
|
---|
826 | {
|
---|
827 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2 >::value, "size mismatch in for_each13 for t2");
|
---|
828 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3 >::value, "size mismatch in for_each13 for t3");
|
---|
829 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4 >::value, "size mismatch in for_each13 for t4");
|
---|
830 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5 >::value, "size mismatch in for_each13 for t5");
|
---|
831 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6 >::value, "size mismatch in for_each13 for t6");
|
---|
832 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T7 >::value, "size mismatch in for_each13 for t7");
|
---|
833 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T8 >::value, "size mismatch in for_each13 for t8");
|
---|
834 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T9 >::value, "size mismatch in for_each13 for t9");
|
---|
835 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T10>::value, "size mismatch in for_each13 for t10");
|
---|
836 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T11>::value, "size mismatch in for_each13 for t11");
|
---|
837 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T12>::value, "size mismatch in for_each13 for t12");
|
---|
838 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T13>::value, "size mismatch in for_each13 for t13");
|
---|
839 |
|
---|
840 |
|
---|
841 | std_tuple_algebra_impl::apply13_t<std::tuple_size<T1>::value>::run_r(
|
---|
842 | std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5),
|
---|
843 | (t6),(t7),(t8),(t9),(t10),
|
---|
844 | (t11),(t12),(t13)
|
---|
845 | );
|
---|
846 | }
|
---|
847 |
|
---|
848 | //---14---
|
---|
849 | template<
|
---|
850 | typename T1 , typename T2 , typename T3 , typename T4 ,typename T5 ,
|
---|
851 | typename T6 , typename T7 , typename T8 , typename T9 ,typename T10,
|
---|
852 | typename T11, typename T12, typename T13, typename T14,
|
---|
853 | class Operation
|
---|
854 | >
|
---|
855 | static void for_each14(
|
---|
856 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
857 | T6 &t6 , T7 &t7 , T8 &t8 , T9 &t9 , T10 &t10,
|
---|
858 | T11 &t11, T12 &t12, T13 &t13, T14 &t14,
|
---|
859 | Operation op )
|
---|
860 | {
|
---|
861 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2 >::value, "size mismatch in for_each14 for t2");
|
---|
862 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3 >::value, "size mismatch in for_each14 for t3");
|
---|
863 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4 >::value, "size mismatch in for_each14 for t4");
|
---|
864 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5 >::value, "size mismatch in for_each14 for t5");
|
---|
865 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6 >::value, "size mismatch in for_each14 for t6");
|
---|
866 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T7 >::value, "size mismatch in for_each14 for t7");
|
---|
867 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T8 >::value, "size mismatch in for_each14 for t8");
|
---|
868 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T9 >::value, "size mismatch in for_each14 for t9");
|
---|
869 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T10>::value, "size mismatch in for_each14 for t10");
|
---|
870 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T11>::value, "size mismatch in for_each14 for t11");
|
---|
871 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T12>::value, "size mismatch in for_each14 for t12");
|
---|
872 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T13>::value, "size mismatch in for_each14 for t13");
|
---|
873 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T14>::value, "size mismatch in for_each14 for t14");
|
---|
874 |
|
---|
875 |
|
---|
876 | std_tuple_algebra_impl::apply14_t<std::tuple_size<T1>::value>::run_r(
|
---|
877 | std::forward<Operation>(op),(t1),(t2),(t3),(t4),(t5),
|
---|
878 | (t6),(t7),(t8),(t9),(t10),
|
---|
879 | (t11),(t12),(t13),(t14)
|
---|
880 | );
|
---|
881 | }
|
---|
882 |
|
---|
883 | //---14---
|
---|
884 | template<
|
---|
885 | typename T1 , typename T2 , typename T3 , typename T4 ,typename T5 ,
|
---|
886 | typename T6 , typename T7 , typename T8 , typename T9 ,typename T10,
|
---|
887 | typename T11, typename T12, typename T13, typename T14,typename T15,
|
---|
888 | class Operation
|
---|
889 | >
|
---|
890 | static void for_each15(
|
---|
891 | T1 &t1 , T2 &t2 , T3 &t3 , T4 &t4 , T5 &t5 ,
|
---|
892 | T6 &t6 , T7 &t7 , T8 &t8 , T9 &t9 , T10 &t10,
|
---|
893 | T11 &t11, T12 &t12, T13 &t13, T14 &t14, T15 &t15,
|
---|
894 | Operation op )
|
---|
895 | {
|
---|
896 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T2 >::value, "size mismatch in for_each15 for t2");
|
---|
897 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T3 >::value, "size mismatch in for_each15 for t3");
|
---|
898 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T4 >::value, "size mismatch in for_each15 for t4");
|
---|
899 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T5 >::value, "size mismatch in for_each15 for t5");
|
---|
900 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T6 >::value, "size mismatch in for_each15 for t6");
|
---|
901 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T7 >::value, "size mismatch in for_each15 for t7");
|
---|
902 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T8 >::value, "size mismatch in for_each15 for t8");
|
---|
903 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T9 >::value, "size mismatch in for_each15 for t9");
|
---|
904 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T10>::value, "size mismatch in for_each15 for t10");
|
---|
905 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T11>::value, "size mismatch in for_each15 for t11");
|
---|
906 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T12>::value, "size mismatch in for_each15 for t12");
|
---|
907 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T13>::value, "size mismatch in for_each15 for t13");
|
---|
908 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T14>::value, "size mismatch in for_each15 for t14");
|
---|
909 | static_assert(std::tuple_size<T1>::value == std::tuple_size<T15>::value, "size mismatch in for_each15 for t15");
|
---|
910 |
|
---|
911 |
|
---|
912 | std_tuple_algebra_impl::apply15_t<std::tuple_size<T1>::value>::run_r(
|
---|
913 | std::forward<Operation>(op),(t1),(t2) ,(t3),(t4),(t5),
|
---|
914 | (t6) ,(t7) ,(t8),(t9),(t10),
|
---|
915 | (t11) ,(t12),(t13),(t14),(t15)
|
---|
916 | );
|
---|
917 | }
|
---|
918 |
|
---|
919 |
|
---|
920 |
|
---|
921 |
|
---|
922 |
|
---|
923 |
|
---|
924 | };
|
---|
925 |
|
---|
926 | }}}
|
---|
927 |
|
---|
928 |
|
---|
929 |
|
---|
930 |
|
---|
931 |
|
---|
932 |
|
---|
933 | //---Register algebra in the dispatcher ---
|
---|
934 | #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
|
---|
935 | namespace boost {
|
---|
936 | namespace numeric {
|
---|
937 | namespace odeint {
|
---|
938 | template< typename... Args >
|
---|
939 | struct algebra_dispatcher< std::tuple<Args...> >
|
---|
940 | {
|
---|
941 | typedef std_tuple_algebra algebra_type;
|
---|
942 | };
|
---|
943 |
|
---|
944 | }}}
|
---|
945 |
|
---|
946 |
|
---|
947 |
|
---|
948 |
|
---|
949 |
|
---|
950 |
|
---|
951 |
|
---|
952 | //default integrate function TODO require more testing
|
---|
953 | /*
|
---|
954 | #include <functional>
|
---|
955 |
|
---|
956 | namespace boost {
|
---|
957 | namespace numeric {
|
---|
958 | namespace odeint {
|
---|
959 |
|
---|
960 |
|
---|
961 |
|
---|
962 |
|
---|
963 | template< typename...State_args, typename... Speed_args, typename Time_t, typename Oberver_t>
|
---|
964 | size_t integrate_const(
|
---|
965 | std::function<void(const std::tuple<State_args...>&, std::tuple<Speed_args...>&, const Time_t t)> speed ,
|
---|
966 | const std::tuple<State_args...> &init_state ,
|
---|
967 | const Time_t &begin,
|
---|
968 | const Time_t &end,
|
---|
969 | const Time_t &step,
|
---|
970 | Oberver_t &observer=std_tuple_algebra_impl::Observer_nothing()
|
---|
971 | ){
|
---|
972 | typedef std::tuple<State_args...> State_type;
|
---|
973 | typedef std::tuple<Speed_args...> Speed_type;
|
---|
974 | typedef runge_kutta_dopri5< State_type , double , Speed_type , Time_t > stepper_type;
|
---|
975 |
|
---|
976 | return integrate_const(
|
---|
977 | make_dense_output( 1.0e-6 , 1.0e-6 , stepper_type() ) ,
|
---|
978 | speed,
|
---|
979 | init_state ,
|
---|
980 | begin ,
|
---|
981 | end ,
|
---|
982 | step ,
|
---|
983 | observer
|
---|
984 | );
|
---|
985 | }
|
---|
986 |
|
---|
987 |
|
---|
988 | template<
|
---|
989 | typename...State_args,
|
---|
990 | typename... Speed_args,
|
---|
991 | typename Time_t,
|
---|
992 | typename Oberver_t
|
---|
993 | >
|
---|
994 | size_t integrate(
|
---|
995 | std::function<
|
---|
996 | void(
|
---|
997 | const std::tuple<State_args...>&,
|
---|
998 | std::tuple<Speed_args...>&,
|
---|
999 | const Time_t t)
|
---|
1000 | > speed ,
|
---|
1001 | const std::tuple<State_args...> &init_state ,
|
---|
1002 | const Time_t &begin,
|
---|
1003 | const Time_t &end,
|
---|
1004 | const Time_t &step,
|
---|
1005 | Oberver_t &observer=std_tuple_algebra_impl::Observer_nothing()
|
---|
1006 | ){
|
---|
1007 | typedef std::tuple<State_args...> State_type;
|
---|
1008 | typedef std::tuple<Speed_args...> Speed_type;
|
---|
1009 | typedef controlled_runge_kutta< runge_kutta_dopri5< State_type , double , Speed_type , Time_t > > stepper_type;
|
---|
1010 |
|
---|
1011 | return integrate_adaptive(
|
---|
1012 | stepper_type() ,
|
---|
1013 | speed,
|
---|
1014 | init_state ,
|
---|
1015 | begin,
|
---|
1016 | end,
|
---|
1017 | step,
|
---|
1018 | observer
|
---|
1019 | );
|
---|
1020 | }
|
---|
1021 |
|
---|
1022 |
|
---|
1023 | }}}
|
---|
1024 |
|
---|
1025 | */
|
---|
1026 |
|
---|
1027 |
|
---|
1028 |
|
---|
1029 |
|
---|
1030 |
|
---|
1031 | #endif /* LIB_MODELS_ODE_BOOST_TUPLE_HPP_ */
|
---|