Accueil Explorer Aide
S'inscrire Connexion
zxw
/
robot
1
0
Fork 0
Fichiers Tickets 0 Pull Requests 0 Wiki
Aborescence: cb845be021
Branches Tags
robot
/
include
/
boost
/
numeric
/
odeint
/
external
/
openmp
/
openmp_nested_algebra.hpp

openmp_nested_algebra.hpp 18 KB
Historique Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281 
  1. /*
    2. 

  2.  [auto_generated]
    3. 

  3.  boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp
    4. 

  4. 

  5.  [begin_description]
    6. 

  6.  Nested parallelized algebra for OpenMP.
    7. 

  7.  [end_description]
    8. 

  8. 

  9.  Copyright 2013 Karsten Ahnert
    10. 

  10.  Copyright 2013 Mario Mulansky
    11. 

  11.  Copyright 2013 Pascal Germroth
    12. 

  12. 

  13.  Distributed under the Boost Software License, Version 1.0.
    14. 

  14.  (See accompanying file LICENSE_1_0.txt or
    15. 

  15.  copy at http://www.boost.org/LICENSE_1_0.txt)
    16. 

  16.  */
    17. 

  17. 

  18. 

  19. #ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_NESTED_ALGEBRA_HPP_INCLUDED
    20. 

  20. #define BOOST_NUMERIC_ODEINT_EXTERNAL_OPENMP_OPENMP_NESTED_ALGEBRA_HPP_INCLUDED
    21. 

  21. 

  22. #include <boost/range.hpp>
    23. 

  23. #include <boost/numeric/odeint/algebra/norm_result_type.hpp>
    24. 

  24. #include <boost/numeric/odeint/util/n_ary_helper.hpp>
    25. 

  25. #include <boost/numeric/odeint/tools/assert.hpp>
    26. 

  26. 

  27. namespace boost {
    28. 

  28. namespace numeric {
    29. 

  29. namespace odeint {
    30. 

  30. 

  31. /** \brief OpenMP-parallelized algebra, wrapping another, non-parallelized algebra.
    32. 

  32.  *
    33. 

  33.  * NestedState must be a model of Random Access Range, where the elements are sub-states
    34. 

  34.  * which will be processed in parallel.
    35. 

  35.  */
    36. 

  36. template< class InnerAlgebra >
    37. 

  37. struct openmp_nested_algebra
    38. 

  38. {
    39. 

  39. 

  40. #if __cplusplus >= 201103L // C++11 supports _Pragma
    41. 

  41. 

  42. #define BOOST_ODEINT_GEN_LOCAL(z, n, unused) \
    43. 

  43.     BOOST_NUMERIC_ODEINT_ASSERT_MSG( len == boost::size(s ## n), "All nested state ranges must have the same size." ); \
    44. 

  44.     typename boost::range_iterator<S ## n>::type beg ## n = boost::begin(s ## n);
    45. 

  45. #define BOOST_ODEINT_GEN_BODY(n) \
    46. 

  46.     const size_t len = boost::size(s0); \
    47. 

  47.     BOOST_PP_REPEAT(n, BOOST_ODEINT_GEN_LOCAL, ~) \
    48. 

  48.     _Pragma("omp parallel for schedule(runtime)") \
    49. 

  49.     for( size_t i = 0 ; i < len ; i++ ) \
    50. 

  50.         InnerAlgebra::for_each##n( \
    51. 

  51.             BOOST_PP_ENUM_BINARY_PARAMS(n, beg, [i] BOOST_PP_INTERCEPT) , \
    52. 

  52.             op \
    53. 

  53.         );
    54. 

  54. BOOST_ODEINT_GEN_FOR_EACH(BOOST_ODEINT_GEN_BODY)
    55. 

  55. #undef BOOST_ODEINT_GEN_BODY
    56. 

  56. #undef BOOST_ODEINT_GEN_LOCAL
    57. 

  57. 

  58. #else
    59. 

  59. 

  60.     template< class S0 , class Op > static void for_each1 ( S0 &s0 , Op op ) {
    61. 

  61.         const size_t len = boost::size(s0);
    62. 

  62.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    63. 

  63.         #pragma omp parallel for schedule(runtime)
    64. 

  64.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each1( beg0 [i] , op );
    65. 

  65.     }
    66. 

  66.     template< class S0 , class S1 , class Op > static void for_each2 ( S0 &s0 , S1 &s1 , Op op ) {
    67. 

  67.         const size_t len = boost::size(s0);
    68. 

  68.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    69. 

  69.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    70. 

  70.         #pragma omp parallel for schedule(runtime)
    71. 

  71.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each2( beg0 [i] , beg1 [i] , op );
    72. 

  72.     }
    73. 

  73.     template< class S0 , class S1 , class S2 , class Op > static void for_each3 ( S0 &s0 , S1 &s1 , S2 &s2 , Op op ) {
    74. 

  74.         const size_t len = boost::size(s0);
    75. 

  75.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    76. 

  76.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    77. 

  77.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    78. 

  78.         #pragma omp parallel for schedule(runtime)
    79. 

  79.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each3( beg0 [i] , beg1 [i] , beg2 [i] , op );
    80. 

  80.     }
    81. 

  81.     template< class S0 , class S1 , class S2 , class S3 , class Op > static void for_each4 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , Op op ) {
    82. 

  82.         const size_t len = boost::size(s0);
    83. 

  83.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    84. 

  84.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    85. 

  85.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    86. 

  86.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    87. 

  87.         #pragma omp parallel for schedule(runtime)
    88. 

  88.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each4( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , op );
    89. 

  89.     }
    90. 

  90.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class Op > static void for_each5 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , Op op ) {
    91. 

  91.         const size_t len = boost::size(s0);
    92. 

  92.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    93. 

  93.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    94. 

  94.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    95. 

  95.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    96. 

  96.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    97. 

  97.         #pragma omp parallel for schedule(runtime)
    98. 

  98.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each5( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , op );
    99. 

  99.     }
    100. 

  100.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class Op > static void for_each6 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , Op op ) {
    101. 

  101.         const size_t len = boost::size(s0);
    102. 

  102.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    103. 

  103.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    104. 

  104.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    105. 

  105.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    106. 

  106.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    107. 

  107.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    108. 

  108.         #pragma omp parallel for schedule(runtime)
    109. 

  109.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each6( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , op );
    110. 

  110.     }
    111. 

  111.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class Op > static void for_each7 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , Op op ) {
    112. 

  112.         const size_t len = boost::size(s0);
    113. 

  113.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    114. 

  114.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    115. 

  115.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    116. 

  116.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    117. 

  117.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    118. 

  118.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    119. 

  119.         typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
    120. 

  120.         #pragma omp parallel for schedule(runtime)
    121. 

  121.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each7( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , op );
    122. 

  122.     }
    123. 

  123.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class Op > static void for_each8 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , Op op ) {
    124. 

  124.         const size_t len = boost::size(s0);
    125. 

  125.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    126. 

  126.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    127. 

  127.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    128. 

  128.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    129. 

  129.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    130. 

  130.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    131. 

  131.         typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
    132. 

  132.         typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
    133. 

  133.         #pragma omp parallel for schedule(runtime)
    134. 

  134.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each8( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , op );
    135. 

  135.     }
    136. 

  136.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class Op > static void for_each9 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , Op op ) {
    137. 

  137.         const size_t len = boost::size(s0);
    138. 

  138.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    139. 

  139.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    140. 

  140.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    141. 

  141.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    142. 

  142.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    143. 

  143.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    144. 

  144.         typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
    145. 

  145.         typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
    146. 

  146.         typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
    147. 

  147.         #pragma omp parallel for schedule(runtime)
    148. 

  148.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each9( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , op );
    149. 

  149.     }
    150. 

  150.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class Op > static void for_each10 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , Op op ) {
    151. 

  151.         const size_t len = boost::size(s0);
    152. 

  152.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    153. 

  153.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    154. 

  154.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    155. 

  155.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    156. 

  156.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    157. 

  157.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    158. 

  158.         typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
    159. 

  159.         typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
    160. 

  160.         typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
    161. 

  161.         typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
    162. 

  162.         #pragma omp parallel for schedule(runtime)
    163. 

  163.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each10( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , op );
    164. 

  164.     }
    165. 

  165.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class Op > static void for_each11 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , Op op ) {
    166. 

  166.         const size_t len = boost::size(s0);
    167. 

  167.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    168. 

  168.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    169. 

  169.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    170. 

  170.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    171. 

  171.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    172. 

  172.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    173. 

  173.         typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
    174. 

  174.         typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
    175. 

  175.         typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
    176. 

  176.         typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
    177. 

  177.         typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
    178. 

  178.         #pragma omp parallel for schedule(runtime)
    179. 

  179.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each11( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , op );
    180. 

  180.     }
    181. 

  181.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class Op > static void for_each12 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , Op op ) {
    182. 

  182.         const size_t len = boost::size(s0);
    183. 

  183.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    184. 

  184.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    185. 

  185.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    186. 

  186.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    187. 

  187.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    188. 

  188.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    189. 

  189.         typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
    190. 

  190.         typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
    191. 

  191.         typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
    192. 

  192.         typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
    193. 

  193.         typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
    194. 

  194.         typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
    195. 

  195.         #pragma omp parallel for schedule(runtime)
    196. 

  196.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each12( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , op );
    197. 

  197.     }
    198. 

  198.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class Op > static void for_each13 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , Op op ) {
    199. 

  199.         const size_t len = boost::size(s0);
    200. 

  200.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    201. 

  201.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    202. 

  202.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    203. 

  203.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    204. 

  204.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    205. 

  205.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    206. 

  206.         typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
    207. 

  207.         typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
    208. 

  208.         typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
    209. 

  209.         typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
    210. 

  210.         typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
    211. 

  211.         typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
    212. 

  212.         typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
    213. 

  213.         #pragma omp parallel for schedule(runtime)
    214. 

  214.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each13( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , op );
    215. 

  215.     }
    216. 

  216.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class Op > static void for_each14 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , Op op ) {
    217. 

  217.         const size_t len = boost::size(s0);
    218. 

  218.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    219. 

  219.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    220. 

  220.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    221. 

  221.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    222. 

  222.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    223. 

  223.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    224. 

  224.         typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
    225. 

  225.         typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
    226. 

  226.         typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
    227. 

  227.         typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
    228. 

  228.         typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
    229. 

  229.         typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
    230. 

  230.         typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
    231. 

  231.         typename boost::range_iterator<S13>::type beg13 = boost::begin(s13);
    232. 

  232.         #pragma omp parallel for schedule(runtime)
    233. 

  233.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each14( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] , op );
    234. 

  234.     }
    235. 

  235.     template< class S0 , class S1 , class S2 , class S3 , class S4 , class S5 , class S6 , class S7 , class S8 , class S9 , class S10 , class S11 , class S12 , class S13 , class S14 , class Op > static void for_each15 ( S0 &s0 , S1 &s1 , S2 &s2 , S3 &s3 , S4 &s4 , S5 &s5 , S6 &s6 , S7 &s7 , S8 &s8 , S9 &s9 , S10 &s10 , S11 &s11 , S12 &s12 , S13 &s13 , S14 &s14 , Op op ) {
    236. 

  236.         const size_t len = boost::size(s0);
    237. 

  237.         typename boost::range_iterator<S0>::type beg0 = boost::begin(s0);
    238. 

  238.         typename boost::range_iterator<S1>::type beg1 = boost::begin(s1);
    239. 

  239.         typename boost::range_iterator<S2>::type beg2 = boost::begin(s2);
    240. 

  240.         typename boost::range_iterator<S3>::type beg3 = boost::begin(s3);
    241. 

  241.         typename boost::range_iterator<S4>::type beg4 = boost::begin(s4);
    242. 

  242.         typename boost::range_iterator<S5>::type beg5 = boost::begin(s5);
    243. 

  243.         typename boost::range_iterator<S6>::type beg6 = boost::begin(s6);
    244. 

  244.         typename boost::range_iterator<S7>::type beg7 = boost::begin(s7);
    245. 

  245.         typename boost::range_iterator<S8>::type beg8 = boost::begin(s8);
    246. 

  246.         typename boost::range_iterator<S9>::type beg9 = boost::begin(s9);
    247. 

  247.         typename boost::range_iterator<S10>::type beg10 = boost::begin(s10);
    248. 

  248.         typename boost::range_iterator<S11>::type beg11 = boost::begin(s11);
    249. 

  249.         typename boost::range_iterator<S12>::type beg12 = boost::begin(s12);
    250. 

  250.         typename boost::range_iterator<S13>::type beg13 = boost::begin(s13);
    251. 

  251.         typename boost::range_iterator<S14>::type beg14 = boost::begin(s14);
    252. 

  252.         #pragma omp parallel for schedule(runtime)
    253. 

  253.         for( size_t i = 0 ; i < len ; i++ ) InnerAlgebra::for_each15( beg0 [i] , beg1 [i] , beg2 [i] , beg3 [i] , beg4 [i] , beg5 [i] , beg6 [i] , beg7 [i] , beg8 [i] , beg9 [i] , beg10 [i] , beg11 [i] , beg12 [i] , beg13 [i] , beg14 [i] , op );
    254. 

  254.     }
    255. 

  255. 

  256. #endif
    257. 

  257. 

  258. 

  259.     template< class NestedState >
    260. 

  260.     static typename norm_result_type< typename NestedState::value_type >::type norm_inf( const NestedState &s )
    261. 

  261.     {
    262. 

  262.         typedef typename boost::range_iterator<const NestedState>::type iterator;
    263. 

  263.         typedef typename std::iterator_traits<iterator>::value_type value_type;
    264. 

  264.         typedef typename norm_result_type<value_type>::type result_type;
    265. 

  265.         result_type init = static_cast< result_type >( 0 );
    266. 

  266.         const size_t len = boost::size(s);
    267. 

  267.         iterator beg = boost::begin(s);
    268. 

  268. #       pragma omp parallel for reduction(max: init) schedule(dynamic)
    269. 

  269.         for( size_t i = 0 ; i < len ; i++ )
    270. 

  270.             init = (std::max)( init , InnerAlgebra::norm_inf( beg[i] ) );
    271. 

  271.         return init;
    272. 

  272.     }
    273. 

  273. 

  274. };
    275. 

  275. 

  276. 

  277. }
    278. 

  278. }
    279. 

  279. }
    280. 

  280. 

  281. #endif
    282.