Ticket #11452: Ode_boost_tuple.hpp

File Ode_boost_tuple.hpp, 33.1 KB (added by pierre blavy <blavy@…>, 7 years ago)

make odeint work with std::tuple

Line 
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
15namespace boost {
16namespace numeric {
17namespace odeint {
18
19//user may specialize (entry point to make boost units works)
20template<typename T>
21struct std_tuple_algebra_to_double_t{
22 static double run(const T&t){return static_cast<double>(t);}
23};
24
25
26
27
28template<typename T> double std_tuple_algebra_to_double(const T&t) {return std_tuple_algebra_to_double_t<T>::run(t);}
29inline const double& std_tuple_algebra_to_double(const double&t){return t;}
30
31
32namespace 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
540struct 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>
935namespace boost {
936namespace numeric {
937namespace 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
956namespace boost {
957namespace numeric {
958namespace 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_ */