00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038 #ifndef BZ_ARRAY_H
00039 #define BZ_ARRAY_H
00040
00041 #include <blitz/blitz.h>
00042 #include <blitz/memblock.h>
00043 #include <blitz/range.h>
00044 #include <blitz/tinyvec.h>
00045
00046 #ifdef BZ_ARRAY_SPACE_FILLING_TRAVERSAL
00047 #include <blitz/traversal.h>
00048 #endif
00049
00050 #include <blitz/indexexpr.h>
00051 #include <blitz/prettyprint.h>
00052
00053 #include <blitz/array/slice.h>
00054 #include <blitz/array/map.h>
00055 #include <blitz/array/multi.h>
00056 #include <blitz/array/domain.h>
00057 #include <blitz/array/storage.h>
00058
00059
00060 BZ_NAMESPACE(blitz)
00061
00062
00063
00064
00065
00066 template<typename T_numtype, int N_rank>
00067 class ArrayIterator;
00068
00069 template<typename T_numtype, int N_rank>
00070 class ConstArrayIterator;
00071
00072 template<typename T_numtype, int N_rank>
00073 class FastArrayIterator;
00074
00075 template<typename P_expr>
00076 class _bz_ArrayExpr;
00077
00078 template<typename T_array, typename T_index>
00079 class IndirectArray;
00080
00081 template <typename P_numtype,int N_rank>
00082 void swap(Array<P_numtype,N_rank>&,Array<P_numtype,N_rank>&);
00083
00084 template <typename P_numtype, int N_rank>
00085 void find(Array<TinyVector<int,N_rank>,1>&,const Array<P_numtype,N_rank>&);
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095 template<typename P_numtype, int N_rank>
00096 class Array : public MemoryBlockReference<P_numtype>
00097 #ifdef BZ_NEW_EXPRESSION_TEMPLATES
00098 , public ETBase<Array<P_numtype,N_rank> >
00099 #endif
00100 {
00101
00102 private:
00103 typedef MemoryBlockReference<P_numtype> T_base;
00104 using T_base::data_;
00105
00106 public:
00108
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122 typedef P_numtype T_numtype;
00123 typedef TinyVector<int, N_rank> T_index;
00124 typedef Array<T_numtype, N_rank> T_array;
00125 typedef FastArrayIterator<T_numtype, N_rank> T_iterator;
00126
00127 typedef ArrayIterator<T_numtype,N_rank> iterator;
00128 typedef ConstArrayIterator<T_numtype,N_rank> const_iterator;
00129
00130 static const int _bz_rank = N_rank;
00131
00133
00135
00136
00137
00138
00139
00140
00141 template<typename T_expr>
00142 explicit Array(_bz_ArrayExpr<T_expr> expr);
00143
00144
00145
00146
00147
00148
00149
00150
00151 Array(GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00152 : storage_(storage)
00153 {
00154 length_ = 0;
00155 stride_ = 0;
00156 zeroOffset_ = 0;
00157 }
00158
00159 explicit Array(int length0,
00160 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00161 : storage_(storage)
00162 {
00163 length_[0] = length0;
00164 setupStorage(0);
00165 }
00166
00167 Array(int length0, int length1,
00168 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00169 : storage_(storage)
00170 {
00171 BZPRECONDITION(N_rank >= 2);
00172 TAU_TYPE_STRING(p1, "Array<T,N>::Array() [T="
00173 + CT(T_numtype) + ",N=" + CT(N_rank) + "]");
00174 TAU_PROFILE(p1, "void (int,int)", TAU_BLITZ);
00175
00176 length_[0] = length0;
00177 length_[1] = length1;
00178 setupStorage(1);
00179 }
00180
00181 Array(int length0, int length1, int length2,
00182 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00183 : storage_(storage)
00184 {
00185 BZPRECONDITION(N_rank >= 3);
00186 length_[0] = length0;
00187 length_[1] = length1;
00188 length_[2] = length2;
00189 setupStorage(2);
00190 }
00191
00192 Array(int length0, int length1, int length2, int length3,
00193 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00194 : storage_(storage)
00195 {
00196 BZPRECONDITION(N_rank >= 4);
00197 length_[0] = length0;
00198 length_[1] = length1;
00199 length_[2] = length2;
00200 length_[3] = length3;
00201 setupStorage(3);
00202 }
00203
00204 Array(int length0, int length1, int length2, int length3, int length4,
00205 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00206 : storage_(storage)
00207 {
00208 BZPRECONDITION(N_rank >= 5);
00209 length_[0] = length0;
00210 length_[1] = length1;
00211 length_[2] = length2;
00212 length_[3] = length3;
00213 length_[4] = length4;
00214 setupStorage(4);
00215 }
00216
00217 Array(int length0, int length1, int length2, int length3, int length4,
00218 int length5,
00219 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00220 : storage_(storage)
00221 {
00222 BZPRECONDITION(N_rank >= 6);
00223 length_[0] = length0;
00224 length_[1] = length1;
00225 length_[2] = length2;
00226 length_[3] = length3;
00227 length_[4] = length4;
00228 length_[5] = length5;
00229 setupStorage(5);
00230 }
00231
00232 Array(int length0, int length1, int length2, int length3, int length4,
00233 int length5, int length6,
00234 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00235 : storage_(storage)
00236 {
00237 BZPRECONDITION(N_rank >= 7);
00238 length_[0] = length0;
00239 length_[1] = length1;
00240 length_[2] = length2;
00241 length_[3] = length3;
00242 length_[4] = length4;
00243 length_[5] = length5;
00244 length_[6] = length6;
00245 setupStorage(6);
00246 }
00247
00248 Array(int length0, int length1, int length2, int length3, int length4,
00249 int length5, int length6, int length7,
00250 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00251 : storage_(storage)
00252 {
00253 BZPRECONDITION(N_rank >= 8);
00254 length_[0] = length0;
00255 length_[1] = length1;
00256 length_[2] = length2;
00257 length_[3] = length3;
00258 length_[4] = length4;
00259 length_[5] = length5;
00260 length_[6] = length6;
00261 length_[7] = length7;
00262 setupStorage(7);
00263 }
00264
00265 Array(int length0, int length1, int length2, int length3, int length4,
00266 int length5, int length6, int length7, int length8,
00267 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00268 : storage_(storage)
00269 {
00270 BZPRECONDITION(N_rank >= 9);
00271 length_[0] = length0;
00272 length_[1] = length1;
00273 length_[2] = length2;
00274 length_[3] = length3;
00275 length_[4] = length4;
00276 length_[5] = length5;
00277 length_[6] = length6;
00278 length_[7] = length7;
00279 length_[8] = length8;
00280 setupStorage(8);
00281 }
00282
00283 Array(int length0, int length1, int length2, int length3, int length4,
00284 int length5, int length6, int length7, int length8, int length9,
00285 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00286 : storage_(storage)
00287 {
00288 BZPRECONDITION(N_rank >= 10);
00289 length_[0] = length0;
00290 length_[1] = length1;
00291 length_[2] = length2;
00292 length_[3] = length3;
00293 length_[4] = length4;
00294 length_[5] = length5;
00295 length_[6] = length6;
00296 length_[7] = length7;
00297 length_[8] = length8;
00298 length_[9] = length9;
00299 setupStorage(9);
00300 }
00301
00302 Array(int length0, int length1, int length2, int length3, int length4,
00303 int length5, int length6, int length7, int length8, int length9,
00304 int length10,
00305 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00306 : storage_(storage)
00307 {
00308 BZPRECONDITION(N_rank >= 11);
00309 length_[0] = length0;
00310 length_[1] = length1;
00311 length_[2] = length2;
00312 length_[3] = length3;
00313 length_[4] = length4;
00314 length_[5] = length5;
00315 length_[6] = length6;
00316 length_[7] = length7;
00317 length_[8] = length8;
00318 length_[9] = length9;
00319 length_[10] = length10;
00320 setupStorage(10);
00321 }
00322
00323
00324
00325
00326
00327 Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
00328 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00329 : MemoryBlockReference<T_numtype>(product(shape), dataFirst,
00330 neverDeleteData),
00331 storage_(storage)
00332 {
00333 BZPRECONDITION(dataFirst != 0);
00334
00335 length_ = shape;
00336 computeStrides();
00337 data_ += zeroOffset_;
00338 }
00339
00340
00341
00342
00343
00344
00345 Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
00346 TinyVector<int, N_rank> stride,
00347 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00348 : MemoryBlockReference<T_numtype>(product(shape), dataFirst,
00349 neverDeleteData),
00350 storage_(storage)
00351 {
00352 BZPRECONDITION(dataFirst != 0);
00353
00354 length_ = shape;
00355 stride_ = stride;
00356 calculateZeroOffset();
00357 data_ += zeroOffset_;
00358 }
00359
00360
00361
00362
00363 Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
00364 preexistingMemoryPolicy deletionPolicy,
00365 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00366 : MemoryBlockReference<T_numtype>(product(shape), dataFirst,
00367 deletionPolicy),
00368 storage_(storage)
00369 {
00370 BZPRECONDITION(dataFirst != 0);
00371
00372 length_ = shape;
00373 computeStrides();
00374 data_ += zeroOffset_;
00375
00376 if (deletionPolicy == duplicateData)
00377 reference(copy());
00378 }
00379
00380
00381
00382
00383
00384 Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
00385 TinyVector<int, N_rank> stride,
00386 preexistingMemoryPolicy deletionPolicy,
00387 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00388 : MemoryBlockReference<T_numtype>(product(shape), dataFirst,
00389 deletionPolicy),
00390 storage_(storage)
00391 {
00392 BZPRECONDITION(dataFirst != 0);
00393
00394 length_ = shape;
00395 stride_ = stride;
00396 calculateZeroOffset();
00397 data_ += zeroOffset_;
00398
00399 if (deletionPolicy == duplicateData)
00400 reference(copy());
00401 }
00402
00403
00404
00405
00406
00407 Array(const TinyVector<int, N_rank>& extent,
00408 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00409 : storage_(storage)
00410 {
00411 length_ = extent;
00412 setupStorage(N_rank - 1);
00413 }
00414
00415
00416
00417
00418
00419
00420 Array(const TinyVector<int, N_rank>& lbounds,
00421 const TinyVector<int, N_rank>& extent,
00422 const GeneralArrayStorage<N_rank>& storage
00423 = GeneralArrayStorage<N_rank>());
00424
00425
00426
00427
00428
00429
00430 Array(Range r0,
00431 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00432 : storage_(storage)
00433 {
00434 BZPRECONDITION(r0.isAscendingContiguous());
00435
00436 length_[0] = r0.length();
00437 storage_.setBase(0, r0.first());
00438 setupStorage(0);
00439 }
00440
00441 Array(Range r0, Range r1,
00442 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00443 : storage_(storage)
00444 {
00445 BZPRECONDITION(r0.isAscendingContiguous() &&
00446 r1.isAscendingContiguous());
00447
00448 length_[0] = r0.length();
00449 storage_.setBase(0, r0.first());
00450 length_[1] = r1.length();
00451 storage_.setBase(1, r1.first());
00452
00453 setupStorage(1);
00454 }
00455
00456 Array(Range r0, Range r1, Range r2,
00457 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00458 : storage_(storage)
00459 {
00460 BZPRECONDITION(r0.isAscendingContiguous() &&
00461 r1.isAscendingContiguous() && r2.isAscendingContiguous());
00462
00463 length_[0] = r0.length();
00464 storage_.setBase(0, r0.first());
00465 length_[1] = r1.length();
00466 storage_.setBase(1, r1.first());
00467 length_[2] = r2.length();
00468 storage_.setBase(2, r2.first());
00469
00470 setupStorage(2);
00471 }
00472
00473 Array(Range r0, Range r1, Range r2, Range r3,
00474 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00475 : storage_(storage)
00476 {
00477 BZPRECONDITION(r0.isAscendingContiguous() &&
00478 r1.isAscendingContiguous() && r2.isAscendingContiguous()
00479 && r3.isAscendingContiguous());
00480
00481 length_[0] = r0.length();
00482 storage_.setBase(0, r0.first());
00483 length_[1] = r1.length();
00484 storage_.setBase(1, r1.first());
00485 length_[2] = r2.length();
00486 storage_.setBase(2, r2.first());
00487 length_[3] = r3.length();
00488 storage_.setBase(3, r3.first());
00489
00490 setupStorage(3);
00491 }
00492
00493 Array(Range r0, Range r1, Range r2, Range r3, Range r4,
00494 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00495 : storage_(storage)
00496 {
00497 BZPRECONDITION(r0.isAscendingContiguous() &&
00498 r1.isAscendingContiguous() && r2.isAscendingContiguous()
00499 && r3.isAscendingContiguous() && r4.isAscendingContiguous());
00500
00501 length_[0] = r0.length();
00502 storage_.setBase(0, r0.first());
00503 length_[1] = r1.length();
00504 storage_.setBase(1, r1.first());
00505 length_[2] = r2.length();
00506 storage_.setBase(2, r2.first());
00507 length_[3] = r3.length();
00508 storage_.setBase(3, r3.first());
00509 length_[4] = r4.length();
00510 storage_.setBase(4, r4.first());
00511
00512 setupStorage(4);
00513 }
00514
00515 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
00516 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00517 : storage_(storage)
00518 {
00519 BZPRECONDITION(r0.isAscendingContiguous() &&
00520 r1.isAscendingContiguous() && r2.isAscendingContiguous()
00521 && r3.isAscendingContiguous() && r4.isAscendingContiguous()
00522 && r5.isAscendingContiguous());
00523
00524 length_[0] = r0.length();
00525 storage_.setBase(0, r0.first());
00526 length_[1] = r1.length();
00527 storage_.setBase(1, r1.first());
00528 length_[2] = r2.length();
00529 storage_.setBase(2, r2.first());
00530 length_[3] = r3.length();
00531 storage_.setBase(3, r3.first());
00532 length_[4] = r4.length();
00533 storage_.setBase(4, r4.first());
00534 length_[5] = r5.length();
00535 storage_.setBase(5, r5.first());
00536
00537 setupStorage(5);
00538 }
00539
00540 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
00541 Range r6,
00542 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00543 : storage_(storage)
00544 {
00545 BZPRECONDITION(r0.isAscendingContiguous() &&
00546 r1.isAscendingContiguous() && r2.isAscendingContiguous()
00547 && r3.isAscendingContiguous() && r4.isAscendingContiguous()
00548 && r5.isAscendingContiguous() && r6.isAscendingContiguous());
00549
00550 length_[0] = r0.length();
00551 storage_.setBase(0, r0.first());
00552 length_[1] = r1.length();
00553 storage_.setBase(1, r1.first());
00554 length_[2] = r2.length();
00555 storage_.setBase(2, r2.first());
00556 length_[3] = r3.length();
00557 storage_.setBase(3, r3.first());
00558 length_[4] = r4.length();
00559 storage_.setBase(4, r4.first());
00560 length_[5] = r5.length();
00561 storage_.setBase(5, r5.first());
00562 length_[6] = r6.length();
00563 storage_.setBase(6, r6.first());
00564
00565 setupStorage(6);
00566 }
00567
00568 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
00569 Range r6, Range r7,
00570 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00571 : storage_(storage)
00572 {
00573 BZPRECONDITION(r0.isAscendingContiguous() &&
00574 r1.isAscendingContiguous() && r2.isAscendingContiguous()
00575 && r3.isAscendingContiguous() && r4.isAscendingContiguous()
00576 && r5.isAscendingContiguous() && r6.isAscendingContiguous()
00577 && r7.isAscendingContiguous());
00578
00579 length_[0] = r0.length();
00580 storage_.setBase(0, r0.first());
00581 length_[1] = r1.length();
00582 storage_.setBase(1, r1.first());
00583 length_[2] = r2.length();
00584 storage_.setBase(2, r2.first());
00585 length_[3] = r3.length();
00586 storage_.setBase(3, r3.first());
00587 length_[4] = r4.length();
00588 storage_.setBase(4, r4.first());
00589 length_[5] = r5.length();
00590 storage_.setBase(5, r5.first());
00591 length_[6] = r6.length();
00592 storage_.setBase(6, r6.first());
00593 length_[7] = r7.length();
00594 storage_.setBase(7, r7.first());
00595
00596 setupStorage(7);
00597 }
00598
00599 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
00600 Range r6, Range r7, Range r8,
00601 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00602 : storage_(storage)
00603 {
00604 BZPRECONDITION(r0.isAscendingContiguous() &&
00605 r1.isAscendingContiguous() && r2.isAscendingContiguous()
00606 && r3.isAscendingContiguous() && r4.isAscendingContiguous()
00607 && r5.isAscendingContiguous() && r6.isAscendingContiguous()
00608 && r7.isAscendingContiguous() && r8.isAscendingContiguous());
00609
00610 length_[0] = r0.length();
00611 storage_.setBase(0, r0.first());
00612 length_[1] = r1.length();
00613 storage_.setBase(1, r1.first());
00614 length_[2] = r2.length();
00615 storage_.setBase(2, r2.first());
00616 length_[3] = r3.length();
00617 storage_.setBase(3, r3.first());
00618 length_[4] = r4.length();
00619 storage_.setBase(4, r4.first());
00620 length_[5] = r5.length();
00621 storage_.setBase(5, r5.first());
00622 length_[6] = r6.length();
00623 storage_.setBase(6, r6.first());
00624 length_[7] = r7.length();
00625 storage_.setBase(7, r7.first());
00626 length_[8] = r8.length();
00627 storage_.setBase(8, r8.first());
00628
00629 setupStorage(8);
00630 }
00631
00632 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
00633 Range r6, Range r7, Range r8, Range r9,
00634 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00635 : storage_(storage)
00636 {
00637 BZPRECONDITION(r0.isAscendingContiguous() &&
00638 r1.isAscendingContiguous() && r2.isAscendingContiguous()
00639 && r3.isAscendingContiguous() && r4.isAscendingContiguous()
00640 && r5.isAscendingContiguous() && r6.isAscendingContiguous()
00641 && r7.isAscendingContiguous() && r8.isAscendingContiguous()
00642 && r9.isAscendingContiguous());
00643
00644 length_[0] = r0.length();
00645 storage_.setBase(0, r0.first());
00646 length_[1] = r1.length();
00647 storage_.setBase(1, r1.first());
00648 length_[2] = r2.length();
00649 storage_.setBase(2, r2.first());
00650 length_[3] = r3.length();
00651 storage_.setBase(3, r3.first());
00652 length_[4] = r4.length();
00653 storage_.setBase(4, r4.first());
00654 length_[5] = r5.length();
00655 storage_.setBase(5, r5.first());
00656 length_[6] = r6.length();
00657 storage_.setBase(6, r6.first());
00658 length_[7] = r7.length();
00659 storage_.setBase(7, r7.first());
00660 length_[8] = r8.length();
00661 storage_.setBase(8, r8.first());
00662 length_[9] = r9.length();
00663 storage_.setBase(9, r9.first());
00664
00665 setupStorage(9);
00666 }
00667
00668 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
00669 Range r6, Range r7, Range r8, Range r9, Range r10,
00670 GeneralArrayStorage<N_rank> storage = GeneralArrayStorage<N_rank>())
00671 : storage_(storage)
00672 {
00673 BZPRECONDITION(r0.isAscendingContiguous() &&
00674 r1.isAscendingContiguous() && r2.isAscendingContiguous()
00675 && r3.isAscendingContiguous() && r4.isAscendingContiguous()
00676 && r5.isAscendingContiguous() && r6.isAscendingContiguous()
00677 && r7.isAscendingContiguous() && r8.isAscendingContiguous()
00678 && r9.isAscendingContiguous() && r10.isAscendingContiguous());
00679
00680 length_[0] = r0.length();
00681 storage_.setBase(0, r0.first());
00682 length_[1] = r1.length();
00683 storage_.setBase(1, r1.first());
00684 length_[2] = r2.length();
00685 storage_.setBase(2, r2.first());
00686 length_[3] = r3.length();
00687 storage_.setBase(3, r3.first());
00688 length_[4] = r4.length();
00689 storage_.setBase(4, r4.first());
00690 length_[5] = r5.length();
00691 storage_.setBase(5, r5.first());
00692 length_[6] = r6.length();
00693 storage_.setBase(6, r6.first());
00694 length_[7] = r7.length();
00695 storage_.setBase(7, r7.first());
00696 length_[8] = r8.length();
00697 storage_.setBase(8, r8.first());
00698 length_[9] = r9.length();
00699 storage_.setBase(9, r9.first());
00700 length_[10] = r10.length();
00701 storage_.setBase(10, r10.first());
00702
00703 setupStorage(10);
00704 }
00705
00706
00707
00708
00709 Array(const Array<T_numtype, N_rank>& array)
00710 #ifdef BZ_NEW_EXPRESSION_TEMPLATES
00711 : MemoryBlockReference<T_numtype>(),
00712 ETBase< Array<T_numtype, N_rank> >(array)
00713 #else
00714 : MemoryBlockReference<T_numtype>()
00715 #endif
00716 {
00717
00718 reference(const_cast<T_array&>(array));
00719 }
00720
00721
00722
00723
00724
00725 Array(const TinyVector<int,N_rank-1>& shape,
00726 int lastExtent, const GeneralArrayStorage<N_rank>& storage);
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739 Array(Array<T_numtype, N_rank>& array, Range r0)
00740 {
00741 constructSubarray(array, r0);
00742 }
00743
00744 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1)
00745 {
00746 constructSubarray(array, r0, r1);
00747 }
00748
00749 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2)
00750 {
00751 constructSubarray(array, r0, r1, r2);
00752 }
00753
00754 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
00755 Range r3)
00756 {
00757 constructSubarray(array, r0, r1, r2, r3);
00758 }
00759
00760 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
00761 Range r3, Range r4)
00762 {
00763 constructSubarray(array, r0, r1, r2, r3, r4);
00764 }
00765
00766 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
00767 Range r3, Range r4, Range r5)
00768 {
00769 constructSubarray(array, r0, r1, r2, r3, r4, r5);
00770 }
00771
00772 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
00773 Range r3, Range r4, Range r5, Range r6)
00774 {
00775 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6);
00776 }
00777
00778 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
00779 Range r3, Range r4, Range r5, Range r6, Range r7)
00780 {
00781 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7);
00782 }
00783
00784 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
00785 Range r3, Range r4, Range r5, Range r6, Range r7, Range r8)
00786 {
00787 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7, r8);
00788 }
00789
00790 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
00791 Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9)
00792 {
00793 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9);
00794 }
00795
00796 Array(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
00797 Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9,
00798 Range r10)
00799 {
00800 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10);
00801 }
00802
00803 Array(Array<T_numtype, N_rank>& array,
00804 const RectDomain<N_rank>& subdomain)
00805 {
00806 constructSubarray(array, subdomain);
00807 }
00808
00809
00810 Array(Array<T_numtype, N_rank>& array,
00811 const StridedDomain<N_rank>& subdomain)
00812 {
00813 constructSubarray(array, subdomain);
00814 }
00815
00816
00817
00818
00819
00820
00821 template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4,
00822 typename R5, typename R6, typename R7, typename R8, typename R9, typename R10>
00823 Array(Array<T_numtype,N_rank2>& array, R0 r0, R1 r1, R2 r2,
00824 R3 r3, R4 r4, R5 r5, R6 r6, R7 r7, R8 r8, R9 r9, R10 r10)
00825 {
00826 constructSlice(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10);
00827 }
00828
00830
00832
00833 const TinyVector<int, N_rank>& base() const
00834 { return storage_.base(); }
00835
00836 int base(int rank) const
00837 { return storage_.base(rank); }
00838
00839 iterator begin()
00840 { return iterator(*this); }
00841
00842 const_iterator begin() const
00843 { return const_iterator(*this); }
00844
00845 T_iterator beginFast() const
00846 { return T_iterator(*this); }
00847
00848
00849 template<typename P_numtype2>
00850 Array<P_numtype2,N_rank> chopComponent(P_numtype2 a, int compNum,
00851 int numComponents) const
00852 { return extractComponent(a, compNum, numComponents); }
00853
00854 int cols() const
00855 { return length_[1]; }
00856
00857 int columns() const
00858 { return length_[1]; }
00859
00860 T_array copy() const;
00861
00862
00863
00864
00865
00866
00867
00868 int dataOffset() const
00869 { return dot(storage_.base(), stride_); }
00870
00871 const T_numtype* restrict data() const
00872 { return data_ + dataOffset(); }
00873
00874 T_numtype* restrict data()
00875 { return data_ + dataOffset(); }
00876
00877
00878
00879
00880 const T_numtype* restrict dataZero() const
00881 { return data_; }
00882
00883 T_numtype* restrict dataZero()
00884 { return data_; }
00885
00886
00887
00888
00889 int dataFirstOffset() const
00890 {
00891 int pos = 0;
00892
00893
00894
00895
00896
00897 for (int i=0; i < N_rank; ++i)
00898 pos += (storage_.base(i) + (1-storage_.isRankStoredAscending(i)) *
00899 (length_(i)-1)) * stride_(i);
00900
00901 return pos;
00902 }
00903
00904 const T_numtype* restrict dataFirst() const
00905 { return data_ + dataFirstOffset(); }
00906
00907 T_numtype* restrict dataFirst()
00908 { return data_ + dataFirstOffset(); }
00909
00910 int depth() const
00911 { return length_[2]; }
00912
00913 int dimensions() const
00914 { return N_rank; }
00915
00916 RectDomain<N_rank> domain() const
00917 { return RectDomain<N_rank>(lbound(), ubound()); }
00918
00919 void dumpStructureInformation(ostream& os = cout) const;
00920
00921 iterator end()
00922 { return iterator(*this,0); }
00923
00924 const_iterator end() const
00925 { return const_iterator(*this,0); }
00926
00927 int extent(int rank) const
00928 { return length_[rank]; }
00929
00930 const TinyVector<int,N_rank>& extent() const
00931 { return length_; }
00932
00933 template<typename P_numtype2>
00934 Array<P_numtype2,N_rank> extractComponent(P_numtype2, int compNum,
00935 int numComponents) const;
00936
00937 void free()
00938 {
00939 T_base::changeToNullBlock();
00940 length_ = 0;
00941 }
00942
00943 bool isMajorRank(int rank) const
00944 { return storage_.ordering(rank) == N_rank-1; }
00945 bool isMinorRank(int rank) const
00946 { return storage_.ordering(rank) != N_rank-1; }
00947 bool isRankStoredAscending(int rank) const
00948 { return storage_.isRankStoredAscending(rank); }
00949
00950 bool isStorageContiguous() const;
00951
00952 int lbound(int rank) const
00953 { return base(rank); }
00954 TinyVector<int,N_rank> lbound() const
00955 { return base(); }
00956
00957 int length(int rank) const
00958 { return length_[rank]; }
00959 const TinyVector<int, N_rank>& length() const
00960 { return length_; }
00961
00962 void makeUnique();
00963
00964 int numElements() const
00965 { return product(length_); }
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975 int ordering(int storageRankIndex) const
00976 { return storage_.ordering(storageRankIndex); }
00977
00978 const TinyVector<int, N_rank>& ordering() const
00979 { return storage_.ordering(); }
00980
00981 void transposeSelf(int r0, int r1, int r2=0,
00982 int r3=0, int r4=0, int r5=0, int r6=0, int r7=0, int r8=0, int
00983 r9=0, int r10=0);
00984 T_array transpose(int r0, int r1, int r2=0,
00985 int r3=0, int r4=0, int r5=0, int r6=0, int r7=0, int r8=0, int
00986 r9=0, int r10=0) const;
00987
00988 int rank() const
00989 { return N_rank; }
00990
00991 void reference(const T_array&);
00992 void weakReference(const T_array&);
00993
00994
00995 T_array reindex(const TinyVector<int,N_rank>&);
00996 void reindexSelf(
00997 const TinyVector<int,N_rank>&);
00998
00999 void resize(int extent);
01000 void resize(int extent1, int extent2);
01001 void resize(int extent1, int extent2,
01002 int extent3);
01003 void resize(int extent1, int extent2,
01004 int extent3, int extent4);
01005 void resize(int extent1, int extent2,
01006 int extent3, int extent4, int extent5);
01007 void resize(int extent1, int extent2,
01008 int extent3, int extent4, int extent5,
01009 int extent6);
01010 void resize(int extent1, int extent2,
01011 int extent3, int extent4, int extent5,
01012 int extent6, int extent7);
01013 void resize(int extent1, int extent2,
01014 int extent3, int extent4, int extent5,
01015 int extent6, int extent7, int extent8);
01016 void resize(int extent1, int extent2,
01017 int extent3, int extent4, int extent5,
01018 int extent6, int extent7, int extent8,
01019 int extent9);
01020 void resize(int extent1, int extent2,
01021 int extent3, int extent4, int extent5,
01022 int extent6, int extent7, int extent8,
01023 int extent9, int extent10);
01024 void resize(int extent1, int extent2,
01025 int extent3, int extent4, int extent5,
01026 int extent6, int extent7, int extent8,
01027 int extent9, int extent10,
01028 int extent11);
01029
01030
01031 void resize(Range r1);
01032 void resize(Range r1, Range r2);
01033 void resize(Range r1, Range r2, Range r3);
01034 void resize(Range r1, Range r2, Range r3,
01035 Range r4);
01036 void resize(Range r1, Range r2, Range r3,
01037 Range r4, Range r5);
01038 void resize(Range r1, Range r2, Range r3,
01039 Range r4, Range r5, Range r6);
01040 void resize(Range r1, Range r2, Range r3,
01041 Range r4, Range r5, Range r6,
01042 Range r7);
01043 void resize(Range r1, Range r2, Range r3,
01044 Range r4, Range r5, Range r6,
01045 Range r7, Range r8);
01046 void resize(Range r1, Range r2, Range r3,
01047 Range r4, Range r5, Range r6,
01048 Range r7, Range r8, Range r9);
01049 void resize(Range r1, Range r2, Range r3,
01050 Range r4, Range r5, Range r6,
01051 Range r7, Range r8, Range r9,
01052 Range r10);
01053 void resize(Range r1, Range r2, Range r3,
01054 Range r4, Range r5, Range r6,
01055 Range r7, Range r8, Range r9,
01056 Range r10, Range r11);
01057
01058 void resize(const TinyVector<int,N_rank>&);
01059
01060
01061 void resizeAndPreserve(const TinyVector<int,
01062 N_rank>&);
01063 void resizeAndPreserve(int extent);
01064 void resizeAndPreserve(int extent1,
01065 int extent2);
01066 void resizeAndPreserve(int extent1,
01067 int extent2, int extent3);
01068 void resizeAndPreserve(int extent1,
01069 int extent2, int extent3, int extent4);
01070 void resizeAndPreserve(int extent1,
01071 int extent2, int extent3, int extent4,
01072 int extent5);
01073 void resizeAndPreserve(int extent1,
01074 int extent2, int extent3, int extent4,
01075 int extent5, int extent6);
01076 void resizeAndPreserve(int extent1,
01077 int extent2, int extent3, int extent4,
01078 int extent5, int extent6, int extent7);
01079 void resizeAndPreserve(int extent1,
01080 int extent2, int extent3, int extent4,
01081 int extent5, int extent6, int extent7,
01082 int extent8);
01083 void resizeAndPreserve(int extent1,
01084 int extent2, int extent3, int extent4,
01085 int extent5, int extent6, int extent7,
01086 int extent8, int extent9);
01087 void resizeAndPreserve(int extent1,
01088 int extent2, int extent3, int extent4,
01089 int extent5, int extent6, int extent7,
01090 int extent8, int extent9,
01091 int extent10);
01092 void resizeAndPreserve(int extent1,
01093 int extent2, int extent3, int extent4,
01094 int extent5, int extent6, int extent7,
01095 int extent8, int extent9, int extent10,
01096 int extent11);
01097
01098
01099
01100
01101 T_array reverse(int rank);
01102 void reverseSelf(int rank);
01103
01104 int rows() const
01105 { return length_[0]; }
01106
01107 void setStorage(GeneralArrayStorage<N_rank>);
01108
01109 void slice(int rank, Range r);
01110
01111 const TinyVector<int, N_rank>& shape() const
01112 { return length_; }
01113
01114 int size() const
01115 { return numElements(); }
01116
01117 const TinyVector<int, N_rank>& stride() const
01118 { return stride_; }
01119
01120 int stride(int rank) const
01121 { return stride_[rank]; }
01122
01123 bool threadLocal(bool disableLock = true) const
01124 { return T_base::lockReferenceCount(!disableLock); }
01125
01126 int ubound(int rank) const
01127 { return base(rank) + length_(rank) - 1; }
01128
01129 TinyVector<int, N_rank> ubound() const
01130 {
01131 TinyVector<int, N_rank> ub;
01132 for (int i=0; i < N_rank; ++i)
01133 ub(i) = base(i) + extent(i) - 1;
01134
01135 return ub;
01136 }
01137
01138 int zeroOffset() const
01139 { return zeroOffset_; }
01140
01142
01144
01145 bool isInRangeForDim(int i, int d) const {
01146 return i >= base(d) && (i - base(d)) < length_[d];
01147 }
01148
01149 bool isInRange(int i0) const {
01150 return i0 >= base(0) && (i0 - base(0)) < length_[0];
01151 }
01152
01153 bool isInRange(int i0, int i1) const {
01154 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01155 && i1 >= base(1) && (i1 - base(1)) < length_[1];
01156 }
01157
01158 bool isInRange(int i0, int i1, int i2) const {
01159 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01160 && i1 >= base(1) && (i1 - base(1)) < length_[1]
01161 && i2 >= base(2) && (i2 - base(2)) < length_[2];
01162 }
01163
01164 bool isInRange(int i0, int i1, int i2, int i3) const {
01165 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01166 && i1 >= base(1) && (i1 - base(1)) < length_[1]
01167 && i2 >= base(2) && (i2 - base(2)) < length_[2]
01168 && i3 >= base(3) && (i3 - base(3)) < length_[3];
01169 }
01170
01171 bool isInRange(int i0, int i1, int i2, int i3, int i4) const {
01172 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01173 && i1 >= base(1) && (i1 - base(1)) < length_[1]
01174 && i2 >= base(2) && (i2 - base(2)) < length_[2]
01175 && i3 >= base(3) && (i3 - base(3)) < length_[3]
01176 && i4 >= base(4) && (i4 - base(4)) < length_[4];
01177 }
01178
01179 bool isInRange(int i0, int i1, int i2, int i3, int i4, int i5) const {
01180 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01181 && i1 >= base(1) && (i1 - base(1)) < length_[1]
01182 && i2 >= base(2) && (i2 - base(2)) < length_[2]
01183 && i3 >= base(3) && (i3 - base(3)) < length_[3]
01184 && i4 >= base(4) && (i4 - base(4)) < length_[4]
01185 && i5 >= base(5) && (i5 - base(5)) < length_[5];
01186 }
01187
01188 bool isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6) const {
01189 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01190 && i1 >= base(1) && (i1 - base(1)) < length_[1]
01191 && i2 >= base(2) && (i2 - base(2)) < length_[2]
01192 && i3 >= base(3) && (i3 - base(3)) < length_[3]
01193 && i4 >= base(4) && (i4 - base(4)) < length_[4]
01194 && i5 >= base(5) && (i5 - base(5)) < length_[5]
01195 && i6 >= base(6) && (i6 - base(6)) < length_[6];
01196 }
01197
01198 bool isInRange(int i0, int i1, int i2, int i3, int i4,
01199 int i5, int i6, int i7) const {
01200 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01201 && i1 >= base(1) && (i1 - base(1)) < length_[1]
01202 && i2 >= base(2) && (i2 - base(2)) < length_[2]
01203 && i3 >= base(3) && (i3 - base(3)) < length_[3]
01204 && i4 >= base(4) && (i4 - base(4)) < length_[4]
01205 && i5 >= base(5) && (i5 - base(5)) < length_[5]
01206 && i6 >= base(6) && (i6 - base(6)) < length_[6]
01207 && i7 >= base(7) && (i7 - base(7)) < length_[7];
01208 }
01209
01210 bool isInRange(int i0, int i1, int i2, int i3, int i4,
01211 int i5, int i6, int i7, int i8) const {
01212 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01213 && i1 >= base(1) && (i1 - base(1)) < length_[1]
01214 && i2 >= base(2) && (i2 - base(2)) < length_[2]
01215 && i3 >= base(3) && (i3 - base(3)) < length_[3]
01216 && i4 >= base(4) && (i4 - base(4)) < length_[4]
01217 && i5 >= base(5) && (i5 - base(5)) < length_[5]
01218 && i6 >= base(6) && (i6 - base(6)) < length_[6]
01219 && i7 >= base(7) && (i7 - base(7)) < length_[7]
01220 && i8 >= base(8) && (i8 - base(8)) < length_[8];
01221 }
01222
01223 bool isInRange(int i0, int i1, int i2, int i3, int i4,
01224 int i5, int i6, int i7, int i8, int i9) const {
01225 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01226 && i1 >= base(1) && (i1 - base(1)) < length_[1]
01227 && i2 >= base(2) && (i2 - base(2)) < length_[2]
01228 && i3 >= base(3) && (i3 - base(3)) < length_[3]
01229 && i4 >= base(4) && (i4 - base(4)) < length_[4]
01230 && i5 >= base(5) && (i5 - base(5)) < length_[5]
01231 && i6 >= base(6) && (i6 - base(6)) < length_[6]
01232 && i7 >= base(7) && (i7 - base(7)) < length_[7]
01233 && i8 >= base(8) && (i8 - base(8)) < length_[8]
01234 && i9 >= base(9) && (i9 - base(9)) < length_[9];
01235 }
01236
01237 bool isInRange(int i0, int i1, int i2, int i3, int i4,
01238 int i5, int i6, int i7, int i8, int i9, int i10) const {
01239 return i0 >= base(0) && (i0 - base(0)) < length_[0]
01240 && i1 >= base(1) && (i1 - base(1)) < length_[1]
01241 && i2 >= base(2) && (i2 - base(2)) < length_[2]
01242 && i3 >= base(3) && (i3 - base(3)) < length_[3]
01243 && i4 >= base(4) && (i4 - base(4)) < length_[4]
01244 && i5 >= base(5) && (i5 - base(5)) < length_[5]
01245 && i6 >= base(6) && (i6 - base(6)) < length_[6]
01246 && i7 >= base(7) && (i7 - base(7)) < length_[7]
01247 && i8 >= base(8) && (i8 - base(8)) < length_[8]
01248 && i9 >= base(9) && (i9 - base(9)) < length_[9]
01249 && i10 >= base(10) && (i10 - base(10)) < length_[10];
01250 }
01251
01252 bool isInRange(const T_index& index) const {
01253 for (int i=0; i < N_rank; ++i)
01254 if (index[i] < base(i) || (index[i] - base(i)) >= length_[i])
01255 return false;
01256
01257 return true;
01258 }
01259
01260 bool assertInRange(const T_index& BZ_DEBUG_PARAM(index)) const {
01261 BZPRECHECK(isInRange(index), "Array index out of range: " << index
01262 << endl << "Lower bounds: " << storage_.base() << endl
01263 << "Length: " << length_ << endl);
01264 return true;
01265 }
01266
01267 bool assertInRange(int BZ_DEBUG_PARAM(i0)) const {
01268 BZPRECHECK(isInRange(i0), "Array index out of range: " << i0
01269 << endl << "Lower bounds: " << storage_.base() << endl
01270 << "Length: " << length_ << endl);
01271 return true;
01272 }
01273
01274 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1)) const {
01275 BZPRECHECK(isInRange(i0,i1), "Array index out of range: ("
01276 << i0 << ", " << i1 << ")"
01277 << endl << "Lower bounds: " << storage_.base() << endl
01278 << "Length: " << length_ << endl);
01279 return true;
01280 }
01281
01282 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
01283 int BZ_DEBUG_PARAM(i2)) const
01284 {
01285 BZPRECHECK(isInRange(i0,i1,i2), "Array index out of range: ("
01286 << i0 << ", " << i1 << ", " << i2 << ")"
01287 << endl << "Lower bounds: " << storage_.base() << endl
01288 << "Length: " << length_ << endl);
01289 return true;
01290 }
01291
01292 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
01293 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3)) const
01294 {
01295 BZPRECHECK(isInRange(i0,i1,i2,i3), "Array index out of range: ("
01296 << i0 << ", " << i1 << ", " << i2 << ", " << i3 << ")"
01297 << endl << "Lower bounds: " << storage_.base() << endl
01298 << "Length: " << length_ << endl);
01299 return true;
01300 }
01301
01302 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
01303 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3),
01304 int BZ_DEBUG_PARAM(i4)) const
01305 {
01306 BZPRECHECK(isInRange(i0,i1,i2,i3,i4), "Array index out of range: ("
01307 << i0 << ", " << i1 << ", " << i2 << ", " << i3
01308 << ", " << i4 << ")"
01309 << endl << "Lower bounds: " << storage_.base() << endl
01310 << "Length: " << length_ << endl);
01311 return true;
01312 }
01313
01314 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
01315 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
01316 int BZ_DEBUG_PARAM(i5)) const
01317 {
01318 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5), "Array index out of range: ("
01319 << i0 << ", " << i1 << ", " << i2 << ", " << i3
01320 << ", " << i4 << ", " << i5 << ")"
01321 << endl << "Lower bounds: " << storage_.base() << endl
01322 << "Length: " << length_ << endl);
01323 return true;
01324 }
01325
01326 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
01327 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
01328 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6)) const
01329 {
01330 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6),
01331 "Array index out of range: ("
01332 << i0 << ", " << i1 << ", " << i2 << ", " << i3
01333 << ", " << i4 << ", " << i5 << ", " << i6 << ")"
01334 << endl << "Lower bounds: " << storage_.base() << endl
01335 << "Length: " << length_ << endl);
01336 return true;
01337 }
01338
01339 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
01340 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
01341 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6),
01342 int BZ_DEBUG_PARAM(i7)) const
01343 {
01344 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7),
01345 "Array index out of range: ("
01346 << i0 << ", " << i1 << ", " << i2 << ", " << i3
01347 << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7 << ")"
01348 << endl << "Lower bounds: " << storage_.base() << endl
01349 << "Length: " << length_ << endl);
01350 return true;
01351 }
01352
01353 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
01354 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
01355 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7),
01356 int BZ_DEBUG_PARAM(i8)) const
01357 {
01358 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7,i8),
01359 "Array index out of range: ("
01360 << i0 << ", " << i1 << ", " << i2 << ", " << i3
01361 << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7
01362 << ", " << i8 << ")"
01363 << endl << "Lower bounds: " << storage_.base() << endl
01364 << "Length: " << length_ << endl);
01365 return true;
01366 }
01367
01368 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
01369 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
01370 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7),
01371 int BZ_DEBUG_PARAM(i8), int BZ_DEBUG_PARAM(i9)) const
01372 {
01373 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7,i8,i9),
01374 "Array index out of range: ("
01375 << i0 << ", " << i1 << ", " << i2 << ", " << i3
01376 << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7
01377 << ", " << i8 << ", " << i9 << ")"
01378 << endl << "Lower bounds: " << storage_.base() << endl
01379 << "Length: " << length_ << endl);
01380 return true;
01381 }
01382
01383 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
01384 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
01385 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7),
01386 int BZ_DEBUG_PARAM(i8), int BZ_DEBUG_PARAM(i9),
01387 int BZ_DEBUG_PARAM(i10)) const
01388 {
01389 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10),
01390 "Array index out of range: ("
01391 << i0 << ", " << i1 << ", " << i2 << ", " << i3
01392 << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7
01393 << ", " << i8 << ", " << i9 << ", " << i10 << ")"
01394 << endl << "Lower bounds: " << storage_.base() << endl
01395 << "Length: " << length_ << endl);
01396 return true;
01397 }
01398
01400
01402
01403 template<int N_rank2>
01404 const T_numtype& restrict operator()(const TinyVector<int,N_rank2>& index) const
01405 {
01406 assertInRange(index);
01407 return data_[dot(index, stride_)];
01408 }
01409
01410 template<int N_rank2>
01411 T_numtype& restrict operator()(const TinyVector<int,N_rank2>& index)
01412 {
01413 assertInRange(index);
01414 return data_[dot(index, stride_)];
01415 }
01416
01417 const T_numtype& restrict operator()(TinyVector<int,1> index) const
01418 {
01419 assertInRange(index[0]);
01420 return data_[index[0] * stride_[0]];
01421 }
01422
01423 T_numtype& operator()(TinyVector<int,1> index)
01424 {
01425 assertInRange(index[0]);
01426 return data_[index[0] * stride_[0]];
01427 }
01428
01429 const T_numtype& restrict operator()(TinyVector<int,2> index) const
01430 {
01431 assertInRange(index[0], index[1]);
01432 return data_[index[0] * stride_[0] + index[1] * stride_[1]];
01433 }
01434
01435 T_numtype& operator()(TinyVector<int,2> index)
01436 {
01437 assertInRange(index[0], index[1]);
01438 return data_[index[0] * stride_[0] + index[1] * stride_[1]];
01439 }
01440
01441 const T_numtype& restrict operator()(TinyVector<int,3> index) const
01442 {
01443 assertInRange(index[0], index[1], index[2]);
01444 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01445 + index[2] * stride_[2]];
01446 }
01447
01448 T_numtype& operator()(TinyVector<int,3> index)
01449 {
01450 assertInRange(index[0], index[1], index[2]);
01451 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01452 + index[2] * stride_[2]];
01453 }
01454
01455 const T_numtype& restrict operator()(const TinyVector<int,4>& index) const
01456 {
01457 assertInRange(index[0], index[1], index[2], index[3]);
01458 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01459 + index[2] * stride_[2] + index[3] * stride_[3]];
01460 }
01461
01462 T_numtype& operator()(const TinyVector<int,4>& index)
01463 {
01464 assertInRange(index[0], index[1], index[2], index[3]);
01465 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01466 + index[2] * stride_[2] + index[3] * stride_[3]];
01467 }
01468
01469 const T_numtype& restrict operator()(const TinyVector<int,5>& index) const
01470 {
01471 assertInRange(index[0], index[1], index[2], index[3],
01472 index[4]);
01473 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01474 + index[2] * stride_[2] + index[3] * stride_[3]
01475 + index[4] * stride_[4]];
01476 }
01477
01478 T_numtype& operator()(const TinyVector<int,5>& index)
01479 {
01480 assertInRange(index[0], index[1], index[2], index[3],
01481 index[4]);
01482 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01483 + index[2] * stride_[2] + index[3] * stride_[3]
01484 + index[4] * stride_[4]];
01485 }
01486
01487 const T_numtype& restrict operator()(const TinyVector<int,6>& index) const
01488 {
01489 assertInRange(index[0], index[1], index[2], index[3],
01490 index[4], index[5]);
01491 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01492 + index[2] * stride_[2] + index[3] * stride_[3]
01493 + index[4] * stride_[4] + index[5] * stride_[5]];
01494 }
01495
01496 T_numtype& operator()(const TinyVector<int,6>& index)
01497 {
01498 assertInRange(index[0], index[1], index[2], index[3],
01499 index[4], index[5]);
01500 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01501 + index[2] * stride_[2] + index[3] * stride_[3]
01502 + index[4] * stride_[4] + index[5] * stride_[5]];
01503 }
01504
01505 const T_numtype& restrict operator()(const TinyVector<int,7>& index) const
01506 {
01507 assertInRange(index[0], index[1], index[2], index[3],
01508 index[4], index[5], index[6]);
01509 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01510 + index[2] * stride_[2] + index[3] * stride_[3]
01511 + index[4] * stride_[4] + index[5] * stride_[5]
01512 + index[6] * stride_[6]];
01513 }
01514
01515 T_numtype& operator()(const TinyVector<int,7>& index)
01516 {
01517 assertInRange(index[0], index[1], index[2], index[3],
01518 index[4], index[5], index[6]);
01519 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01520 + index[2] * stride_[2] + index[3] * stride_[3]
01521 + index[4] * stride_[4] + index[5] * stride_[5]
01522 + index[6] * stride_[6]];
01523 }
01524
01525 const T_numtype& restrict operator()(const TinyVector<int,8>& index) const
01526 {
01527 assertInRange(index[0], index[1], index[2], index[3],
01528 index[4], index[5], index[6], index[7]);
01529 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01530 + index[2] * stride_[2] + index[3] * stride_[3]
01531 + index[4] * stride_[4] + index[5] * stride_[5]
01532 + index[6] * stride_[6] + index[7] * stride_[7]];
01533 }
01534
01535 T_numtype& operator()(const TinyVector<int,8>& index)
01536 {
01537 assertInRange(index[0], index[1], index[2], index[3],
01538 index[4], index[5], index[6], index[7]);
01539 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01540 + index[2] * stride_[2] + index[3] * stride_[3]
01541 + index[4] * stride_[4] + index[5] * stride_[5]
01542 + index[6] * stride_[6] + index[7] * stride_[7]];
01543 }
01544
01545 const T_numtype& restrict operator()(const TinyVector<int,9>& index) const
01546 {
01547 assertInRange(index[0], index[1], index[2], index[3],
01548 index[4], index[5], index[6], index[7], index[8]);
01549 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01550 + index[2] * stride_[2] + index[3] * stride_[3]
01551 + index[4] * stride_[4] + index[5] * stride_[5]
01552 + index[6] * stride_[6] + index[7] * stride_[7]
01553 + index[8] * stride_[8]];
01554 }
01555
01556 T_numtype& operator()(const TinyVector<int,9>& index)
01557 {
01558 assertInRange(index[0], index[1], index[2], index[3],
01559 index[4], index[5], index[6], index[7], index[8]);
01560 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01561 + index[2] * stride_[2] + index[3] * stride_[3]
01562 + index[4] * stride_[4] + index[5] * stride_[5]
01563 + index[6] * stride_[6] + index[7] * stride_[7]
01564 + index[8] * stride_[8]];
01565 }
01566
01567 const T_numtype& restrict operator()(const TinyVector<int,10>& index) const
01568 {
01569 assertInRange(index[0], index[1], index[2], index[3],
01570 index[4], index[5], index[6], index[7], index[8], index[9]);
01571 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01572 + index[2] * stride_[2] + index[3] * stride_[3]
01573 + index[4] * stride_[4] + index[5] * stride_[5]
01574 + index[6] * stride_[6] + index[7] * stride_[7]
01575 + index[8] * stride_[8] + index[9] * stride_[9]];
01576 }
01577
01578 T_numtype& operator()(const TinyVector<int,10>& index)
01579 {
01580 assertInRange(index[0], index[1], index[2], index[3],
01581 index[4], index[5], index[6], index[7], index[8], index[9]);
01582 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01583 + index[2] * stride_[2] + index[3] * stride_[3]
01584 + index[4] * stride_[4] + index[5] * stride_[5]
01585 + index[6] * stride_[6] + index[7] * stride_[7]
01586 + index[8] * stride_[8] + index[9] * stride_[9]];
01587 }
01588
01589 const T_numtype& restrict operator()(const TinyVector<int,11>& index) const
01590 {
01591 assertInRange(index[0], index[1], index[2], index[3],
01592 index[4], index[5], index[6], index[7], index[8], index[9],
01593 index[10]);
01594 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01595 + index[2] * stride_[2] + index[3] * stride_[3]
01596 + index[4] * stride_[4] + index[5] * stride_[5]
01597 + index[6] * stride_[6] + index[7] * stride_[7]
01598 + index[8] * stride_[8] + index[9] * stride_[9]
01599 + index[10] * stride_[10]];
01600 }
01601
01602 T_numtype& operator()(const TinyVector<int,11>& index)
01603 {
01604 assertInRange(index[0], index[1], index[2], index[3],
01605 index[4], index[5], index[6], index[7], index[8], index[9],
01606 index[10]);
01607 return data_[index[0] * stride_[0] + index[1] * stride_[1]
01608 + index[2] * stride_[2] + index[3] * stride_[3]
01609 + index[4] * stride_[4] + index[5] * stride_[5]
01610 + index[6] * stride_[6] + index[7] * stride_[7]
01611 + index[8] * stride_[8] + index[9] * stride_[9]
01612 + index[10] * stride_[10]];
01613 }
01614
01615 const T_numtype& restrict operator()(int i0) const
01616 {
01617 assertInRange(i0);
01618 return data_[i0 * stride_[0]];
01619 }
01620
01621 T_numtype& restrict operator()(int i0)
01622 {
01623 assertInRange(i0);
01624 return data_[i0 * stride_[0]];
01625 }
01626
01627 const T_numtype& restrict operator()(int i0, int i1) const
01628 {
01629 assertInRange(i0, i1);
01630 return data_[i0 * stride_[0] + i1 * stride_[1]];
01631 }
01632
01633 T_numtype& restrict operator()(int i0, int i1)
01634 {
01635 assertInRange(i0, i1);
01636 return data_[i0 * stride_[0] + i1 * stride_[1]];
01637 }
01638
01639 const T_numtype& restrict operator()(int i0, int i1, int i2) const
01640 {
01641 assertInRange(i0, i1, i2);
01642 return data_[i0 * stride_[0] + i1 * stride_[1]
01643 + i2 * stride_[2]];
01644 }
01645
01646 T_numtype& restrict operator()(int i0, int i1, int i2)
01647 {
01648 assertInRange(i0, i1, i2);
01649 return data_[i0 * stride_[0] + i1 * stride_[1]
01650 + i2 * stride_[2]];
01651 }
01652
01653 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3) const
01654 {
01655 assertInRange(i0, i1, i2, i3);
01656 return data_[i0 * stride_[0] + i1 * stride_[1]
01657 + i2 * stride_[2] + i3 * stride_[3]];
01658 }
01659
01660 T_numtype& restrict operator()(int i0, int i1, int i2, int i3)
01661 {
01662 assertInRange(i0, i1, i2, i3);
01663 return data_[i0 * stride_[0] + i1 * stride_[1]
01664 + i2 * stride_[2] + i3 * stride_[3]];
01665 }
01666
01667 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01668 int i4) const
01669 {
01670 assertInRange(i0, i1, i2, i3, i4);
01671 return data_[i0 * stride_[0] + i1 * stride_[1]
01672 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]];
01673 }
01674
01675 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01676 int i4)
01677 {
01678 assertInRange(i0, i1, i2, i3, i4);
01679 return data_[i0 * stride_[0] + i1 * stride_[1]
01680 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]];
01681 }
01682
01683 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01684 int i4, int i5) const
01685 {
01686 assertInRange(i0, i1, i2, i3, i4, i5);
01687 return data_[i0 * stride_[0] + i1 * stride_[1]
01688 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01689 + i5 * stride_[5]];
01690 }
01691
01692 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01693 int i4, int i5)
01694 {
01695 assertInRange(i0, i1, i2, i3, i4, i5);
01696 return data_[i0 * stride_[0] + i1 * stride_[1]
01697 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01698 + i5 * stride_[5]];
01699 }
01700
01701 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01702 int i4, int i5, int i6) const
01703 {
01704 assertInRange(i0, i1, i2, i3, i4, i5, i6);
01705 return data_[i0 * stride_[0] + i1 * stride_[1]
01706 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01707 + i5 * stride_[5] + i6 * stride_[6]];
01708 }
01709
01710 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01711 int i4, int i5, int i6)
01712 {
01713 assertInRange(i0, i1, i2, i3, i4, i5, i6);
01714 return data_[i0 * stride_[0] + i1 * stride_[1]
01715 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01716 + i5 * stride_[5] + i6 * stride_[6]];
01717 }
01718
01719 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01720 int i4, int i5, int i6, int i7) const
01721 {
01722 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7);
01723 return data_[i0 * stride_[0] + i1 * stride_[1]
01724 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01725 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]];
01726 }
01727
01728 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01729 int i4, int i5, int i6, int i7)
01730 {
01731 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7);
01732 return data_[i0 * stride_[0] + i1 * stride_[1]
01733 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01734 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]];
01735 }
01736
01737 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01738 int i4, int i5, int i6, int i7, int i8) const
01739 {
01740 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8);
01741 return data_[i0 * stride_[0] + i1 * stride_[1]
01742 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01743 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
01744 + i8 * stride_[8]];
01745 }
01746
01747 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01748 int i4, int i5, int i6, int i7, int i8)
01749 {
01750 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8);
01751 return data_[i0 * stride_[0] + i1 * stride_[1]
01752 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01753 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
01754 + i8 * stride_[8]];
01755 }
01756
01757 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01758 int i4, int i5, int i6, int i7, int i8, int i9) const
01759 {
01760 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);
01761 return data_[i0 * stride_[0] + i1 * stride_[1]
01762 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01763 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
01764 + i8 * stride_[8] + i9 * stride_[9]];
01765 }
01766
01767 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01768 int i4, int i5, int i6, int i7, int i8, int i9)
01769 {
01770 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);
01771 return data_[i0 * stride_[0] + i1 * stride_[1]
01772 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01773 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
01774 + i8 * stride_[8] + i9 * stride_[9]];
01775 }
01776
01777 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01778 int i4, int i5, int i6, int i7, int i8, int i9, int i10) const
01779 {
01780 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8,
01781 i9, i10);
01782 return data_[i0 * stride_[0] + i1 * stride_[1]
01783 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01784 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
01785 + i8 * stride_[8] + i9 * stride_[9] + i10 * stride_[10]];
01786 }
01787
01788 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
01789 int i4, int i5, int i6, int i7, int i8, int i9, int i10)
01790 {
01791 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8,
01792 i9, i10);
01793 return data_[i0 * stride_[0] + i1 * stride_[1]
01794 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
01795 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
01796 + i8 * stride_[8] + i9 * stride_[9] + i10 * stride_[10]];
01797 }
01798
01799
01800
01801
01802
01803
01804 T_array& noConst() const
01805 { return const_cast<T_array&>(*this); }
01806
01807 T_array operator()(const RectDomain<N_rank>& subdomain) const
01808 {
01809 return T_array(noConst(), subdomain);
01810 }
01811
01812
01813 T_array operator()(const StridedDomain<N_rank>& subdomain) const
01814 {
01815 return T_array(noConst(), subdomain);
01816 }
01817
01818 T_array operator()(Range r0) const
01819 {
01820 return T_array(noConst(), r0);
01821 }
01822
01823 T_array operator()(Range r0, Range r1) const
01824 {
01825 return T_array(noConst(), r0, r1);
01826 }
01827
01828 T_array operator()(Range r0, Range r1, Range r2) const
01829 {
01830 return T_array(noConst(), r0, r1, r2);
01831 }
01832
01833 T_array operator()(Range r0, Range r1, Range r2, Range r3) const
01834 {
01835 return T_array(noConst(), r0, r1, r2, r3);
01836 }
01837
01838 T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4) const
01839 {
01840 return T_array(noConst(), r0, r1, r2, r3, r4);
01841 }
01842
01843 T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
01844 Range r5) const
01845 {
01846 return T_array(noConst(), r0, r1, r2, r3, r4, r5);
01847 }
01848
01849 T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
01850 Range r5, Range r6) const
01851 {
01852 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6);
01853 }
01854
01855 T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
01856 Range r5, Range r6, Range r7) const
01857 {
01858 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7);
01859 }
01860
01861 T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
01862 Range r5, Range r6, Range r7, Range r8) const
01863 {
01864 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7, r8);
01865 }
01866
01867 T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
01868 Range r5, Range r6, Range r7, Range r8, Range r9) const
01869 {
01870 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7, r8, r9);
01871 }
01872
01873 T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
01874 Range r5, Range r6, Range r7, Range r8, Range r9, Range r10) const
01875 {
01876 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10);
01877 }
01878
01879
01880
01881
01882
01883
01884
01885
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900
01901
01902 #ifdef BZ_HAVE_PARTIAL_ORDERING
01903
01904 template<typename T1, typename T2>
01905 typename SliceInfo<T_numtype,T1,T2>::T_slice
01906 operator()(T1 r1, T2 r2) const
01907 {
01908 typedef typename SliceInfo<T_numtype,T1,T2>::T_slice slice;
01909 return slice(noConst(), r1, r2, nilArraySection(), nilArraySection(), nilArraySection(),
01910 nilArraySection(), nilArraySection(), nilArraySection(),
01911 nilArraySection(), nilArraySection(), nilArraySection());
01912 }
01913
01914 template<typename T1, typename T2, typename T3>
01915 typename SliceInfo<T_numtype,T1,T2,T3>::T_slice
01916 operator()(T1 r1, T2 r2, T3 r3) const
01917 {
01918 typedef typename SliceInfo<T_numtype,T1,T2,T3>::T_slice slice;
01919 return slice(noConst(), r1, r2, r3, nilArraySection(), nilArraySection(), nilArraySection(),
01920 nilArraySection(), nilArraySection(), nilArraySection(),
01921 nilArraySection(), nilArraySection());
01922 }
01923
01924 template<typename T1, typename T2, typename T3, typename T4>
01925 typename SliceInfo<T_numtype,T1,T2,T3,T4>::T_slice
01926 operator()(T1 r1, T2 r2, T3 r3, T4 r4) const
01927 {
01928 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4>::T_slice slice;
01929 return slice(noConst(), r1, r2, r3, r4, nilArraySection(), nilArraySection(),
01930 nilArraySection(), nilArraySection(), nilArraySection(),
01931 nilArraySection(), nilArraySection());
01932 }
01933
01934 template<typename T1, typename T2, typename T3, typename T4, typename T5>
01935 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5>::T_slice
01936 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5) const
01937 {
01938 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5>::T_slice slice;
01939 return slice(noConst(), r1, r2, r3, r4, r5, nilArraySection(),
01940 nilArraySection(), nilArraySection(), nilArraySection(),
01941 nilArraySection(), nilArraySection());
01942 }
01943
01944 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
01945 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6>::T_slice
01946 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6) const
01947 {
01948 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6>::T_slice slice;
01949 return slice(noConst(), r1, r2, r3, r4, r5, r6, nilArraySection(), nilArraySection(), nilArraySection(),
01950 nilArraySection(), nilArraySection());
01951 }
01952
01953 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
01954 typename T7>
01955 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7>::T_slice
01956 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7) const
01957 {
01958 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7>::T_slice slice;
01959 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, nilArraySection(), nilArraySection(),
01960 nilArraySection(), nilArraySection());
01961 }
01962
01963 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
01964 typename T7, typename T8>
01965 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8>::T_slice
01966 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8) const
01967 {
01968 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8>::T_slice slice;
01969 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8,
01970 nilArraySection(), nilArraySection(), nilArraySection());
01971 }
01972
01973 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
01974 typename T7, typename T8, typename T9>
01975 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_slice
01976 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8, T9 r9) const
01977 {
01978 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_slice slice;
01979 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8, r9, nilArraySection(), nilArraySection());
01980 }
01981
01982 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
01983 typename T7, typename T8, typename T9, typename T10>
01984 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_slice
01985 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8, T9 r9, T10 r10) const
01986 {
01987 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_slice slice;
01988 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, nilArraySection());
01989 }
01990
01991 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
01992 typename T7, typename T8, typename T9, typename T10, typename T11>
01993 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_slice
01994 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8, T9 r9, T10 r10, T11 r11) const
01995 {
01996 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_slice slice;
01997 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11);
01998 }
01999
02000 #endif // BZ_HAVE_PARTIAL_ORDERING
02001
02002
02003
02004
02005
02006
02007
02008
02009
02010
02011
02012
02013 template<int N0>
02014 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0> >
02015 operator()(IndexPlaceholder<N0>) const
02016 {
02017 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0> >
02018 (noConst());
02019 }
02020
02021 template<int N0, int N1>
02022 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1> >
02023 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>) const
02024 {
02025 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02026 N1> >(noConst());
02027 }
02028
02029 template<int N0, int N1, int N2>
02030 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2> >
02031 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
02032 IndexPlaceholder<N2>) const
02033 {
02034 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02035 N1, N2> >(noConst());
02036 }
02037
02038 template<int N0, int N1, int N2, int N3>
02039 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3> >
02040 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
02041 IndexPlaceholder<N2>, IndexPlaceholder<N3>) const
02042 {
02043 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02044 N1, N2, N3> >(noConst());
02045 }
02046
02047 template<int N0, int N1, int N2, int N3, int N4>
02048 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3, N4> >
02049 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
02050 IndexPlaceholder<N2>, IndexPlaceholder<N3>,
02051 IndexPlaceholder<N4>) const
02052 {
02053 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02054 N1, N2, N3, N4> >(noConst());
02055 }
02056
02057 template<int N0, int N1, int N2, int N3, int N4, int N5>
02058 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
02059 N4, N5> >
02060 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
02061 IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
02062 IndexPlaceholder<N5>) const
02063 {
02064 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02065 N1, N2, N3, N4, N5> >(noConst());
02066 }
02067
02068 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6>
02069 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
02070 N4, N5, N6> >
02071 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
02072 IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
02073 IndexPlaceholder<N5>, IndexPlaceholder<N6>) const
02074 {
02075 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02076 N1, N2, N3, N4, N5, N6> >(noConst());
02077 }
02078
02079 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
02080 int N7>
02081 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
02082 N4, N5, N6, N7> >
02083 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
02084 IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
02085 IndexPlaceholder<N5>, IndexPlaceholder<N6>,
02086 IndexPlaceholder<N7>) const
02087 {
02088 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02089 N1, N2, N3, N4, N5, N6, N7> >(noConst());
02090 }
02091
02092 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
02093 int N7, int N8>
02094 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
02095 N4, N5, N6, N7, N8> >
02096 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
02097 IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
02098 IndexPlaceholder<N5>, IndexPlaceholder<N6>, IndexPlaceholder<N7>,
02099 IndexPlaceholder<N8>) const
02100 {
02101 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02102 N1, N2, N3, N4, N5, N6, N7, N8> >(noConst());
02103 }
02104
02105 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
02106 int N7, int N8, int N9>
02107 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
02108 N4, N5, N6, N7, N8, N9> >
02109 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
02110 IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
02111 IndexPlaceholder<N5>, IndexPlaceholder<N6>, IndexPlaceholder<N7>,
02112 IndexPlaceholder<N8>, IndexPlaceholder<N9>) const
02113 {
02114 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02115 N1, N2, N3, N4, N5, N6, N7, N8, N9> >(noConst());
02116 }
02117
02118 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
02119 int N7, int N8, int N9, int N10>
02120 _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0, N1, N2, N3,
02121 N4, N5, N6, N7, N8, N9, N10> >
02122 operator()(IndexPlaceholder<N0>, IndexPlaceholder<N1>,
02123 IndexPlaceholder<N2>, IndexPlaceholder<N3>, IndexPlaceholder<N4>,
02124 IndexPlaceholder<N5>, IndexPlaceholder<N6>, IndexPlaceholder<N7>,
02125 IndexPlaceholder<N8>, IndexPlaceholder<N9>,
02126 IndexPlaceholder<N10>) const
02127 {
02128 return _bz_ArrayExpr<ArrayIndexMapping<T_numtype, N_rank, N0,
02129 N1, N2, N3, N4, N5, N6, N7, N8, N9, N10> >(noConst());
02130 }
02131
02133
02135
02136
02137
02138
02139
02140
02141 Array<typename multicomponent_traits<T_numtype>::T_element,N_rank>
02142 operator[](const unsigned component) {
02143 typedef typename multicomponent_traits<T_numtype>::T_element T_compType;
02144
02145 return extractComponent(T_compType(),component,
02146 multicomponent_traits<T_numtype>::numComponents);
02147 }
02148
02149 const Array<typename multicomponent_traits<T_numtype>::T_element,N_rank>
02150 operator[](const unsigned component) const {
02151 typedef typename multicomponent_traits<T_numtype>::T_element T_compType;
02152
02153 return extractComponent(T_compType(),component,
02154 multicomponent_traits<T_numtype>::numComponents);
02155 }
02156
02157 Array<typename multicomponent_traits<T_numtype>::T_element,N_rank>
02158 operator[](const int component) {
02159 return operator[](static_cast<unsigned>(component));
02160 }
02161
02162 const Array<typename multicomponent_traits<T_numtype>::T_element,N_rank>
02163 operator[](const int component) const {
02164 return operator[](static_cast<unsigned>(component));
02165 }
02166
02168
02170
02171 template<typename T_indexContainer>
02172 IndirectArray<T_array, T_indexContainer>
02173 operator[](const T_indexContainer& index)
02174 {
02175 return IndirectArray<T_array, T_indexContainer>(*this,
02176 const_cast<T_indexContainer&>(index));
02177 }
02178
02180
02182
02183
02184
02185
02186 ListInitializationSwitch<T_array,T_numtype*> operator=(T_numtype x)
02187 {
02188 return ListInitializationSwitch<T_array,T_numtype*>(*this, x);
02189 }
02190
02191 T_array& initialize(T_numtype);
02192
02193
02194
02195
02196 #ifdef BZ_NEW_EXPRESSION_TEMPLATES
02197 template<typename T_expr>
02198 T_array& operator=(const ETBase<T_expr>&);
02199 T_array& operator=(const Array<T_numtype,N_rank>&);
02200
02201 template<typename T> T_array& operator+=(const T&);
02202 template<typename T> T_array& operator-=(const T&);
02203 template<typename T> T_array& operator*=(const T&);
02204 template<typename T> T_array& operator/=(const T&);
02205 template<typename T> T_array& operator%=(const T&);
02206 template<typename T> T_array& operator^=(const T&);
02207 template<typename T> T_array& operator&=(const T&);
02208 template<typename T> T_array& operator|=(const T&);
02209 template<typename T> T_array& operator>>=(const T&);
02210 template<typename T> T_array& operator<<=(const T&);
02211
02212 #else
02213 T_array& operator+=(T_numtype);
02214 T_array& operator-=(T_numtype);
02215 T_array& operator*=(T_numtype);
02216 T_array& operator/=(T_numtype);
02217 T_array& operator%=(T_numtype);
02218 T_array& operator^=(T_numtype);
02219 T_array& operator&=(T_numtype);
02220 T_array& operator|=(T_numtype);
02221 T_array& operator>>=(T_numtype);
02222 T_array& operator<<=(T_numtype);
02223
02224
02225 T_array& operator=(const Array<T_numtype,N_rank>&);
02226
02227 template<typename P_numtype2>
02228 T_array& operator=(const Array<P_numtype2,N_rank>&);
02229 template<typename P_numtype2>
02230 T_array& operator+=(const Array<P_numtype2,N_rank>&);
02231 template<typename P_numtype2>
02232 T_array& operator-=(const Array<P_numtype2,N_rank>&);
02233 template<typename P_numtype2>
02234 T_array& operator*=(const Array<P_numtype2,N_rank>&);
02235 template<typename P_numtype2>
02236 T_array& operator/=(const Array<P_numtype2,N_rank>&);
02237 template<typename P_numtype2>
02238 T_array& operator%=(const Array<P_numtype2,N_rank>&);
02239 template<typename P_numtype2>
02240 T_array& operator^=(const Array<P_numtype2,N_rank>&);
02241 template<typename P_numtype2>
02242 T_array& operator&=(const Array<P_numtype2,N_rank>&);
02243 template<typename P_numtype2>
02244 T_array& operator|=(const Array<P_numtype2,N_rank>&);
02245 template<typename P_numtype2>
02246 T_array& operator>>=(const Array<P_numtype2,N_rank>&);
02247 template<typename P_numtype2>
02248 T_array& operator<<=(const Array<P_numtype2,N_rank>&);
02249
02250
02251 template<typename T_expr>
02252 inline T_array& operator=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02253 template<typename T_expr>
02254 inline T_array& operator+=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02255 template<typename T_expr>
02256 inline T_array& operator-=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02257 template<typename T_expr>
02258 inline T_array& operator*=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02259 template<typename T_expr>
02260 inline T_array& operator/=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02261 template<typename T_expr>
02262 inline T_array& operator%=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02263 template<typename T_expr>
02264 inline T_array& operator^=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02265 template<typename T_expr>
02266 inline T_array& operator&=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02267 template<typename T_expr>
02268 inline T_array& operator|=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02269 template<typename T_expr>
02270 inline T_array& operator>>=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02271 template<typename T_expr>
02272 inline T_array& operator<<=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
02273
02274
02275
02276
02277 #endif
02278
02279 public:
02280
02281
02282 template<typename T_expr, typename T_update>
02283 inline T_array& evaluate(T_expr expr, T_update);
02284
02285 #ifdef BZ_HAVE_STD
02286 #ifdef BZ_ARRAY_SPACE_FILLING_TRAVERSAL
02287 template<typename T_expr, typename T_update>
02288 inline T_array& evaluateWithFastTraversal(
02289 const TraversalOrder<N_rank - 1>& order,
02290 T_expr expr, T_update);
02291 #endif // BZ_ARRAY_SPACE_FILLING_TRAVERSAL
02292 #endif
02293
02294 #ifdef BZ_ARRAY_2D_STENCIL_TILING
02295 template<typename T_expr, typename T_update>
02296 inline T_array& evaluateWithTiled2DTraversal(
02297 T_expr expr, T_update);
02298 #endif
02299
02300 template<typename T_expr, typename T_update>
02301 inline T_array& evaluateWithIndexTraversal1(
02302 T_expr expr, T_update);
02303
02304 template<typename T_expr, typename T_update>
02305 inline T_array& evaluateWithIndexTraversalN(
02306 T_expr expr, T_update);
02307
02308 template<typename T_expr, typename T_update>
02309 inline T_array& evaluateWithStackTraversal1(
02310 T_expr expr, T_update);
02311
02312 template<typename T_expr, typename T_update>
02313 inline T_array& evaluateWithStackTraversalN(
02314 T_expr expr, T_update);
02315
02316
02317 T_numtype* restrict getInitializationIterator() { return dataFirst(); }
02318
02319 bool canCollapse(int outerRank, int innerRank) const {
02320 #ifdef BZ_DEBUG_TRAVERSE
02321 BZ_DEBUG_MESSAGE("stride(" << innerRank << ")=" << stride(innerRank)
02322 << ", extent()=" << extent(innerRank) << ", stride(outerRank)="
02323 << stride(outerRank));
02324 #endif
02325 return (stride(innerRank) * extent(innerRank) == stride(outerRank));
02326 }
02327
02328 protected:
02330
02332
02333 _bz_inline2 void computeStrides();
02334 _bz_inline2 void setupStorage(int rank);
02335 void constructSubarray(Array<T_numtype, N_rank>& array,
02336 const RectDomain<N_rank>&);
02337 void constructSubarray(Array<T_numtype, N_rank>& array,
02338 const StridedDomain<N_rank>&);
02339 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0);
02340 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0, Range r1);
02341 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
02342 Range r1, Range r2);
02343 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
02344 Range r1, Range r2, Range r3);
02345 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
02346 Range r1, Range r2, Range r3, Range r4);
02347 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
02348 Range r1, Range r2, Range r3, Range r4, Range r5);
02349 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
02350 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6);
02351 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
02352 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
02353 Range r7);
02354 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
02355 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
02356 Range r7, Range r8);
02357 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
02358 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
02359 Range r7, Range r8, Range r9);
02360 void constructSubarray(Array<T_numtype, N_rank>& array, Range r0,
02361 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
02362 Range r7, Range r8, Range r9, Range r10);
02363
02364 void calculateZeroOffset();
02365
02366 template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4,
02367 typename R5, typename R6, typename R7, typename R8, typename R9, typename R10>
02368 void constructSlice(Array<T_numtype, N_rank2>& array, R0 r0, R1 r1, R2 r2,
02369 R3 r3, R4 r4, R5 r5, R6 r6, R7 r7, R8 r8, R9 r9, R10 r10);
02370
02371 template<int N_rank2>
02372 void slice(int& setRank, Range r, Array<T_numtype,N_rank2>& array,
02373 TinyVector<int,N_rank2>& rankMap, int sourceRank);
02374
02375 template<int N_rank2>
02376 void slice(int& setRank, int i, Array<T_numtype,N_rank2>& array,
02377 TinyVector<int,N_rank2>& rankMap, int sourceRank);
02378
02379 template<int N_rank2>
02380 void slice(int&, nilArraySection, Array<T_numtype,N_rank2>&,
02381 TinyVector<int,N_rank2>&, int)
02382 { }
02383
02384 void doTranspose(int destRank, int sourceRank, T_array& array);
02385
02386 protected:
02388
02390
02391
02392
02393
02394
02395
02396
02397
02398
02399
02400
02401
02402
02403
02404
02405
02406
02407
02408 GeneralArrayStorage<N_rank> storage_;
02409 TinyVector<int, N_rank> length_;
02410 TinyVector<int, N_rank> stride_;
02411 int zeroOffset_;
02412 };
02413
02414
02415
02416
02417
02418
02419
02420
02421
02422
02423
02424
02425
02426 const int firstRank = 0;
02427 const int secondRank = 1;
02428 const int thirdRank = 2;
02429 const int fourthRank = 3;
02430 const int fifthRank = 4;
02431 const int sixthRank = 5;
02432 const int seventhRank = 6;
02433 const int eighthRank = 7;
02434 const int ninthRank = 8;
02435 const int tenthRank = 9;
02436 const int eleventhRank = 10;
02437
02438 const int firstDim = 0;
02439 const int secondDim = 1;
02440 const int thirdDim = 2;
02441 const int fourthDim = 3;
02442 const int fifthDim = 4;
02443 const int sixthDim = 5;
02444 const int seventhDim = 6;
02445 const int eighthDim = 7;
02446 const int ninthDim = 8;
02447 const int tenthDim = 9;
02448 const int eleventhDim = 10;
02449
02450
02451
02452
02453
02454 template<typename T_numtype>
02455 ostream& operator<<(ostream&, const Array<T_numtype,1>&);
02456
02457 template<typename T_numtype, int N_rank>
02458 ostream& operator<<(ostream&, const Array<T_numtype,N_rank>&);
02459
02460 template<typename T_numtype, int N_rank>
02461 istream& operator>>(istream& is, Array<T_numtype,N_rank>& x);
02462
02463 template <typename P_numtype,int N_rank>
02464 void swap(Array<P_numtype,N_rank>& a,Array<P_numtype,N_rank>& b) {
02465 Array<P_numtype,N_rank> c(a);
02466 a.reference(b);
02467 b.reference(c);
02468 }
02469
02470 template <typename P_expr>
02471 void find(Array<TinyVector<int,P_expr::rank>,1>& indices,
02472 const _bz_ArrayExpr<P_expr>& expr) {
02473 find(indices,
02474 static_cast< Array<typename P_expr::T_numtype,P_expr::rank> >(expr));
02475 }
02476
02477 template <typename P_numtype, int N_rank>
02478 void find(Array<TinyVector<int,N_rank>,1>& indices,
02479 const Array<P_numtype,N_rank>& exprVals) {
02480 indices.resize(exprVals.size());
02481 typename Array<P_numtype,N_rank>::const_iterator it, end = exprVals.end();
02482 int j=0;
02483 for (it = exprVals.begin(); it != end; ++it)
02484 if (*it)
02485 indices(j++) = it.position();
02486 if (j)
02487 indices.resizeAndPreserve(j);
02488 else
02489 indices.free();
02490 return;
02491 }
02492
02493
02494 BZ_NAMESPACE_END
02495
02496
02497
02498
02499
02500
02501 #include <blitz/array/iter.h>
02502 #include <blitz/array/fastiter.h>
02503 #include <blitz/array/expr.h>
02504 #include <blitz/array/methods.cc>
02505 #include <blitz/array/eval.cc>
02506 #include <blitz/array/ops.cc>
02507 #include <blitz/array/io.cc>
02508 #include <blitz/array/et.h>
02509 #include <blitz/array/reduce.h>
02510 #include <blitz/array/interlace.cc>
02511 #include <blitz/array/resize.cc>
02512 #include <blitz/array/slicing.cc>
02513 #include <blitz/array/cycle.cc>
02514 #include <blitz/array/complex.cc>
02515 #include <blitz/array/zip.h>
02516 #include <blitz/array/where.h>
02517 #include <blitz/array/indirect.h>
02518 #include <blitz/array/stencils.h>
02519
02520 #endif // BZ_ARRAY_H