|
phdMesh Version of the Day
|
|
phdMesh Version of the Day
|
00001 /*------------------------------------------------------------------------*/ 00002 /* phdMesh : Parallel Heterogneous Dynamic unstructured Mesh */ 00003 /* Copyright (2008) Sandia Corporation */ 00004 /* */ 00005 /* Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive */ 00006 /* license for use of this work by or on behalf of the U.S. Government. */ 00007 /* */ 00008 /* This library is free software; you can redistribute it and/or modify */ 00009 /* it under the terms of the GNU Lesser General Public License as */ 00010 /* published by the Free Software Foundation; either version 2.1 of the */ 00011 /* License, or (at your option) any later version. */ 00012 /* */ 00013 /* This library is distributed in the hope that it will be useful, */ 00014 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ 00015 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU */ 00016 /* Lesser General Public License for more details. */ 00017 /* */ 00018 /* You should have received a copy of the GNU Lesser General Public */ 00019 /* License along with this library; if not, write to the Free Software */ 00020 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ 00021 /* USA */ 00022 /*------------------------------------------------------------------------*/ 00028 #ifndef util_ArrayPrivate_hpp 00029 #define util_ArrayPrivate_hpp 00030 00031 namespace phdmesh { 00032 00033 //---------------------------------------------------------------------- 00034 00040 unsigned array_stride_size( 00041 const unsigned rank , 00042 const unsigned * const stride ); 00043 00045 void array_stride_to_natural_dimensions( 00046 const unsigned rank , 00047 const unsigned * const stride , 00048 unsigned * const dim ); 00049 00051 void array_stride_to_natural_indices( 00052 const unsigned rank , 00053 const unsigned * const stride , 00054 const unsigned offset , 00055 unsigned * const indices ); 00056 00057 00058 //---------------------------------------------------------------------- 00059 00060 #ifndef DOXYGEN_COMPILE 00061 00062 void array_check_rank( const unsigned rank , 00063 const unsigned test_rank ); 00064 00065 void array_check_ordinal( const unsigned rank , 00066 const unsigned test_ordinal ); 00067 00068 void array_check_index( const unsigned dim , 00069 const unsigned index ); 00070 00071 void array_check_offset( const unsigned size , 00072 const unsigned test_offset ); 00073 00074 void array_check_indices( const bool , 00075 const unsigned rank , 00076 const unsigned * const stride , 00077 const unsigned = 0 , 00078 const unsigned = 0 , 00079 const unsigned = 0 , 00080 const unsigned = 0 , 00081 const unsigned = 0 , 00082 const unsigned = 0 , 00083 const unsigned = 0 , 00084 const unsigned = 0 ); 00085 00086 //---------------------------------------------------------------------- 00087 00088 template< unsigned , unsigned > struct array_check_ordinal_is_less ; 00089 00090 template<> struct array_check_ordinal_is_less<0,8> {}; 00091 template<> struct array_check_ordinal_is_less<1,8> {}; 00092 template<> struct array_check_ordinal_is_less<2,8> {}; 00093 template<> struct array_check_ordinal_is_less<3,8> {}; 00094 template<> struct array_check_ordinal_is_less<4,8> {}; 00095 template<> struct array_check_ordinal_is_less<5,8> {}; 00096 template<> struct array_check_ordinal_is_less<6,8> {}; 00097 template<> struct array_check_ordinal_is_less<7,8> {}; 00098 00099 template<> struct array_check_ordinal_is_less<0,7> {}; 00100 template<> struct array_check_ordinal_is_less<1,7> {}; 00101 template<> struct array_check_ordinal_is_less<2,7> {}; 00102 template<> struct array_check_ordinal_is_less<3,7> {}; 00103 template<> struct array_check_ordinal_is_less<4,7> {}; 00104 template<> struct array_check_ordinal_is_less<5,7> {}; 00105 template<> struct array_check_ordinal_is_less<6,7> {}; 00106 00107 template<> struct array_check_ordinal_is_less<0,6> {}; 00108 template<> struct array_check_ordinal_is_less<1,6> {}; 00109 template<> struct array_check_ordinal_is_less<2,6> {}; 00110 template<> struct array_check_ordinal_is_less<3,6> {}; 00111 template<> struct array_check_ordinal_is_less<4,6> {}; 00112 template<> struct array_check_ordinal_is_less<5,6> {}; 00113 00114 template<> struct array_check_ordinal_is_less<0,5> {}; 00115 template<> struct array_check_ordinal_is_less<1,5> {}; 00116 template<> struct array_check_ordinal_is_less<2,5> {}; 00117 template<> struct array_check_ordinal_is_less<3,5> {}; 00118 template<> struct array_check_ordinal_is_less<4,5> {}; 00119 00120 template<> struct array_check_ordinal_is_less<0,4> {}; 00121 template<> struct array_check_ordinal_is_less<1,4> {}; 00122 template<> struct array_check_ordinal_is_less<2,4> {}; 00123 template<> struct array_check_ordinal_is_less<3,4> {}; 00124 00125 template<> struct array_check_ordinal_is_less<0,3> {}; 00126 template<> struct array_check_ordinal_is_less<1,3> {}; 00127 template<> struct array_check_ordinal_is_less<2,3> {}; 00128 00129 template<> struct array_check_ordinal_is_less<0,2> {}; 00130 template<> struct array_check_ordinal_is_less<1,2> {}; 00131 00132 template<> struct array_check_ordinal_is_less<0,1> {}; 00133 00134 //---------------------------------------------------------------------- 00135 00136 template< class , unsigned > struct ArrayTagAt ; 00137 00138 template< typename Scalar , ArrayOrder order , 00139 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00140 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00141 struct ArrayTagAt<Array<Scalar,order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>,0> 00142 { typedef Tag1 type ; }; 00143 00144 template< typename Scalar , ArrayOrder order , 00145 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00146 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00147 struct ArrayTagAt<Array<Scalar,order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>,1> 00148 { typedef Tag2 type ; }; 00149 00150 template< typename Scalar , ArrayOrder order , 00151 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00152 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00153 struct ArrayTagAt<Array<Scalar,order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>,2> 00154 { typedef Tag3 type ; }; 00155 00156 template< typename Scalar , ArrayOrder order , 00157 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00158 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00159 struct ArrayTagAt<Array<Scalar,order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>,3> 00160 { typedef Tag4 type ; }; 00161 00162 template< typename Scalar , ArrayOrder order , 00163 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00164 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00165 struct ArrayTagAt<Array<Scalar,order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>,4> 00166 { typedef Tag5 type ; }; 00167 00168 template< typename Scalar , ArrayOrder order , 00169 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00170 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00171 struct ArrayTagAt<Array<Scalar,order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>,5> 00172 { typedef Tag6 type ; }; 00173 00174 template< typename Scalar , ArrayOrder order , 00175 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00176 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00177 struct ArrayTagAt<Array<Scalar,order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>,6> 00178 { typedef Tag7 type ; }; 00179 00180 template< typename Scalar , ArrayOrder order , 00181 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00182 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00183 struct ArrayTagAt<Array<Scalar,order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>,7> 00184 { typedef Tag8 type ; }; 00185 00186 //---------------------------------------------------------------------- 00187 //---------------------------------------------------------------------- 00188 00189 template< typename Scalar , 00190 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00191 class Tag5 , class Tag6 , class Tag7 , class TApp > 00192 struct ArrayAppend< 00193 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,void> , TApp > 00194 { 00195 typedef 00196 Array<Scalar,NaturalOrder,TApp,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7> type ; 00197 }; 00198 00199 template< typename Scalar , 00200 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00201 class Tag5 , class Tag6 , class Tag7 , class TApp > 00202 struct ArrayAppend< 00203 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,void> , TApp > 00204 { 00205 typedef 00206 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,TApp> type ; 00207 }; 00208 00209 template< typename Scalar , 00210 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00211 class Tag5 , class Tag6 , class TApp > 00212 struct ArrayAppend< 00213 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,void,void> , TApp > 00214 { 00215 typedef 00216 Array<Scalar,NaturalOrder,TApp,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,void> type ; 00217 }; 00218 00219 template< typename Scalar , 00220 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00221 class Tag5 , class Tag6 , class TApp > 00222 struct ArrayAppend< 00223 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,void,void> , TApp > 00224 { 00225 typedef 00226 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,TApp,void> type ; 00227 }; 00228 00229 template< typename Scalar , 00230 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00231 class Tag5 , class TApp > 00232 struct ArrayAppend< 00233 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,void,void,void> , TApp > 00234 { 00235 typedef 00236 Array<Scalar,NaturalOrder,TApp,Tag1,Tag2,Tag3,Tag4,Tag5,void,void> type ; 00237 }; 00238 00239 template< typename Scalar , 00240 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00241 class Tag5 , class TApp > 00242 struct ArrayAppend< 00243 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,void,void,void> , TApp > 00244 { 00245 typedef 00246 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,TApp,void,void> type ; 00247 }; 00248 00249 template< typename Scalar , 00250 class Tag1 , class Tag2 , class Tag3 , class Tag4 , class TApp > 00251 struct ArrayAppend< 00252 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,void,void,void,void> , TApp > 00253 { 00254 typedef 00255 Array<Scalar,NaturalOrder,TApp,Tag1,Tag2,Tag3,Tag4,void,void,void> type ; 00256 }; 00257 00258 template< typename Scalar , 00259 class Tag1 , class Tag2 , class Tag3 , class Tag4 , class TApp > 00260 struct ArrayAppend< 00261 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,void,void,void,void> , TApp > 00262 { 00263 typedef 00264 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,TApp,void,void,void> type ; 00265 }; 00266 00267 template< typename Scalar , 00268 class Tag1 , class Tag2 , class Tag3 , class TApp > 00269 struct ArrayAppend< 00270 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,void,void,void,void,void> , TApp > 00271 { 00272 typedef 00273 Array<Scalar,NaturalOrder,TApp,Tag1,Tag2,Tag3,void,void,void,void> type ; 00274 }; 00275 00276 template< typename Scalar , 00277 class Tag1 , class Tag2 , class Tag3 , class TApp > 00278 struct ArrayAppend< 00279 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,void,void,void,void,void> , TApp > 00280 { 00281 typedef 00282 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,TApp,void,void,void,void> type ; 00283 }; 00284 00285 template< typename Scalar , class Tag1 , class Tag2 , class TApp > 00286 struct ArrayAppend< 00287 Array<Scalar,NaturalOrder,Tag1,Tag2,void,void,void,void,void,void> , TApp > 00288 { 00289 typedef 00290 Array<Scalar,NaturalOrder,TApp,Tag1,Tag2,void,void,void,void,void> type ; 00291 }; 00292 00293 template< typename Scalar , class Tag1 , class Tag2 , class TApp > 00294 struct ArrayAppend< 00295 Array<Scalar,FortranOrder,Tag1,Tag2,void,void,void,void,void,void> , TApp > 00296 { 00297 typedef 00298 Array<Scalar,FortranOrder,Tag1,Tag2,TApp,void,void,void,void,void> type ; 00299 }; 00300 00301 template< typename Scalar , class Tag1 , class TApp > 00302 struct ArrayAppend< 00303 Array<Scalar,NaturalOrder,Tag1,void,void,void,void,void,void,void> , TApp > 00304 { 00305 typedef 00306 Array<Scalar,NaturalOrder,TApp,Tag1,void,void,void,void,void,void> type ; 00307 }; 00308 00309 template< typename Scalar , class Tag1 , class TApp > 00310 struct ArrayAppend< 00311 Array<Scalar,FortranOrder,Tag1,void,void,void,void,void,void,void> , TApp > 00312 { 00313 typedef 00314 Array<Scalar,FortranOrder,Tag1,TApp,void,void,void,void,void,void> type ; 00315 }; 00316 00317 template< typename Scalar , class TApp > 00318 struct ArrayAppend< 00319 Array<Scalar,RankZero,void,void,void,void,void,void,void,void> , TApp > 00320 { 00321 typedef 00322 Array<Scalar,NaturalOrder,TApp,void,void,void,void,void,void,void> type ; 00323 }; 00324 00325 template< typename Scalar , class TApp > 00326 struct ArrayAppend< 00327 Array<Scalar,NaturalOrder,void,void,void,void,void,void,void,void> , TApp > 00328 { /* Cannot append to runtime-ranked array */ }; 00329 00330 template< typename Scalar , class TApp > 00331 struct ArrayAppend< 00332 Array<Scalar,FortranOrder,void,void,void,void,void,void,void,void> , TApp > 00333 { /* Cannot append to runtime-ranked array */ }; 00334 00335 //---------------------------------------------------------------------- 00336 //---------------------------------------------------------------------- 00337 00338 template< class A > struct ArrayReverse ; 00339 00340 template< typename Scalar , 00341 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00342 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00343 struct ArrayReverse< 00344 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8> > 00345 { 00346 typedef 00347 Array<Scalar,FortranOrder,Tag8,Tag7,Tag6,Tag5,Tag4,Tag3,Tag2,Tag1> type ; 00348 }; 00349 00350 template< typename Scalar , 00351 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00352 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00353 struct ArrayReverse< 00354 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8> > 00355 { 00356 typedef 00357 Array<Scalar,NaturalOrder,Tag8,Tag7,Tag6,Tag5,Tag4,Tag3,Tag2,Tag1> type ; 00358 }; 00359 00360 00361 template< typename Scalar , 00362 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00363 class Tag5 , class Tag6 , class Tag7 > 00364 struct ArrayReverse< 00365 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,void> > 00366 { 00367 typedef 00368 Array<Scalar,FortranOrder,Tag7,Tag6,Tag5,Tag4,Tag3,Tag2,Tag1,void> type ; 00369 }; 00370 00371 template< typename Scalar , 00372 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00373 class Tag5 , class Tag6 , class Tag7 > 00374 struct ArrayReverse< 00375 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,void> > 00376 { 00377 typedef 00378 Array<Scalar,NaturalOrder,Tag7,Tag6,Tag5,Tag4,Tag3,Tag2,Tag1,void> type ; 00379 }; 00380 00381 00382 template< typename Scalar , 00383 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00384 class Tag5 , class Tag6 > 00385 struct ArrayReverse< 00386 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,void,void> > 00387 { 00388 typedef 00389 Array<Scalar,FortranOrder,Tag6,Tag5,Tag4,Tag3,Tag2,Tag1,void,void> type ; 00390 }; 00391 00392 template< typename Scalar , 00393 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00394 class Tag5 , class Tag6 > 00395 struct ArrayReverse< 00396 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,void,void> > 00397 { 00398 typedef 00399 Array<Scalar,NaturalOrder,Tag6,Tag5,Tag4,Tag3,Tag2,Tag1,void,void> type ; 00400 }; 00401 00402 00403 template< typename Scalar , 00404 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00405 class Tag5 > 00406 struct ArrayReverse< 00407 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,void,void,void> > 00408 { 00409 typedef 00410 Array<Scalar,FortranOrder,Tag5,Tag4,Tag3,Tag2,Tag1,void,void,void> type ; 00411 }; 00412 00413 template< typename Scalar , 00414 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00415 class Tag5 > 00416 struct ArrayReverse< 00417 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,void,void,void> > 00418 { 00419 typedef 00420 Array<Scalar,NaturalOrder,Tag5,Tag4,Tag3,Tag2,Tag1,void,void,void> type ; 00421 }; 00422 00423 00424 template< typename Scalar , 00425 class Tag1 , class Tag2 , class Tag3 , class Tag4 > 00426 struct ArrayReverse< 00427 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,void,void,void,void> > 00428 { 00429 typedef 00430 Array<Scalar,FortranOrder,Tag4,Tag3,Tag2,Tag1,void,void,void,void> type ; 00431 }; 00432 00433 template< typename Scalar , 00434 class Tag1 , class Tag2 , class Tag3 , class Tag4 > 00435 struct ArrayReverse< 00436 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,void,void,void,void> > 00437 { 00438 typedef 00439 Array<Scalar,NaturalOrder,Tag4,Tag3,Tag2,Tag1,void,void,void,void> type ; 00440 }; 00441 00442 00443 template< typename Scalar , class Tag1 , class Tag2 , class Tag3 > 00444 struct ArrayReverse< 00445 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,void,void,void,void,void> > 00446 { 00447 typedef 00448 Array<Scalar,FortranOrder,Tag3,Tag2,Tag1,void,void,void,void,void> type ; 00449 }; 00450 00451 template< typename Scalar , class Tag1 , class Tag2 , class Tag3 > 00452 struct ArrayReverse< 00453 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,void,void,void,void,void> > 00454 { 00455 typedef 00456 Array<Scalar,NaturalOrder,Tag3,Tag2,Tag1,void,void,void,void,void> type ; 00457 }; 00458 00459 00460 template< typename Scalar , class Tag1 , class Tag2 > 00461 struct ArrayReverse< 00462 Array<Scalar,NaturalOrder,Tag1,Tag2,void,void,void,void,void,void> > 00463 { 00464 typedef 00465 Array<Scalar,FortranOrder,Tag2,Tag1,void,void,void,void,void,void> type ; 00466 }; 00467 00468 template< typename Scalar , class Tag1 , class Tag2 > 00469 struct ArrayReverse< 00470 Array<Scalar,FortranOrder,Tag1,Tag2,void,void,void,void,void,void> > 00471 { 00472 typedef 00473 Array<Scalar,NaturalOrder,Tag2,Tag1,void,void,void,void,void,void> type ; 00474 }; 00475 00476 00477 template< typename Scalar , class Tag1 > 00478 struct ArrayReverse< 00479 Array<Scalar,NaturalOrder,Tag1,void,void,void,void,void,void,void> > 00480 { 00481 typedef 00482 Array<Scalar,FortranOrder,Tag1,void,void,void,void,void,void,void> type ; 00483 }; 00484 00485 template< typename Scalar , class Tag1 > 00486 struct ArrayReverse< 00487 Array<Scalar,FortranOrder,Tag1,void,void,void,void,void,void,void> > 00488 { 00489 typedef 00490 Array<Scalar,NaturalOrder,Tag1,void,void,void,void,void,void,void> type ; 00491 }; 00492 00493 00494 template< typename Scalar > 00495 struct ArrayReverse< 00496 Array<Scalar,NaturalOrder,void,void,void,void,void,void,void,void> > 00497 { 00498 typedef 00499 Array<Scalar,FortranOrder,void,void,void,void,void,void,void,void> type ; 00500 }; 00501 00502 template< typename Scalar > 00503 struct ArrayReverse< 00504 Array<Scalar,FortranOrder,void,void,void,void,void,void,void,void> > 00505 { 00506 typedef 00507 Array<Scalar,NaturalOrder,void,void,void,void,void,void,void,void> type ; 00508 }; 00509 00510 00511 //---------------------------------------------------------------------- 00512 //---------------------------------------------------------------------- 00513 00514 template< class A > struct ArrayTruncate ; 00515 00516 template< typename Scalar , 00517 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00518 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00519 struct ArrayTruncate< 00520 Array<Scalar,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8> > 00521 { 00522 typedef 00523 Array<Scalar,NaturalOrder,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8,void> type ; 00524 }; 00525 00526 template< typename Scalar , class Tag1 > 00527 struct ArrayTruncate< 00528 Array<Scalar,NaturalOrder,Tag1,void,void,void,void,void,void,void> > 00529 { 00530 typedef Array<Scalar,RankZero,void,void,void,void,void,void,void,void> type ; 00531 }; 00532 00533 template< typename Scalar , class Tag1 > 00534 struct ArrayTruncate< 00535 Array<Scalar,FortranOrder,Tag1,void,void,void,void,void,void,void> > 00536 { 00537 typedef Array<Scalar,RankZero,void,void,void,void,void,void,void,void> type ; 00538 }; 00539 00540 template< typename Scalar , class Tag1 , class Tag2 > 00541 struct ArrayTruncate< 00542 Array<Scalar,FortranOrder,Tag1,Tag2,void,void,void,void,void,void> > 00543 { 00544 typedef 00545 Array<Scalar,FortranOrder,Tag1,void,void,void,void,void,void,void> type ; 00546 }; 00547 00548 template< typename Scalar , class Tag1 , class Tag2 , class Tag3 > 00549 struct ArrayTruncate< 00550 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,void,void,void,void,void> > 00551 { 00552 typedef 00553 Array<Scalar,FortranOrder,Tag1,Tag2,void,void,void,void,void,void> type ; 00554 }; 00555 00556 template< typename Scalar , 00557 class Tag1 , class Tag2 , class Tag3 , class Tag4 > 00558 struct ArrayTruncate< 00559 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,void,void,void,void> > 00560 { 00561 typedef 00562 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,void,void,void,void,void> type ; 00563 }; 00564 00565 template< typename Scalar , 00566 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00567 class Tag5 > 00568 struct ArrayTruncate< 00569 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,void,void,void> > 00570 { 00571 typedef 00572 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,void,void,void,void> type ; 00573 }; 00574 00575 template< typename Scalar , 00576 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00577 class Tag5 , class Tag6 > 00578 struct ArrayTruncate< 00579 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,void,void> > 00580 { 00581 typedef 00582 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,void,void,void> type ; 00583 }; 00584 00585 template< typename Scalar , 00586 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00587 class Tag5 , class Tag6 , class Tag7 > 00588 struct ArrayTruncate< 00589 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,void> > 00590 { 00591 typedef 00592 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,void,void> type ; 00593 }; 00594 00595 template< typename Scalar , 00596 class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00597 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00598 struct ArrayTruncate< 00599 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8> > 00600 { 00601 typedef 00602 Array<Scalar,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,void> type ; 00603 }; 00604 00605 //---------------------------------------------------------------------- 00606 //---------------------------------------------------------------------- 00607 00608 template< ArrayOrder , unsigned Rank , unsigned Ordinal = 0 > 00609 struct ArrayStrideDim ; 00610 00611 template< unsigned Rank , unsigned Ordinal > 00612 struct ArrayStrideDim<RankZero,Rank,Ordinal> { 00613 00614 static unsigned dimension( const unsigned * ) 00615 { return 0 ; } 00616 00617 static unsigned dimension( const unsigned * , const unsigned & ) 00618 { return 0 ; } 00619 }; 00620 00621 template< unsigned Rank > 00622 struct ArrayStrideDim<FortranOrder,Rank,0> { 00623 static unsigned dimension( const unsigned * stride ) 00624 { return stride[0]; } 00625 00626 static unsigned dimension( const unsigned * stride , 00627 const unsigned & ordinal ) 00628 { return ordinal ? stride[ordinal] / stride[ordinal-1] : stride[0] ; } 00629 }; 00630 00631 template< unsigned Rank > 00632 struct ArrayStrideDim<NaturalOrder,Rank,0> { 00633 static unsigned dimension( const unsigned * stride ) { return stride[0]; } 00634 00635 static unsigned dimension( const unsigned * stride , 00636 const unsigned & ordinal ) 00637 { 00638 const unsigned i = ( Rank - 1 ) - ordinal ; 00639 return i ? stride[i] / stride[i-1] : stride[0] ; 00640 } 00641 }; 00642 00643 template< unsigned Rank , unsigned Ordinal > 00644 struct ArrayStrideDim<FortranOrder,Rank,Ordinal> { 00645 static unsigned dimension( const unsigned * stride ) 00646 { return stride[Ordinal] / stride[Ordinal-1]; } 00647 }; 00648 00649 template< unsigned Rank , unsigned Ordinal > 00650 struct ArrayStrideDim<NaturalOrder,Rank,Ordinal> { 00651 static unsigned dimension( const unsigned * stride ) 00652 { 00653 enum { I = ( Rank - 1 ) - Ordinal }; 00654 return stride[I] / stride[I-1]; 00655 } 00656 }; 00657 00658 //---------------------------------------------------------------------- 00659 00660 namespace { 00661 00662 template< class Tag > const ArrayDimTag * array_dim_tag(); 00663 00664 template<> 00665 inline 00666 const ArrayDimTag * array_dim_tag<void>() { return NULL ; } 00667 00668 template< class Tag > 00669 inline 00670 const ArrayDimTag * array_dim_tag() { return & Tag::tag(); } 00671 00672 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00673 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00674 const ArrayDimTag * const * array_dim_tags() 00675 { 00676 static const ArrayDimTag * t[8] = 00677 { 00678 array_dim_tag< Tag1 >() , 00679 array_dim_tag< Tag2 >() , 00680 array_dim_tag< Tag3 >() , 00681 array_dim_tag< Tag4 >() , 00682 array_dim_tag< Tag5 >() , 00683 array_dim_tag< Tag6 >() , 00684 array_dim_tag< Tag7 >() , 00685 array_dim_tag< Tag8 >() 00686 }; 00687 00688 return t ; 00689 } 00690 00691 } 00692 00693 //---------------------------------------------------------------------- 00694 00695 template< ArrayOrder array_order , unsigned rank > 00696 unsigned array_offset( 00697 const unsigned * const , 00698 const unsigned & i1 , const unsigned & i2 , 00699 const unsigned & i3 , const unsigned & i4 , 00700 const unsigned & i5 , const unsigned & i6 , 00701 const unsigned & i7 , const unsigned & i8 ); 00702 00703 template< ArrayOrder array_order , unsigned rank > 00704 unsigned array_offset( 00705 const unsigned * const , 00706 const unsigned & i1 , const unsigned & i2 , 00707 const unsigned & i3 , const unsigned & i4 , 00708 const unsigned & i5 , const unsigned & i6 , 00709 const unsigned & i7 ); 00710 00711 template< ArrayOrder array_order , unsigned rank > 00712 unsigned array_offset( 00713 const unsigned * const , 00714 const unsigned & i1 , const unsigned & i2 , 00715 const unsigned & i3 , const unsigned & i4 , 00716 const unsigned & i5 , const unsigned & i6 ); 00717 00718 template< ArrayOrder array_order , unsigned rank > 00719 unsigned array_offset( 00720 const unsigned * const , 00721 const unsigned & i1 , const unsigned & i2 , 00722 const unsigned & i3 , const unsigned & i4 , 00723 const unsigned & i5 ); 00724 00725 template< ArrayOrder array_order , unsigned rank > 00726 unsigned array_offset( 00727 const unsigned * const , 00728 const unsigned & i1 , const unsigned & i2 , 00729 const unsigned & i3 , const unsigned & i4 ); 00730 00731 template< ArrayOrder array_order , unsigned rank > 00732 unsigned array_offset( 00733 const unsigned * const , 00734 const unsigned & i1 , const unsigned & i2 , 00735 const unsigned & i3 ); 00736 00737 template< ArrayOrder array_order , unsigned rank > 00738 unsigned array_offset( 00739 const unsigned * const , 00740 const unsigned & i1 , const unsigned & i2 ); 00741 00742 template< ArrayOrder array_order , unsigned rank > 00743 unsigned array_offset( 00744 const unsigned * const , 00745 const unsigned & i1 ); 00746 00747 //---------------------------------------------------------------------- 00748 00749 template<> inline 00750 unsigned array_offset<FortranOrder,8>( 00751 const unsigned * const stride , 00752 const unsigned & i1 , const unsigned & i2 , 00753 const unsigned & i3 , const unsigned & i4 , 00754 const unsigned & i5 , const unsigned & i6 , 00755 const unsigned & i7 , const unsigned & i8 ) 00756 { 00757 ARRAY_CHECK(array_check_indices(false,8,stride,i1,i2,i3,i4,i5,i6,i7,i8)); 00758 return i1 + i2 * stride[0] + 00759 i3 * stride[1] + i4 * stride[2] + 00760 i5 * stride[3] + i6 * stride[4] + 00761 i7 * stride[5] + i8 * stride[6] ; 00762 } 00763 00764 template<> inline 00765 unsigned array_offset<FortranOrder,7>( 00766 const unsigned * const stride , 00767 const unsigned & i1 , const unsigned & i2 , 00768 const unsigned & i3 , const unsigned & i4 , 00769 const unsigned & i5 , const unsigned & i6 , 00770 const unsigned & i7 ) 00771 { 00772 ARRAY_CHECK(array_check_indices(false,7,stride,i1,i2,i3,i4,i5,i6,i7)); 00773 return i1 + i2 * stride[0] + 00774 i3 * stride[1] + i4 * stride[2] + 00775 i5 * stride[3] + i6 * stride[4] + 00776 i7 * stride[5] ; 00777 } 00778 00779 template<> inline 00780 unsigned array_offset<FortranOrder,6>( 00781 const unsigned * const stride , 00782 const unsigned & i1 , const unsigned & i2 , 00783 const unsigned & i3 , const unsigned & i4 , 00784 const unsigned & i5 , const unsigned & i6 ) 00785 { 00786 ARRAY_CHECK(array_check_indices(false,6,stride,i1,i2,i3,i4,i5,i6)); 00787 return i1 + i2 * stride[0] + 00788 i3 * stride[1] + i4 * stride[2] + 00789 i5 * stride[3] + i6 * stride[4] ; 00790 } 00791 00792 template<> inline 00793 unsigned array_offset<FortranOrder,5>( 00794 const unsigned * const stride , 00795 const unsigned & i1 , const unsigned & i2 , 00796 const unsigned & i3 , const unsigned & i4 , 00797 const unsigned & i5 ) 00798 { 00799 ARRAY_CHECK(array_check_indices(false,5,stride,i1,i2,i3,i4,i5)); 00800 return i1 + i2 * stride[0] + 00801 i3 * stride[1] + i4 * stride[2] + 00802 i5 * stride[3] ; 00803 } 00804 00805 template<> inline 00806 unsigned array_offset<FortranOrder,4>( 00807 const unsigned * const stride , 00808 const unsigned & i1 , const unsigned & i2 , 00809 const unsigned & i3 , const unsigned & i4 ) 00810 { 00811 ARRAY_CHECK(array_check_indices(false,4,stride,i1,i2,i3,i4)); 00812 return i1 + i2 * stride[0] + 00813 i3 * stride[1] + i4 * stride[2] ; 00814 } 00815 00816 template<> inline 00817 unsigned array_offset<FortranOrder,3>( 00818 const unsigned * const stride , 00819 const unsigned & i1 , const unsigned & i2 , 00820 const unsigned & i3 ) 00821 { 00822 ARRAY_CHECK(array_check_indices(false,3,stride,i1,i2,i3)); 00823 return i1 + i2 * stride[0] + i3 * stride[1] ; 00824 } 00825 00826 template<> inline 00827 unsigned array_offset<FortranOrder,2>( 00828 const unsigned * const stride , 00829 const unsigned & i1 , const unsigned & i2 ) 00830 { 00831 ARRAY_CHECK(array_check_indices(false,2,stride,i1,i2)); 00832 return i1 + i2 * stride[0] ; 00833 } 00834 00835 template<> inline 00836 unsigned array_offset<FortranOrder,1>( 00837 const unsigned * const ARRAY_CHECK( stride ) , 00838 const unsigned & i1 ) 00839 { 00840 ARRAY_CHECK(array_check_indices(false,1,stride,i1)); 00841 return i1 ; 00842 } 00843 00844 //---------------------------------------------------------------------- 00845 00846 template<> inline 00847 unsigned array_offset<NaturalOrder,8>( 00848 const unsigned * const stride , 00849 const unsigned & i1 , const unsigned & i2 , 00850 const unsigned & i3 , const unsigned & i4 , 00851 const unsigned & i5 , const unsigned & i6 , 00852 const unsigned & i7 , const unsigned & i8 ) 00853 { 00854 ARRAY_CHECK(array_check_indices(true,8,stride,i1,i2,i3,i4,i5,i6,i7,i8)); 00855 return i8 + i7 * stride[0] + 00856 i6 * stride[1] + i5 * stride[2] + 00857 i4 * stride[3] + i3 * stride[4] + 00858 i2 * stride[5] + i1 * stride[6] ; 00859 } 00860 00861 template<> inline 00862 unsigned array_offset<NaturalOrder,7>( 00863 const unsigned * const stride , 00864 const unsigned & i1 , const unsigned & i2 , 00865 const unsigned & i3 , const unsigned & i4 , 00866 const unsigned & i5 , const unsigned & i6 , 00867 const unsigned & i7 ) 00868 { 00869 ARRAY_CHECK(array_check_indices(true,7,stride,i1,i2,i3,i4,i5,i6,i7)); 00870 return i7 + i6 * stride[0] + 00871 i5 * stride[1] + i4 * stride[2] + 00872 i3 * stride[3] + i2 * stride[4] + 00873 i1 * stride[5] ; 00874 } 00875 00876 template<> inline 00877 unsigned array_offset<NaturalOrder,6>( 00878 const unsigned * const stride , 00879 const unsigned & i1 , const unsigned & i2 , 00880 const unsigned & i3 , const unsigned & i4 , 00881 const unsigned & i5 , const unsigned & i6 ) 00882 { 00883 ARRAY_CHECK(array_check_indices(true,6,stride,i1,i2,i3,i4,i5,i6)); 00884 return i6 + i5 * stride[0] + 00885 i4 * stride[1] + i3 * stride[2] + 00886 i2 * stride[3] + i1 * stride[4] ; 00887 } 00888 00889 template<> inline 00890 unsigned array_offset<NaturalOrder,5>( 00891 const unsigned * const stride , 00892 const unsigned & i1 , const unsigned & i2 , 00893 const unsigned & i3 , const unsigned & i4 , 00894 const unsigned & i5 ) 00895 { 00896 ARRAY_CHECK(array_check_indices(true,5,stride,i1,i2,i3,i4,i5)); 00897 return i5 + i4 * stride[0] + 00898 i3 * stride[1] + i2 * stride[2] + 00899 i1 * stride[3] ; 00900 } 00901 00902 template<> inline 00903 unsigned array_offset<NaturalOrder,4>( 00904 const unsigned * const stride , 00905 const unsigned & i1 , const unsigned & i2 , 00906 const unsigned & i3 , const unsigned & i4 ) 00907 { 00908 ARRAY_CHECK(array_check_indices(true,4,stride,i1,i2,i3,i4)); 00909 return i4 + i3 * stride[0] + 00910 i2 * stride[1] + i1 * stride[2] ; 00911 } 00912 00913 template<> inline 00914 unsigned array_offset<NaturalOrder,3>( 00915 const unsigned * const stride , 00916 const unsigned & i1 , const unsigned & i2 , 00917 const unsigned & i3 ) 00918 { 00919 ARRAY_CHECK(array_check_indices(true,3,stride,i1,i2,i3)); 00920 return i3 + i2 * stride[0] + i1 * stride[1] ; 00921 } 00922 00923 template<> inline 00924 unsigned array_offset<NaturalOrder,2>( 00925 const unsigned * const stride , 00926 const unsigned & i1 , const unsigned & i2 ) 00927 { 00928 ARRAY_CHECK(array_check_indices(true,2,stride,i1,i2)); 00929 return i2 + i1 * stride[0] ; 00930 } 00931 00932 template<> inline 00933 unsigned array_offset<NaturalOrder,1>( 00934 const unsigned * const ARRAY_CHECK( stride ) , 00935 const unsigned & i1 ) 00936 { 00937 ARRAY_CHECK(array_check_indices(true,1,stride,i1)); 00938 return i1 ; 00939 } 00940 00941 //---------------------------------------------------------------------- 00942 00943 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 , 00944 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 00945 struct Array<void,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8> 00946 { 00947 enum { Rank = 8 }; 00948 00949 static void assign( unsigned * stride ) 00950 { 00951 stride[7] = Tag8::Size * ( 00952 stride[6] = Tag7::Size * ( 00953 stride[5] = Tag6::Size * ( 00954 stride[4] = Tag5::Size * ( 00955 stride[3] = Tag4::Size * ( 00956 stride[2] = Tag3::Size * ( 00957 stride[1] = Tag2::Size * ( 00958 stride[0] = Tag1::Size ))))))); 00959 } 00960 00961 static void assign( unsigned * stride , 00962 const unsigned & n8 ) 00963 { 00964 stride[7] = n8 * ( 00965 stride[6] = Tag7::Size * ( 00966 stride[5] = Tag6::Size * ( 00967 stride[4] = Tag5::Size * ( 00968 stride[3] = Tag4::Size * ( 00969 stride[2] = Tag3::Size * ( 00970 stride[1] = Tag2::Size * ( 00971 stride[0] = Tag1::Size ))))))); 00972 } 00973 00974 static void assign( unsigned * stride , 00975 const unsigned & n7 , 00976 const unsigned & n8 ) 00977 { 00978 stride[7] = n8 * ( 00979 stride[6] = n7 * ( 00980 stride[5] = Tag6::Size * ( 00981 stride[4] = Tag5::Size * ( 00982 stride[3] = Tag4::Size * ( 00983 stride[2] = Tag3::Size * ( 00984 stride[1] = Tag2::Size * ( 00985 stride[0] = Tag1::Size ))))))); 00986 } 00987 00988 static void assign( unsigned * stride , 00989 const unsigned & n6 , 00990 const unsigned & n7 , 00991 const unsigned & n8 ) 00992 { 00993 stride[7] = n8 * ( 00994 stride[6] = n7 * ( 00995 stride[5] = n6 * ( 00996 stride[4] = Tag5::Size * ( 00997 stride[3] = Tag4::Size * ( 00998 stride[2] = Tag3::Size * ( 00999 stride[1] = Tag2::Size * ( 01000 stride[0] = Tag1::Size ))))))); 01001 } 01002 01003 static void assign( unsigned * stride , 01004 const unsigned & n5 , 01005 const unsigned & n6 , 01006 const unsigned & n7 , 01007 const unsigned & n8 ) 01008 { 01009 stride[7] = n8 * ( 01010 stride[6] = n7 * ( 01011 stride[5] = n6 * ( 01012 stride[4] = n5 * ( 01013 stride[3] = Tag4::Size * ( 01014 stride[2] = Tag3::Size * ( 01015 stride[1] = Tag2::Size * ( 01016 stride[0] = Tag1::Size ))))))); 01017 } 01018 01019 static void assign( unsigned * stride , 01020 const unsigned & n4 , 01021 const unsigned & n5 , 01022 const unsigned & n6 , 01023 const unsigned & n7 , 01024 const unsigned & n8 ) 01025 { 01026 stride[7] = n8 * ( 01027 stride[6] = n7 * ( 01028 stride[5] = n6 * ( 01029 stride[4] = n5 * ( 01030 stride[3] = n4 * ( 01031 stride[2] = Tag3::Size * ( 01032 stride[1] = Tag2::Size * ( 01033 stride[0] = Tag1::Size ))))))); 01034 } 01035 01036 static void assign( unsigned * stride , 01037 const unsigned & n3 , 01038 const unsigned & n4 , 01039 const unsigned & n5 , 01040 const unsigned & n6 , 01041 const unsigned & n7 , 01042 const unsigned & n8 ) 01043 { 01044 stride[7] = n8 * ( 01045 stride[6] = n7 * ( 01046 stride[5] = n6 * ( 01047 stride[4] = n5 * ( 01048 stride[3] = n4 * ( 01049 stride[2] = n3 * ( 01050 stride[1] = Tag2::Size * ( 01051 stride[0] = Tag1::Size ))))))); 01052 } 01053 01054 static void assign( unsigned * stride , 01055 const unsigned & n2 , 01056 const unsigned & n3 , 01057 const unsigned & n4 , 01058 const unsigned & n5 , 01059 const unsigned & n6 , 01060 const unsigned & n7 , 01061 const unsigned & n8 ) 01062 { 01063 stride[7] = n8 * ( 01064 stride[6] = n7 * ( 01065 stride[5] = n6 * ( 01066 stride[4] = n5 * ( 01067 stride[3] = n4 * ( 01068 stride[2] = n3 * ( 01069 stride[1] = n2 * ( 01070 stride[0] = Tag1::Size ))))))); 01071 } 01072 01073 static void assign( unsigned * stride , 01074 const unsigned & n1 , 01075 const unsigned & n2 , 01076 const unsigned & n3 , 01077 const unsigned & n4 , 01078 const unsigned & n5 , 01079 const unsigned & n6 , 01080 const unsigned & n7 , 01081 const unsigned & n8 ) 01082 { 01083 stride[7] = n8 * ( 01084 stride[6] = n7 * ( 01085 stride[5] = n6 * ( 01086 stride[4] = n5 * ( 01087 stride[3] = n4 * ( 01088 stride[2] = n3 * ( 01089 stride[1] = n2 * ( 01090 stride[0] = n1 ))))))); 01091 } 01092 01093 static void assign( unsigned * stride , 01094 const unsigned * const dims ) 01095 { 01096 stride[7] = dims[7] * ( 01097 stride[6] = dims[6] * ( 01098 stride[5] = dims[5] * ( 01099 stride[4] = dims[4] * ( 01100 stride[3] = dims[3] * ( 01101 stride[2] = dims[2] * ( 01102 stride[1] = dims[1] * ( 01103 stride[0] = dims[0] ))))))); 01104 } 01105 }; 01106 01107 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 , 01108 class Tag5 , class Tag6 , class Tag7 > 01109 struct Array<void,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,void> 01110 { 01111 enum { Rank = 7 }; 01112 01113 static void assign( unsigned * stride ) 01114 { 01115 stride[6] = Tag7::Size * ( 01116 stride[5] = Tag6::Size * ( 01117 stride[4] = Tag5::Size * ( 01118 stride[3] = Tag4::Size * ( 01119 stride[2] = Tag3::Size * ( 01120 stride[1] = Tag2::Size * ( 01121 stride[0] = Tag1::Size )))))); 01122 } 01123 01124 static void assign( unsigned * stride , 01125 const unsigned & n7 ) 01126 { 01127 stride[6] = n7 * ( 01128 stride[5] = Tag6::Size * ( 01129 stride[4] = Tag5::Size * ( 01130 stride[3] = Tag4::Size * ( 01131 stride[2] = Tag3::Size * ( 01132 stride[1] = Tag2::Size * ( 01133 stride[0] = Tag1::Size )))))); 01134 } 01135 01136 static void assign( unsigned * stride , 01137 const unsigned & n6 , 01138 const unsigned & n7 ) 01139 { 01140 stride[6] = n7 * ( 01141 stride[5] = n6 * ( 01142 stride[4] = Tag5::Size * ( 01143 stride[3] = Tag4::Size * ( 01144 stride[2] = Tag3::Size * ( 01145 stride[1] = Tag2::Size * ( 01146 stride[0] = Tag1::Size )))))); 01147 } 01148 01149 static void assign( unsigned * stride , 01150 const unsigned & n5 , 01151 const unsigned & n6 , 01152 const unsigned & n7 ) 01153 { 01154 stride[6] = n7 * ( 01155 stride[5] = n6 * ( 01156 stride[4] = n5 * ( 01157 stride[3] = Tag4::Size * ( 01158 stride[2] = Tag3::Size * ( 01159 stride[1] = Tag2::Size * ( 01160 stride[0] = Tag1::Size )))))); 01161 } 01162 01163 static void assign( unsigned * stride , 01164 const unsigned & n4 , 01165 const unsigned & n5 , 01166 const unsigned & n6 , 01167 const unsigned & n7 ) 01168 { 01169 stride[6] = n7 * ( 01170 stride[5] = n6 * ( 01171 stride[4] = n5 * ( 01172 stride[3] = n4 * ( 01173 stride[2] = Tag3::Size * ( 01174 stride[1] = Tag2::Size * ( 01175 stride[0] = Tag1::Size )))))); 01176 } 01177 01178 static void assign( unsigned * stride , 01179 const unsigned & n3 , 01180 const unsigned & n4 , 01181 const unsigned & n5 , 01182 const unsigned & n6 , 01183 const unsigned & n7 ) 01184 { 01185 stride[6] = n7 * ( 01186 stride[5] = n6 * ( 01187 stride[4] = n5 * ( 01188 stride[3] = n4 * ( 01189 stride[2] = n3 * ( 01190 stride[1] = Tag2::Size * ( 01191 stride[0] = Tag1::Size )))))); 01192 } 01193 01194 static void assign( unsigned * stride , 01195 const unsigned & n2 , 01196 const unsigned & n3 , 01197 const unsigned & n4 , 01198 const unsigned & n5 , 01199 const unsigned & n6 , 01200 const unsigned & n7 ) 01201 { 01202 stride[6] = n7 * ( 01203 stride[5] = n6 * ( 01204 stride[4] = n5 * ( 01205 stride[3] = n4 * ( 01206 stride[2] = n3 * ( 01207 stride[1] = n2 * ( 01208 stride[0] = Tag1::Size )))))); 01209 } 01210 01211 static void assign( unsigned * stride , 01212 const unsigned & n1 , 01213 const unsigned & n2 , 01214 const unsigned & n3 , 01215 const unsigned & n4 , 01216 const unsigned & n5 , 01217 const unsigned & n6 , 01218 const unsigned & n7 ) 01219 { 01220 stride[6] = n7 * ( 01221 stride[5] = n6 * ( 01222 stride[4] = n5 * ( 01223 stride[3] = n4 * ( 01224 stride[2] = n3 * ( 01225 stride[1] = n2 * ( 01226 stride[0] = n1 )))))); 01227 } 01228 01229 static void assign( unsigned * stride , 01230 const unsigned * const dims ) 01231 { 01232 stride[6] = dims[6] * ( 01233 stride[5] = dims[5] * ( 01234 stride[4] = dims[4] * ( 01235 stride[3] = dims[3] * ( 01236 stride[2] = dims[2] * ( 01237 stride[1] = dims[1] * ( 01238 stride[0] = dims[0] )))))); 01239 } 01240 }; 01241 01242 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 , 01243 class Tag5 , class Tag6 > 01244 struct Array<void,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,void,void> 01245 { 01246 enum { Rank = 6 }; 01247 01248 static void assign( unsigned * stride ) 01249 { 01250 stride[5] = Tag6::Size * ( 01251 stride[4] = Tag5::Size * ( 01252 stride[3] = Tag4::Size * ( 01253 stride[2] = Tag3::Size * ( 01254 stride[1] = Tag2::Size * ( 01255 stride[0] = Tag1::Size ))))); 01256 } 01257 01258 static void assign( unsigned * stride , 01259 const unsigned & n6 ) 01260 { 01261 stride[5] = n6 * ( 01262 stride[4] = Tag5::Size * ( 01263 stride[3] = Tag4::Size * ( 01264 stride[2] = Tag3::Size * ( 01265 stride[1] = Tag2::Size * ( 01266 stride[0] = Tag1::Size ))))); 01267 } 01268 01269 static void assign( unsigned * stride , 01270 const unsigned & n5 , 01271 const unsigned & n6 ) 01272 { 01273 stride[5] = n6 * ( 01274 stride[4] = n5 * ( 01275 stride[3] = Tag4::Size * ( 01276 stride[2] = Tag3::Size * ( 01277 stride[1] = Tag2::Size * ( 01278 stride[0] = Tag1::Size ))))); 01279 } 01280 01281 static void assign( unsigned * stride , 01282 const unsigned & n4 , 01283 const unsigned & n5 , 01284 const unsigned & n6 ) 01285 { 01286 stride[5] = n6 * ( 01287 stride[4] = n5 * ( 01288 stride[3] = n4 * ( 01289 stride[2] = Tag3::Size * ( 01290 stride[1] = Tag2::Size * ( 01291 stride[0] = Tag1::Size ))))); 01292 } 01293 01294 static void assign( unsigned * stride , 01295 const unsigned & n3 , 01296 const unsigned & n4 , 01297 const unsigned & n5 , 01298 const unsigned & n6 ) 01299 { 01300 stride[5] = n6 * ( 01301 stride[4] = n5 * ( 01302 stride[3] = n4 * ( 01303 stride[2] = n3 * ( 01304 stride[1] = Tag2::Size * ( 01305 stride[0] = Tag1::Size ))))); 01306 } 01307 01308 static void assign( unsigned * stride , 01309 const unsigned & n2 , 01310 const unsigned & n3 , 01311 const unsigned & n4 , 01312 const unsigned & n5 , 01313 const unsigned & n6 ) 01314 { 01315 stride[5] = n6 * ( 01316 stride[4] = n5 * ( 01317 stride[3] = n4 * ( 01318 stride[2] = n3 * ( 01319 stride[1] = n2 * ( 01320 stride[0] = Tag1::Size ))))); 01321 } 01322 01323 static void assign( unsigned * stride , 01324 const unsigned & n1 , 01325 const unsigned & n2 , 01326 const unsigned & n3 , 01327 const unsigned & n4 , 01328 const unsigned & n5 , 01329 const unsigned & n6 ) 01330 { 01331 stride[5] = n6 * ( 01332 stride[4] = n5 * ( 01333 stride[3] = n4 * ( 01334 stride[2] = n3 * ( 01335 stride[1] = n2 * ( 01336 stride[0] = n1 ))))); 01337 } 01338 01339 static void assign( unsigned * stride , 01340 const unsigned * const dims ) 01341 { 01342 stride[5] = dims[5] * ( 01343 stride[4] = dims[4] * ( 01344 stride[3] = dims[3] * ( 01345 stride[2] = dims[2] * ( 01346 stride[1] = dims[1] * ( 01347 stride[0] = dims[0] ))))); 01348 } 01349 }; 01350 01351 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 , 01352 class Tag5 > 01353 struct Array<void,FortranOrder,Tag1,Tag2,Tag3,Tag4,Tag5,void,void,void> 01354 { 01355 enum { Rank = 5 }; 01356 01357 static void assign( unsigned * stride ) 01358 { 01359 stride[4] = Tag5::Size * ( 01360 stride[3] = Tag4::Size * ( 01361 stride[2] = Tag3::Size * ( 01362 stride[1] = Tag2::Size * ( 01363 stride[0] = Tag1::Size )))); 01364 } 01365 01366 static void assign( unsigned * stride , 01367 const unsigned & n5 ) 01368 { 01369 stride[4] = n5 * ( 01370 stride[3] = Tag4::Size * ( 01371 stride[2] = Tag3::Size * ( 01372 stride[1] = Tag2::Size * ( 01373 stride[0] = Tag1::Size )))); 01374 } 01375 01376 static void assign( unsigned * stride , 01377 const unsigned & n4 , 01378 const unsigned & n5 ) 01379 { 01380 stride[4] = n5 * ( 01381 stride[3] = n4 * ( 01382 stride[2] = Tag3::Size * ( 01383 stride[1] = Tag2::Size * ( 01384 stride[0] = Tag1::Size )))); 01385 } 01386 01387 static void assign( unsigned * stride , 01388 const unsigned & n3 , 01389 const unsigned & n4 , 01390 const unsigned & n5 ) 01391 { 01392 stride[4] = n5 * ( 01393 stride[3] = n4 * ( 01394 stride[2] = n3 * ( 01395 stride[1] = Tag2::Size * ( 01396 stride[0] = Tag1::Size )))); 01397 } 01398 01399 static void assign( unsigned * stride , 01400 const unsigned & n2 , 01401 const unsigned & n3 , 01402 const unsigned & n4 , 01403 const unsigned & n5 ) 01404 { 01405 stride[4] = n5 * ( 01406 stride[3] = n4 * ( 01407 stride[2] = n3 * ( 01408 stride[1] = n2 * ( 01409 stride[0] = Tag1::Size )))); 01410 } 01411 01412 static void assign( unsigned * stride , 01413 const unsigned & n1 , 01414 const unsigned & n2 , 01415 const unsigned & n3 , 01416 const unsigned & n4 , 01417 const unsigned & n5 ) 01418 { 01419 stride[4] = n5 * ( 01420 stride[3] = n4 * ( 01421 stride[2] = n3 * ( 01422 stride[1] = n2 * ( 01423 stride[0] = n1 )))); 01424 } 01425 01426 static void assign( unsigned * stride , 01427 const unsigned * const dims ) 01428 { 01429 stride[4] = dims[4] * ( 01430 stride[3] = dims[3] * ( 01431 stride[2] = dims[2] * ( 01432 stride[1] = dims[1] * ( 01433 stride[0] = dims[0] )))); 01434 } 01435 }; 01436 01437 01438 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 > 01439 struct Array<void,FortranOrder,Tag1,Tag2,Tag3,Tag4,void,void,void,void> 01440 { 01441 enum { Rank = 4 }; 01442 01443 static void assign( unsigned * stride ) 01444 { 01445 stride[3] = Tag4::Size * ( 01446 stride[2] = Tag3::Size * ( 01447 stride[1] = Tag2::Size * ( 01448 stride[0] = Tag1::Size ))); 01449 } 01450 01451 static void assign( unsigned * stride , 01452 const unsigned & n4 ) 01453 { 01454 stride[3] = n4 * ( 01455 stride[2] = Tag3::Size * ( 01456 stride[1] = Tag2::Size * ( 01457 stride[0] = Tag1::Size ))); 01458 } 01459 01460 static void assign( unsigned * stride , 01461 const unsigned & n3 , 01462 const unsigned & n4 ) 01463 { 01464 stride[3] = n4 * ( 01465 stride[2] = n3 * ( 01466 stride[1] = Tag2::Size * ( 01467 stride[0] = Tag1::Size ))); 01468 } 01469 01470 static void assign( unsigned * stride , 01471 const unsigned & n2 , 01472 const unsigned & n3 , 01473 const unsigned & n4 ) 01474 { 01475 stride[3] = n4 * ( 01476 stride[2] = n3 * ( 01477 stride[1] = n2 * ( 01478 stride[0] = Tag1::Size ))); 01479 } 01480 01481 static void assign( unsigned * stride , 01482 const unsigned & n1 , 01483 const unsigned & n2 , 01484 const unsigned & n3 , 01485 const unsigned & n4 ) 01486 { 01487 stride[3] = n4 * ( 01488 stride[2] = n3 * ( 01489 stride[1] = n2 * ( 01490 stride[0] = n1 ))); 01491 } 01492 01493 static void assign( unsigned * stride , 01494 const unsigned * const dims ) 01495 { 01496 stride[3] = dims[3] * ( 01497 stride[2] = dims[2] * ( 01498 stride[1] = dims[1] * ( 01499 stride[0] = dims[0] ))); 01500 } 01501 }; 01502 01503 template< class Tag1 , class Tag2 , class Tag3 > 01504 struct Array<void,FortranOrder,Tag1,Tag2,Tag3,void,void,void,void,void> 01505 { 01506 enum { Rank = 3 }; 01507 01508 static void assign( unsigned * stride ) 01509 { 01510 stride[2] = Tag3::Size * ( 01511 stride[1] = Tag2::Size * ( 01512 stride[0] = Tag1::Size )); 01513 } 01514 01515 static void assign( unsigned * stride , 01516 const unsigned & n3 ) 01517 { 01518 stride[2] = n3 * ( 01519 stride[1] = Tag2::Size * ( 01520 stride[0] = Tag1::Size )); 01521 } 01522 01523 static void assign( unsigned * stride , 01524 const unsigned & n2 , 01525 const unsigned & n3 ) 01526 { 01527 stride[2] = n3 * ( 01528 stride[1] = n2 * ( 01529 stride[0] = Tag1::Size )); 01530 } 01531 01532 static void assign( unsigned * stride , 01533 const unsigned & n1 , 01534 const unsigned & n2 , 01535 const unsigned & n3 ) 01536 { 01537 stride[2] = n3 * ( 01538 stride[1] = n2 * ( 01539 stride[0] = n1 )); 01540 } 01541 01542 static void assign( unsigned * stride , 01543 const unsigned * const dims ) 01544 { 01545 stride[2] = dims[2] * ( 01546 stride[1] = dims[1] * ( 01547 stride[0] = dims[0] )); 01548 } 01549 }; 01550 01551 template< class Tag1 , class Tag2 > 01552 struct Array<void,FortranOrder,Tag1,Tag2,void,void,void,void,void,void> 01553 { 01554 enum { Rank = 2 }; 01555 01556 static void assign( unsigned * stride ) 01557 { stride[1] = Tag2::Size * ( stride[0] = Tag1::Size ); } 01558 01559 static void assign( unsigned * stride , 01560 const unsigned & n2 ) 01561 { stride[1] = n2 * ( stride[0] = Tag1::Size ); } 01562 01563 static void assign( unsigned * stride , 01564 const unsigned & n1 , 01565 const unsigned & n2 ) 01566 { stride[1] = n2 * ( stride[0] = n1 ); } 01567 01568 static void assign( unsigned * stride , 01569 const unsigned * const dims ) 01570 { stride[1] = dims[1] * ( stride[0] = dims[0] ); } 01571 }; 01572 01573 template< class Tag1 > 01574 struct Array<void,FortranOrder,Tag1,void,void,void,void,void,void,void> 01575 { 01576 enum { Rank = 1 }; 01577 01578 static void assign( unsigned * stride ) { stride[0] = Tag1::Size ; } 01579 01580 static void assign( unsigned * stride , 01581 const unsigned & n1 ) { stride[0] = n1 ; } 01582 01583 static void assign( unsigned * stride , 01584 const unsigned * const dims ) 01585 { stride[0] = dims[0] ; } 01586 }; 01587 01588 //---------------------------------------------------------------------- 01589 01590 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 , 01591 class Tag5 , class Tag6 , class Tag7 , class Tag8 > 01592 struct Array<void,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8> 01593 { 01594 enum { Rank = 8 }; 01595 01596 static void assign( unsigned * stride ) 01597 { 01598 stride[7] = Tag1::Size * ( 01599 stride[6] = Tag2::Size * ( 01600 stride[5] = Tag3::Size * ( 01601 stride[4] = Tag4::Size * ( 01602 stride[3] = Tag5::Size * ( 01603 stride[2] = Tag6::Size * ( 01604 stride[1] = Tag7::Size * ( 01605 stride[0] = Tag8::Size ))))))); 01606 } 01607 01608 static void assign( unsigned * stride , 01609 const unsigned & n1 ) 01610 { 01611 stride[7] = n1 * ( 01612 stride[6] = Tag2::Size * ( 01613 stride[5] = Tag3::Size * ( 01614 stride[4] = Tag4::Size * ( 01615 stride[3] = Tag5::Size * ( 01616 stride[2] = Tag6::Size * ( 01617 stride[1] = Tag7::Size * ( 01618 stride[0] = Tag8::Size ))))))); 01619 } 01620 01621 static void assign( unsigned * stride , 01622 const unsigned & n1 , 01623 const unsigned & n2 ) 01624 { 01625 stride[7] = n1 * ( 01626 stride[6] = n2 * ( 01627 stride[5] = Tag3::Size * ( 01628 stride[4] = Tag4::Size * ( 01629 stride[3] = Tag5::Size * ( 01630 stride[2] = Tag6::Size * ( 01631 stride[1] = Tag7::Size * ( 01632 stride[0] = Tag8::Size ))))))); 01633 } 01634 01635 static void assign( unsigned * stride , 01636 const unsigned & n1 , 01637 const unsigned & n2 , 01638 const unsigned & n3 ) 01639 { 01640 stride[7] = n1 * ( 01641 stride[6] = n2 * ( 01642 stride[5] = n3 * ( 01643 stride[4] = Tag4::Size * ( 01644 stride[3] = Tag5::Size * ( 01645 stride[2] = Tag6::Size * ( 01646 stride[1] = Tag7::Size * ( 01647 stride[0] = Tag8::Size ))))))); 01648 } 01649 01650 static void assign( unsigned * stride , 01651 const unsigned & n1 , 01652 const unsigned & n2 , 01653 const unsigned & n3 , 01654 const unsigned & n4 ) 01655 { 01656 stride[7] = n1 * ( 01657 stride[6] = n2 * ( 01658 stride[5] = n3 * ( 01659 stride[4] = n4 * ( 01660 stride[3] = Tag5::Size * ( 01661 stride[2] = Tag6::Size * ( 01662 stride[1] = Tag7::Size * ( 01663 stride[0] = Tag8::Size ))))))); 01664 } 01665 01666 static void assign( unsigned * stride , 01667 const unsigned & n1 , 01668 const unsigned & n2 , 01669 const unsigned & n3 , 01670 const unsigned & n4 , 01671 const unsigned & n5 ) 01672 { 01673 stride[7] = n1 * ( 01674 stride[6] = n2 * ( 01675 stride[5] = n3 * ( 01676 stride[4] = n4 * ( 01677 stride[3] = n5 * ( 01678 stride[2] = Tag6::Size * ( 01679 stride[1] = Tag7::Size * ( 01680 stride[0] = Tag8::Size ))))))); 01681 } 01682 01683 static void assign( unsigned * stride , 01684 const unsigned & n1 , 01685 const unsigned & n2 , 01686 const unsigned & n3 , 01687 const unsigned & n4 , 01688 const unsigned & n5 , 01689 const unsigned & n6 ) 01690 { 01691 stride[7] = n1 * ( 01692 stride[6] = n2 * ( 01693 stride[5] = n3 * ( 01694 stride[4] = n4 * ( 01695 stride[3] = n5 * ( 01696 stride[2] = n6 * ( 01697 stride[1] = Tag7::Size * ( 01698 stride[0] = Tag8::Size ))))))); 01699 } 01700 01701 static void assign( unsigned * stride , 01702 const unsigned & n1 , 01703 const unsigned & n2 , 01704 const unsigned & n3 , 01705 const unsigned & n4 , 01706 const unsigned & n5 , 01707 const unsigned & n6 , 01708 const unsigned & n7 ) 01709 { 01710 stride[7] = n1 * ( 01711 stride[6] = n2 * ( 01712 stride[5] = n3 * ( 01713 stride[4] = n4 * ( 01714 stride[3] = n5 * ( 01715 stride[2] = n6 * ( 01716 stride[1] = n7 * ( 01717 stride[0] = Tag8::Size ))))))); 01718 } 01719 01720 static void assign( unsigned * stride , 01721 const unsigned & n1 , 01722 const unsigned & n2 , 01723 const unsigned & n3 , 01724 const unsigned & n4 , 01725 const unsigned & n5 , 01726 const unsigned & n6 , 01727 const unsigned & n7 , 01728 const unsigned & n8 ) 01729 { 01730 stride[7] = n1 * ( 01731 stride[6] = n2 * ( 01732 stride[5] = n3 * ( 01733 stride[4] = n4 * ( 01734 stride[3] = n5 * ( 01735 stride[2] = n6 * ( 01736 stride[1] = n7 * ( 01737 stride[0] = n8 ))))))); 01738 } 01739 01740 static void assign( unsigned * stride , 01741 const unsigned * const dims ) 01742 { 01743 stride[7] = dims[0] * ( 01744 stride[6] = dims[1] * ( 01745 stride[5] = dims[2] * ( 01746 stride[4] = dims[3] * ( 01747 stride[3] = dims[4] * ( 01748 stride[2] = dims[5] * ( 01749 stride[1] = dims[6] * ( 01750 stride[0] = dims[7] ))))))); 01751 } 01752 }; 01753 01754 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 , 01755 class Tag5 , class Tag6 , class Tag7 > 01756 struct Array<void,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,void> 01757 { 01758 enum { Rank = 7 }; 01759 01760 static void assign( unsigned * stride ) 01761 { 01762 stride[6] = Tag1::Size * ( 01763 stride[5] = Tag2::Size * ( 01764 stride[4] = Tag3::Size * ( 01765 stride[3] = Tag4::Size * ( 01766 stride[2] = Tag5::Size * ( 01767 stride[1] = Tag6::Size * ( 01768 stride[0] = Tag7::Size )))))); 01769 } 01770 01771 static void assign( unsigned * stride , 01772 const unsigned & n1 ) 01773 { 01774 stride[6] = n1 * ( 01775 stride[5] = Tag2::Size * ( 01776 stride[4] = Tag3::Size * ( 01777 stride[3] = Tag4::Size * ( 01778 stride[2] = Tag5::Size * ( 01779 stride[1] = Tag6::Size * ( 01780 stride[0] = Tag7::Size )))))); 01781 } 01782 01783 static void assign( unsigned * stride , 01784 const unsigned & n1 , 01785 const unsigned & n2 ) 01786 { 01787 stride[6] = n1 * ( 01788 stride[5] = n2 * ( 01789 stride[4] = Tag3::Size * ( 01790 stride[3] = Tag4::Size * ( 01791 stride[2] = Tag5::Size * ( 01792 stride[1] = Tag6::Size * ( 01793 stride[0] = Tag7::Size )))))); 01794 } 01795 01796 static void assign( unsigned * stride , 01797 const unsigned & n1 , 01798 const unsigned & n2 , 01799 const unsigned & n3 ) 01800 { 01801 stride[6] = n1 * ( 01802 stride[5] = n2 * ( 01803 stride[4] = n3 * ( 01804 stride[3] = Tag4::Size * ( 01805 stride[2] = Tag5::Size * ( 01806 stride[1] = Tag6::Size * ( 01807 stride[0] = Tag7::Size )))))); 01808 } 01809 01810 static void assign( unsigned * stride , 01811 const unsigned & n1 , 01812 const unsigned & n2 , 01813 const unsigned & n3 , 01814 const unsigned & n4 ) 01815 { 01816 stride[6] = n1 * ( 01817 stride[5] = n2 * ( 01818 stride[4] = n3 * ( 01819 stride[3] = n4 * ( 01820 stride[2] = Tag5::Size * ( 01821 stride[1] = Tag6::Size * ( 01822 stride[0] = Tag7::Size )))))); 01823 } 01824 01825 static void assign( unsigned * stride , 01826 const unsigned & n1 , 01827 const unsigned & n2 , 01828 const unsigned & n3 , 01829 const unsigned & n4 , 01830 const unsigned & n5 ) 01831 { 01832 stride[6] = n1 * ( 01833 stride[5] = n2 * ( 01834 stride[4] = n3 * ( 01835 stride[3] = n4 * ( 01836 stride[2] = n5 * ( 01837 stride[1] = Tag6::Size * ( 01838 stride[0] = Tag7::Size )))))); 01839 } 01840 01841 static void assign( unsigned * stride , 01842 const unsigned & n1 , 01843 const unsigned & n2 , 01844 const unsigned & n3 , 01845 const unsigned & n4 , 01846 const unsigned & n5 , 01847 const unsigned & n6 ) 01848 { 01849 stride[6] = n1 * ( 01850 stride[5] = n2 * ( 01851 stride[4] = n3 * ( 01852 stride[3] = n4 * ( 01853 stride[2] = n5 * ( 01854 stride[1] = n6 * ( 01855 stride[0] = Tag7::Size )))))); 01856 } 01857 01858 static void assign( unsigned * stride , 01859 const unsigned & n1 , 01860 const unsigned & n2 , 01861 const unsigned & n3 , 01862 const unsigned & n4 , 01863 const unsigned & n5 , 01864 const unsigned & n6 , 01865 const unsigned & n7 ) 01866 { 01867 stride[6] = n1 * ( 01868 stride[5] = n2 * ( 01869 stride[4] = n3 * ( 01870 stride[3] = n4 * ( 01871 stride[2] = n5 * ( 01872 stride[1] = n6 * ( 01873 stride[0] = n7 )))))); 01874 } 01875 01876 static void assign( unsigned * stride , 01877 const unsigned * const dims ) 01878 { 01879 stride[6] = dims[0] * ( 01880 stride[5] = dims[1] * ( 01881 stride[4] = dims[2] * ( 01882 stride[3] = dims[3] * ( 01883 stride[2] = dims[4] * ( 01884 stride[1] = dims[5] * ( 01885 stride[0] = dims[6] )))))); 01886 } 01887 }; 01888 01889 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 , 01890 class Tag5 , class Tag6 > 01891 struct Array<void,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,void,void> 01892 { 01893 enum { Rank = 6 }; 01894 01895 static void assign( unsigned * stride ) 01896 { 01897 stride[5] = Tag1::Size * ( 01898 stride[4] = Tag2::Size * ( 01899 stride[3] = Tag3::Size * ( 01900 stride[2] = Tag4::Size * ( 01901 stride[1] = Tag5::Size * ( 01902 stride[0] = Tag6::Size ))))); 01903 } 01904 01905 static void assign( unsigned * stride , 01906 const unsigned & n1 ) 01907 { 01908 stride[5] = n1 * ( 01909 stride[4] = Tag2::Size * ( 01910 stride[3] = Tag3::Size * ( 01911 stride[2] = Tag4::Size * ( 01912 stride[1] = Tag5::Size * ( 01913 stride[0] = Tag6::Size ))))); 01914 } 01915 01916 static void assign( unsigned * stride , 01917 const unsigned & n1 , 01918 const unsigned & n2 ) 01919 { 01920 stride[5] = n1 * ( 01921 stride[4] = n2 * ( 01922 stride[3] = Tag3::Size * ( 01923 stride[2] = Tag4::Size * ( 01924 stride[1] = Tag5::Size * ( 01925 stride[0] = Tag6::Size ))))); 01926 } 01927 01928 static void assign( unsigned * stride , 01929 const unsigned & n1 , 01930 const unsigned & n2 , 01931 const unsigned & n3 ) 01932 { 01933 stride[5] = n1 * ( 01934 stride[4] = n2 * ( 01935 stride[3] = n3 * ( 01936 stride[2] = Tag4::Size * ( 01937 stride[1] = Tag5::Size * ( 01938 stride[0] = Tag6::Size ))))); 01939 } 01940 01941 static void assign( unsigned * stride , 01942 const unsigned & n1 , 01943 const unsigned & n2 , 01944 const unsigned & n3 , 01945 const unsigned & n4 ) 01946 { 01947 stride[5] = n1 * ( 01948 stride[4] = n2 * ( 01949 stride[3] = n3 * ( 01950 stride[2] = n4 * ( 01951 stride[1] = Tag5::Size * ( 01952 stride[0] = Tag6::Size ))))); 01953 } 01954 01955 static void assign( unsigned * stride , 01956 const unsigned & n1 , 01957 const unsigned & n2 , 01958 const unsigned & n3 , 01959 const unsigned & n4 , 01960 const unsigned & n5 ) 01961 { 01962 stride[5] = n1 * ( 01963 stride[4] = n2 * ( 01964 stride[3] = n3 * ( 01965 stride[2] = n4 * ( 01966 stride[1] = n5 * ( 01967 stride[0] = Tag6::Size ))))); 01968 } 01969 01970 static void assign( unsigned * stride , 01971 const unsigned & n1 , 01972 const unsigned & n2 , 01973 const unsigned & n3 , 01974 const unsigned & n4 , 01975 const unsigned & n5 , 01976 const unsigned & n6 ) 01977 { 01978 stride[5] = n1 * ( 01979 stride[4] = n2 * ( 01980 stride[3] = n3 * ( 01981 stride[2] = n4 * ( 01982 stride[1] = n5 * ( 01983 stride[0] = n6 ))))); 01984 } 01985 01986 static void assign( unsigned * stride , 01987 const unsigned * const dims ) 01988 { 01989 stride[5] = dims[0] * ( 01990 stride[4] = dims[1] * ( 01991 stride[3] = dims[2] * ( 01992 stride[2] = dims[3] * ( 01993 stride[1] = dims[4] * ( 01994 stride[0] = dims[5] ))))); 01995 } 01996 }; 01997 01998 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 , 01999 class Tag5 > 02000 struct Array<void,NaturalOrder,Tag1,Tag2,Tag3,Tag4,Tag5,void,void,void> 02001 { 02002 enum { Rank = 5 }; 02003 02004 static void assign( unsigned * stride ) 02005 { 02006 stride[4] = Tag1::Size * ( 02007 stride[3] = Tag2::Size * ( 02008 stride[2] = Tag3::Size * ( 02009 stride[1] = Tag4::Size * ( 02010 stride[0] = Tag5::Size )))); 02011 } 02012 02013 static void assign( unsigned * stride , 02014 const unsigned & n1 ) 02015 { 02016 stride[4] = n1 * ( 02017 stride[3] = Tag2::Size * ( 02018 stride[2] = Tag3::Size * ( 02019 stride[1] = Tag4::Size * ( 02020 stride[0] = Tag5::Size )))); 02021 } 02022 02023 static void assign( unsigned * stride , 02024 const unsigned & n1 , 02025 const unsigned & n2 ) 02026 { 02027 stride[4] = n1 * ( 02028 stride[3] = n2 * ( 02029 stride[2] = Tag3::Size * ( 02030 stride[1] = Tag4::Size * ( 02031 stride[0] = Tag5::Size )))); 02032 } 02033 02034 static void assign( unsigned * stride , 02035 const unsigned & n1 , 02036 const unsigned & n2 , 02037 const unsigned & n3 ) 02038 { 02039 stride[4] = n1 * ( 02040 stride[3] = n2 * ( 02041 stride[2] = n3 * ( 02042 stride[1] = Tag4::Size * ( 02043 stride[0] = Tag5::Size )))); 02044 } 02045 02046 static void assign( unsigned * stride , 02047 const unsigned & n1 , 02048 const unsigned & n2 , 02049 const unsigned & n3 , 02050 const unsigned & n4 ) 02051 { 02052 stride[4] = n1 * ( 02053 stride[3] = n2 * ( 02054 stride[2] = n3 * ( 02055 stride[1] = n4 * ( 02056 stride[0] = Tag5::Size )))); 02057 } 02058 02059 static void assign( unsigned * stride , 02060 const unsigned & n1 , 02061 const unsigned & n2 , 02062 const unsigned & n3 , 02063 const unsigned & n4 , 02064 const unsigned & n5 ) 02065 { 02066 stride[4] = n1 * ( 02067 stride[3] = n2 * ( 02068 stride[2] = n3 * ( 02069 stride[1] = n4 * ( 02070 stride[0] = n5 )))); 02071 } 02072 02073 static void assign( unsigned * stride , 02074 const unsigned * const dims ) 02075 { 02076 stride[4] = dims[0] * ( 02077 stride[3] = dims[1] * ( 02078 stride[2] = dims[2] * ( 02079 stride[1] = dims[3] * ( 02080 stride[0] = dims[4] )))); 02081 } 02082 }; 02083 02084 02085 template< class Tag1 , class Tag2 , class Tag3 , class Tag4 > 02086 struct Array<void,NaturalOrder,Tag1,Tag2,Tag3,Tag4,void,void,void,void> 02087 { 02088 enum { Rank = 4 }; 02089 02090 static void assign( unsigned * stride ) 02091 { 02092 stride[3] = Tag1::Size * ( 02093 stride[2] = Tag2::Size * ( 02094 stride[1] = Tag3::Size * ( 02095 stride[0] = Tag4::Size ))); 02096 } 02097 02098 static void assign( unsigned * stride , 02099 const unsigned & n1 ) 02100 { 02101 stride[3] = n1 * ( 02102 stride[2] = Tag2::Size * ( 02103 stride[1] = Tag3::Size * ( 02104 stride[0] = Tag4::Size ))); 02105 } 02106 02107 static void assign( unsigned * stride , 02108 const unsigned & n1 , 02109 const unsigned & n2 ) 02110 { 02111 stride[3] = n1 * ( 02112 stride[2] = n2 * ( 02113 stride[1] = Tag3::Size * ( 02114 stride[0] = Tag4::Size ))); 02115 } 02116 02117 static void assign( unsigned * stride , 02118 const unsigned & n1 , 02119 const unsigned & n2 , 02120 const unsigned & n3 ) 02121 { 02122 stride[3] = n1 * ( 02123 stride[2] = n2 * ( 02124 stride[1] = n3 * ( 02125 stride[0] = Tag4::Size ))); 02126 } 02127 02128 static void assign( unsigned * stride , 02129 const unsigned & n1 , 02130 const unsigned & n2 , 02131 const unsigned & n3 , 02132 const unsigned & n4 ) 02133 { 02134 stride[3] = n1 * ( 02135 stride[2] = n2 * ( 02136 stride[1] = n3 * ( 02137 stride[0] = n4 ))); 02138 } 02139 02140 static void assign( unsigned * stride , 02141 const unsigned * const dims ) 02142 { 02143 stride[3] = dims[0] * ( 02144 stride[2] = dims[1] * ( 02145 stride[1] = dims[2] * ( 02146 stride[0] = dims[3] ))); 02147 } 02148 }; 02149 02150 template< class Tag1 , class Tag2 , class Tag3 > 02151 struct Array<void,NaturalOrder,Tag1,Tag2,Tag3,void,void,void,void,void> 02152 { 02153 enum { Rank = 3 }; 02154 02155 static void assign( unsigned * stride ) 02156 { 02157 stride[2] = Tag1::Size * ( 02158 stride[1] = Tag2::Size * ( 02159 stride[0] = Tag3::Size )); 02160 } 02161 02162 static void assign( unsigned * stride , 02163 const unsigned & n1 ) 02164 { 02165 stride[2] = n1 * ( 02166 stride[1] = Tag2::Size * ( 02167 stride[0] = Tag3::Size )); 02168 } 02169 02170 static void assign( unsigned * stride , 02171 const unsigned & n1 , 02172 const unsigned & n2 ) 02173 { 02174 stride[2] = n1 * ( 02175 stride[1] = n2 * ( 02176 stride[0] = Tag3::Size )); 02177 } 02178 02179 static void assign( unsigned * stride , 02180 const unsigned & n1 , 02181 const unsigned & n2 , 02182 const unsigned & n3 ) 02183 { 02184 stride[2] = n1 * ( 02185 stride[1] = n2 * ( 02186 stride[0] = n3 )); 02187 } 02188 02189 static void assign( unsigned * stride , 02190 const unsigned * const dims ) 02191 { 02192 stride[2] = dims[0] * ( 02193 stride[1] = dims[1] * ( 02194 stride[0] = dims[2] )); 02195 } 02196 }; 02197 02198 template< class Tag1 , class Tag2 > 02199 struct Array<void,NaturalOrder,Tag1,Tag2,void,void,void,void,void,void> 02200 { 02201 enum { Rank = 2 }; 02202 02203 static void assign( unsigned * stride ) 02204 { stride[1] = Tag1::Size * ( stride[0] = Tag2::Size ); } 02205 02206 static void assign( unsigned * stride , 02207 const unsigned & n1 ) 02208 { stride[1] = n1 * ( stride[0] = Tag2::Size ); } 02209 02210 static void assign( unsigned * stride , 02211 const unsigned & n1 , 02212 const unsigned & n2 ) 02213 { stride[1] = n1 * ( stride[0] = n2 ); } 02214 02215 static void assign( unsigned * stride , 02216 const unsigned * const dims ) 02217 { 02218 stride[1] = dims[0] * ( 02219 stride[0] = dims[1] ); 02220 } 02221 }; 02222 02223 template< class Tag1 > 02224 struct Array<void,NaturalOrder,Tag1,void,void,void,void,void,void,void> 02225 { 02226 enum { Rank = 1 }; 02227 02228 static void assign( unsigned * stride ) { stride[0] = Tag1::Size ; } 02229 02230 static void assign( unsigned * stride , 02231 const unsigned & n1 ) { stride[0] = n1 ; } 02232 02233 static void assign( unsigned * stride , 02234 const unsigned * const dims ) 02235 { stride[0] = dims[0] ; } 02236 }; 02237 02238 //---------------------------------------------------------------------- 02239 02240 template<> 02241 struct Array<void,RankZero,void,void,void,void,void,void,void,void> 02242 { 02243 enum { Rank = 0 }; 02244 02245 static void assign( unsigned * ) {} 02246 }; 02247 02248 //---------------------------------------------------------------------- 02249 02250 #endif /* DOXYGEN_COMPILE */ 02251 02254 } // namespace phdmesh 02255 02256 #endif 02257
1.7.4
