blitz Version 1.0.2
Loading...
Searching...
No Matches
array-impl.h
Go to the documentation of this file.
1// -*- C++ -*-
2/***************************************************************************
3 * blitz/array-impl.h Definition of the Array<P_numtype, N_rank> class
4 *
5 * $Id$
6 *
7 * Copyright (C) 1997-2011 Todd Veldhuizen <tveldhui@acm.org>
8 *
9 * This file is a part of Blitz.
10 *
11 * Blitz is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License
13 * as published by the Free Software Foundation, either version 3
14 * of the License, or (at your option) any later version.
15 *
16 * Blitz is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with Blitz. If not, see <http://www.gnu.org/licenses/>.
23 *
24 * Suggestions: blitz-devel@lists.sourceforge.net
25 * Bugs: blitz-support@lists.sourceforge.net
26 *
27 * For more information, please see the Blitz++ Home Page:
28 * https://sourceforge.net/projects/blitz/
29 *
30 ***************************************************************************/
31
32/*
33 * Wish list for array classes.
34 * - Arrays whose dimensions are unknown at compile time.
35 * - where()/elsewhere()/elsewhere() as in Dan Quinlan's implementation
36 * - block reduction operations
37 * - conversion to/from matrix & vector
38 * - apply(T func(T))
39 * - apply(T func(const T&))
40 * - apply<T func(T)>
41 */
42
43#ifndef BZ_ARRAY_H
44#define BZ_ARRAY_H
45
46#include <blitz/blitz.h>
47#include <blitz/memblock.h>
48#include <blitz/range.h>
49#include <blitz/tinyvec2.h>
50#include <blitz/tvecglobs.h>
51
52#include <blitz/indexexpr.h>
53
54#include <blitz/array/slice.h> // Subarrays and slicing
55#include <blitz/array/map.h> // Tensor index notation
56#include <blitz/array/multi.h> // Multicomponent arrays
57#include <blitz/array/domain.h> // RectDomain class
58#include <blitz/array/storage.h> // GeneralArrayStorage
59
60#ifdef BZ_HAVE_BOOST_SERIALIZATION
61#include <boost/serialization/serialization.hpp>
62#include <boost/serialization/base_object.hpp>
63#endif
64
65
66namespace blitz {
67
68/*
69 * Forward declarations
70 */
71
72template<typename T_numtype, int N_rank>
74
75template<typename T_numtype, int N_rank>
77
78template<typename T_numtype, int N_rank>
80
81template<typename P_expr>
82class _bz_ArrayExpr;
83
84template<typename T_array, typename T_index>
86
87template <typename P_numtype,int N_rank>
89
90template <typename P_numtype, int N_rank>
92
93
104
105template<typename P_numtype, int N_rank>
106class Array : public MemoryBlockReference<P_numtype>
107#ifdef BZ_NEW_EXPRESSION_TEMPLATES
108 , public ETBase<Array<P_numtype,N_rank> >
109#endif
110{
111
112private:
114 using T_base::data_;
115
116public:
118 // Public Types
120
121 /*
122 * T_numtype is the numeric type stored in the array.
123 * T_index is a vector type which can be used to access elements
124 * of many-dimensional arrays.
125 * T_array is the array type itself -- Array<T_numtype, N_rank>
126 * T_iterator is a a fast iterator for the array, used for expression
127 * templates
128 * iterator is a STL-style iterator
129 * const_iterator is an STL-style const iterator
130 * T_default_storage is the default storage class type for the array
131 */
132
133 typedef P_numtype T_numtype;
137
140
149#if defined(BZ_FORTRAN_ARRAY)
150 typedef FortranArray<N_rank> T_default_storage;
151#elif defined(BZ_COLUMN_MAJOR_ARRAY)
152 typedef ColumnMajorArray<N_rank> T_default_storage;
153#else
154 typedef GeneralArrayStorage<N_rank> T_default_storage;
155#endif
156
157 static const int rank_ = N_rank;
158
160 // Constructors //
162
163
168 template<typename T_expr>
170
171 /*
172 * Any missing length arguments will have their value taken from the
173 * last argument. For example,
174 * Array<int,3> A(32,64);
175 * will create a 32x64x64 array. This is handled by setupStorage().
176 */
177
178 Array(GeneralArrayStorage<N_rank> storage = T_default_storage())
179 : storage_(storage)
180 {
181 length_ = 0;
182 stride_ = 0;
183 zeroOffset_ = 0;
184 }
185
186 explicit Array(int length0,
187 GeneralArrayStorage<N_rank> storage = T_default_storage())
188 : storage_(storage)
189 {
190 length_[0] = length0;
191 setupStorage(0);
192 }
193
194 Array(int length0, int length1,
195 GeneralArrayStorage<N_rank> storage = T_default_storage())
196 : storage_(storage)
197 {
198 BZPRECONDITION(N_rank >= 2);
199 TAU_TYPE_STRING(p1, "Array<T,N>::Array() [T="
200 + CT(T_numtype) + ",N=" + CT(N_rank) + "]");
201 TAU_PROFILE(p1, "void (int,int)", TAU_BLITZ);
202
203 length_[0] = length0;
204 length_[1] = length1;
205 setupStorage(1);
206 }
207
208 Array(int length0, int length1, int length2,
209 GeneralArrayStorage<N_rank> storage = T_default_storage())
210 : storage_(storage)
211 {
212 BZPRECONDITION(N_rank >= 3);
213 length_[0] = length0;
214 length_[1] = length1;
215 length_[2] = length2;
216 setupStorage(2);
217 }
218
219 Array(int length0, int length1, int length2, int length3,
220 GeneralArrayStorage<N_rank> storage = T_default_storage())
221 : storage_(storage)
222 {
223 BZPRECONDITION(N_rank >= 4);
224 length_[0] = length0;
225 length_[1] = length1;
226 length_[2] = length2;
227 length_[3] = length3;
228 setupStorage(3);
229 }
230
231 Array(int length0, int length1, int length2, int length3, int length4,
232 GeneralArrayStorage<N_rank> storage = T_default_storage())
233 : storage_(storage)
234 {
235 BZPRECONDITION(N_rank >= 5);
236 length_[0] = length0;
237 length_[1] = length1;
238 length_[2] = length2;
239 length_[3] = length3;
240 length_[4] = length4;
241 setupStorage(4);
242 }
243
244 Array(int length0, int length1, int length2, int length3, int length4,
245 int length5,
246 GeneralArrayStorage<N_rank> storage = T_default_storage())
247 : storage_(storage)
248 {
249 BZPRECONDITION(N_rank >= 6);
250 length_[0] = length0;
251 length_[1] = length1;
252 length_[2] = length2;
253 length_[3] = length3;
254 length_[4] = length4;
255 length_[5] = length5;
256 setupStorage(5);
257 }
258
259 Array(int length0, int length1, int length2, int length3, int length4,
260 int length5, int length6,
261 GeneralArrayStorage<N_rank> storage = T_default_storage())
262 : storage_(storage)
263 {
264 BZPRECONDITION(N_rank >= 7);
265 length_[0] = length0;
266 length_[1] = length1;
267 length_[2] = length2;
268 length_[3] = length3;
269 length_[4] = length4;
270 length_[5] = length5;
271 length_[6] = length6;
272 setupStorage(6);
273 }
274
275 Array(int length0, int length1, int length2, int length3, int length4,
276 int length5, int length6, int length7,
277 GeneralArrayStorage<N_rank> storage = T_default_storage())
278 : storage_(storage)
279 {
280 BZPRECONDITION(N_rank >= 8);
281 length_[0] = length0;
282 length_[1] = length1;
283 length_[2] = length2;
284 length_[3] = length3;
285 length_[4] = length4;
286 length_[5] = length5;
287 length_[6] = length6;
288 length_[7] = length7;
289 setupStorage(7);
290 }
291
292 Array(int length0, int length1, int length2, int length3, int length4,
293 int length5, int length6, int length7, int length8,
294 GeneralArrayStorage<N_rank> storage = T_default_storage())
295 : storage_(storage)
296 {
297 BZPRECONDITION(N_rank >= 9);
298 length_[0] = length0;
299 length_[1] = length1;
300 length_[2] = length2;
301 length_[3] = length3;
302 length_[4] = length4;
303 length_[5] = length5;
304 length_[6] = length6;
305 length_[7] = length7;
306 length_[8] = length8;
307 setupStorage(8);
308 }
309
310 Array(int length0, int length1, int length2, int length3, int length4,
311 int length5, int length6, int length7, int length8, int length9,
312 GeneralArrayStorage<N_rank> storage = T_default_storage())
313 : storage_(storage)
314 {
315 BZPRECONDITION(N_rank >= 10);
316 length_[0] = length0;
317 length_[1] = length1;
318 length_[2] = length2;
319 length_[3] = length3;
320 length_[4] = length4;
321 length_[5] = length5;
322 length_[6] = length6;
323 length_[7] = length7;
324 length_[8] = length8;
325 length_[9] = length9;
326 setupStorage(9);
327 }
328
329 Array(int length0, int length1, int length2, int length3, int length4,
330 int length5, int length6, int length7, int length8, int length9,
331 int length10,
332 GeneralArrayStorage<N_rank> storage = T_default_storage())
333 : storage_(storage)
334 {
335 BZPRECONDITION(N_rank >= 11);
336 length_[0] = length0;
337 length_[1] = length1;
338 length_[2] = length2;
339 length_[3] = length3;
340 length_[4] = length4;
341 length_[5] = length5;
342 length_[6] = length6;
343 length_[7] = length7;
344 length_[8] = length8;
345 length_[9] = length9;
346 length_[10] = length10;
347 setupStorage(10);
348 }
349
350 /*
351 * Construct an array from an existing block of memory. Ownership
352 * is not acquired (this is provided for backwards compatibility).
353 */
355 GeneralArrayStorage<N_rank> storage =
356 T_default_storage(contiguousData))
359 storage_(storage)
360 {
361 BZPRECONDITION(dataFirst != 0);
362
363 length_ = shape;
366
367 }
368
381 GeneralArrayStorage<N_rank> storage =
382 T_default_storage(contiguousData))
385 storage_(storage)
386 {
387 BZPRECONDITION(dataFirst != 0);
388
389 length_ = shape;
390 stride_ = stride;
393 }
394
403 preexistingMemoryPolicy deletionPolicy,
404 GeneralArrayStorage<N_rank> storage =
405 T_default_storage(contiguousData))
407 deletionPolicy),
408 storage_(storage)
409 {
410 BZPRECONDITION(dataFirst != 0);
411
412 length_ = shape;
415
416 BZPRECHECK(deletionPolicy!=deleteDataWhenDone || isStorageContiguous(), "Non-contiguous storage used with owned pre-existing memory");
417
418 if (deletionPolicy == duplicateData)
419 reference(copy());
420 }
421
431 preexistingMemoryPolicy deletionPolicy,
432 GeneralArrayStorage<N_rank> storage =
433 T_default_storage(contiguousData))
435 deletionPolicy),
436 storage_(storage)
437 {
438 BZPRECONDITION(dataFirst != 0);
439
440 length_ = shape;
441 stride_ = stride;
444
445 BZPRECHECK(deletionPolicy!=deleteDataWhenDone || isStorageContiguous(), "Non-contiguous storage used with owned pre-existing memory");
446
447 if (deletionPolicy == duplicateData)
448 reference(copy());
449 }
450
451 /*
452 * This constructor takes an extent (length) vector and storage format.
453 */
454
456 GeneralArrayStorage<N_rank> storage = T_default_storage())
457 : storage_(storage)
458 {
459 length_ = extent;
460 setupStorage(N_rank - 1);
461 }
462
463 /*
464 * This construct takes a vector of bases (lbounds) and a vector of
465 * extents.
466 */
467
470 const GeneralArrayStorage<N_rank>& storage
472
473 /*
474 * These constructors allow arbitrary bases (starting indices) to be set.
475 * e.g. Array<int,2> A(Range(10,20), Range(20,30))
476 * will create an 11x11 array whose indices are 10..20 and 20..30
477 */
479 GeneralArrayStorage<N_rank> storage = T_default_storage())
480 : storage_(storage)
481 {
482 BZPRECONDITION(r0.isAscendingContiguous());
483
484 length_[0] = r0.length();
485 storage_.setBase(0, r0.first());
486 setupStorage(0);
487 }
488
490 GeneralArrayStorage<N_rank> storage = T_default_storage())
491 : storage_(storage)
492 {
493 BZPRECONDITION(r0.isAscendingContiguous() &&
495
496 length_[0] = r0.length();
497 storage_.setBase(0, r0.first());
498 length_[1] = r1.length();
499 storage_.setBase(1, r1.first());
500
501 setupStorage(1);
502 }
503
504 Array(Range r0, Range r1, Range r2,
505 GeneralArrayStorage<N_rank> storage = T_default_storage())
506 : storage_(storage)
507 {
508 BZPRECONDITION(r0.isAscendingContiguous() &&
510
511 length_[0] = r0.length();
512 storage_.setBase(0, r0.first());
513 length_[1] = r1.length();
514 storage_.setBase(1, r1.first());
515 length_[2] = r2.length();
516 storage_.setBase(2, r2.first());
517
518 setupStorage(2);
519 }
520
521 Array(Range r0, Range r1, Range r2, Range r3,
522 GeneralArrayStorage<N_rank> storage = T_default_storage())
523 : storage_(storage)
524 {
525 BZPRECONDITION(r0.isAscendingContiguous() &&
527 && r3.isAscendingContiguous());
528
529 length_[0] = r0.length();
530 storage_.setBase(0, r0.first());
531 length_[1] = r1.length();
532 storage_.setBase(1, r1.first());
533 length_[2] = r2.length();
534 storage_.setBase(2, r2.first());
535 length_[3] = r3.length();
536 storage_.setBase(3, r3.first());
537
538 setupStorage(3);
539 }
540
541 Array(Range r0, Range r1, Range r2, Range r3, Range r4,
542 GeneralArrayStorage<N_rank> storage = T_default_storage())
543 : storage_(storage)
544 {
545 BZPRECONDITION(r0.isAscendingContiguous() &&
548
549 length_[0] = r0.length();
550 storage_.setBase(0, r0.first());
551 length_[1] = r1.length();
552 storage_.setBase(1, r1.first());
553 length_[2] = r2.length();
554 storage_.setBase(2, r2.first());
555 length_[3] = r3.length();
556 storage_.setBase(3, r3.first());
557 length_[4] = r4.length();
558 storage_.setBase(4, r4.first());
559
560 setupStorage(4);
561 }
562
563 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
564 GeneralArrayStorage<N_rank> storage = T_default_storage())
565 : storage_(storage)
566 {
567 BZPRECONDITION(r0.isAscendingContiguous() &&
570 && r5.isAscendingContiguous());
571
572 length_[0] = r0.length();
573 storage_.setBase(0, r0.first());
574 length_[1] = r1.length();
575 storage_.setBase(1, r1.first());
576 length_[2] = r2.length();
577 storage_.setBase(2, r2.first());
578 length_[3] = r3.length();
579 storage_.setBase(3, r3.first());
580 length_[4] = r4.length();
581 storage_.setBase(4, r4.first());
582 length_[5] = r5.length();
583 storage_.setBase(5, r5.first());
584
585 setupStorage(5);
586 }
587
588 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
589 Range r6,
590 GeneralArrayStorage<N_rank> storage = T_default_storage())
591 : storage_(storage)
592 {
593 BZPRECONDITION(r0.isAscendingContiguous() &&
597
598 length_[0] = r0.length();
599 storage_.setBase(0, r0.first());
600 length_[1] = r1.length();
601 storage_.setBase(1, r1.first());
602 length_[2] = r2.length();
603 storage_.setBase(2, r2.first());
604 length_[3] = r3.length();
605 storage_.setBase(3, r3.first());
606 length_[4] = r4.length();
607 storage_.setBase(4, r4.first());
608 length_[5] = r5.length();
609 storage_.setBase(5, r5.first());
610 length_[6] = r6.length();
611 storage_.setBase(6, r6.first());
612
613 setupStorage(6);
614 }
615
616 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
617 Range r6, Range r7,
618 GeneralArrayStorage<N_rank> storage = T_default_storage())
619 : storage_(storage)
620 {
621 BZPRECONDITION(r0.isAscendingContiguous() &&
625 && r7.isAscendingContiguous());
626
627 length_[0] = r0.length();
628 storage_.setBase(0, r0.first());
629 length_[1] = r1.length();
630 storage_.setBase(1, r1.first());
631 length_[2] = r2.length();
632 storage_.setBase(2, r2.first());
633 length_[3] = r3.length();
634 storage_.setBase(3, r3.first());
635 length_[4] = r4.length();
636 storage_.setBase(4, r4.first());
637 length_[5] = r5.length();
638 storage_.setBase(5, r5.first());
639 length_[6] = r6.length();
640 storage_.setBase(6, r6.first());
641 length_[7] = r7.length();
642 storage_.setBase(7, r7.first());
643
644 setupStorage(7);
645 }
646
647 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
648 Range r6, Range r7, Range r8,
649 GeneralArrayStorage<N_rank> storage = T_default_storage())
650 : storage_(storage)
651 {
652 BZPRECONDITION(r0.isAscendingContiguous() &&
657
658 length_[0] = r0.length();
659 storage_.setBase(0, r0.first());
660 length_[1] = r1.length();
661 storage_.setBase(1, r1.first());
662 length_[2] = r2.length();
663 storage_.setBase(2, r2.first());
664 length_[3] = r3.length();
665 storage_.setBase(3, r3.first());
666 length_[4] = r4.length();
667 storage_.setBase(4, r4.first());
668 length_[5] = r5.length();
669 storage_.setBase(5, r5.first());
670 length_[6] = r6.length();
671 storage_.setBase(6, r6.first());
672 length_[7] = r7.length();
673 storage_.setBase(7, r7.first());
674 length_[8] = r8.length();
675 storage_.setBase(8, r8.first());
676
677 setupStorage(8);
678 }
679
680 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
681 Range r6, Range r7, Range r8, Range r9,
682 GeneralArrayStorage<N_rank> storage = T_default_storage())
683 : storage_(storage)
684 {
685 BZPRECONDITION(r0.isAscendingContiguous() &&
690 && r9.isAscendingContiguous());
691
692 length_[0] = r0.length();
693 storage_.setBase(0, r0.first());
694 length_[1] = r1.length();
695 storage_.setBase(1, r1.first());
696 length_[2] = r2.length();
697 storage_.setBase(2, r2.first());
698 length_[3] = r3.length();
699 storage_.setBase(3, r3.first());
700 length_[4] = r4.length();
701 storage_.setBase(4, r4.first());
702 length_[5] = r5.length();
703 storage_.setBase(5, r5.first());
704 length_[6] = r6.length();
705 storage_.setBase(6, r6.first());
706 length_[7] = r7.length();
707 storage_.setBase(7, r7.first());
708 length_[8] = r8.length();
709 storage_.setBase(8, r8.first());
710 length_[9] = r9.length();
711 storage_.setBase(9, r9.first());
712
713 setupStorage(9);
714 }
715
716 Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
717 Range r6, Range r7, Range r8, Range r9, Range r10,
718 GeneralArrayStorage<N_rank> storage = T_default_storage())
719 : storage_(storage)
720 {
721 BZPRECONDITION(r0.isAscendingContiguous() &&
727
728 length_[0] = r0.length();
729 storage_.setBase(0, r0.first());
730 length_[1] = r1.length();
731 storage_.setBase(1, r1.first());
732 length_[2] = r2.length();
733 storage_.setBase(2, r2.first());
734 length_[3] = r3.length();
735 storage_.setBase(3, r3.first());
736 length_[4] = r4.length();
737 storage_.setBase(4, r4.first());
738 length_[5] = r5.length();
739 storage_.setBase(5, r5.first());
740 length_[6] = r6.length();
741 storage_.setBase(6, r6.first());
742 length_[7] = r7.length();
743 storage_.setBase(7, r7.first());
744 length_[8] = r8.length();
745 storage_.setBase(8, r8.first());
746 length_[9] = r9.length();
747 storage_.setBase(9, r9.first());
748 length_[10] = r10.length();
749 storage_.setBase(10, r10.first());
750
751 setupStorage(10);
752 }
753
754 /*
755 * Create a reference of another array
756 */
758#ifdef BZ_NEW_EXPRESSION_TEMPLATES
761#else
763#endif
764 {
765 // NEEDS_WORK: this const_cast is a tad ugly.
766 reference(const_cast<T_array&>(array));
767 }
768
769 /*
770 * These constructors are used for creating interlaced arrays (see
771 * <blitz/arrayshape.h>
772 */
774 int lastExtent, const GeneralArrayStorage<N_rank>& storage);
775 //Array(const TinyVector<Range,N_rank-1>& shape,
776 // int lastExtent, const GeneralArrayStorage<N_rank>& storage);
777
778 /*
779 * These constructors make the array a view of a subportion of another
780 * array. If there fewer than N_rank Range arguments provided, no
781 * slicing is performed in the unspecified ranks.
782 * e.g. Array<int,3> A(20,20,20);
783 * Array<int,3> B(A, Range(5,15));
784 * is equivalent to:
785 * Array<int,3> B(A, Range(5,15), Range::all(), Range::all());
786 */
788 {
789 constructSubarray(array, r0);
790 }
791
793 {
794 constructSubarray(array, r0, r1);
795 }
796
798 {
799 constructSubarray(array, r0, r1, r2);
800 }
801
803 Range r3)
804 {
805 constructSubarray(array, r0, r1, r2, r3);
806 }
807
809 Range r3, Range r4)
810 {
811 constructSubarray(array, r0, r1, r2, r3, r4);
812 }
813
815 Range r3, Range r4, Range r5)
816 {
817 constructSubarray(array, r0, r1, r2, r3, r4, r5);
818 }
819
821 Range r3, Range r4, Range r5, Range r6)
822 {
823 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6);
824 }
825
827 Range r3, Range r4, Range r5, Range r6, Range r7)
828 {
829 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7);
830 }
831
833 Range r3, Range r4, Range r5, Range r6, Range r7, Range r8)
834 {
835 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7, r8);
836 }
837
839 Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9)
840 {
841 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9);
842 }
843
845 Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9,
846 Range r10)
847 {
848 constructSubarray(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10);
849 }
850
852 const RectDomain<N_rank>& subdomain)
853 {
854 constructSubarray(array, subdomain);
855 }
856
857 /* Constructor added by Julian Cummings */
859 const StridedDomain<N_rank>& subdomain)
860 {
861 constructSubarray(array, subdomain);
862 }
863
864 /*
865 * This constructor is invoked by the operator()'s which take
866 * a combination of integer and Range arguments. It's not intended
867 * for end-user use.
868 */
869 template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4,
870 typename R5, typename R6, typename R7, typename R8, typename R9, typename R10>
871 Array(Array<T_numtype,N_rank2>& array, R0 r0, R1 r1, R2 r2,
872 R3 r3, R4 r4, R5 r5, R6 r6, R7 r7, R8 r8, R9 r9, R10 r10)
873 {
874 constructSlice(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10);
875 }
876
878 // Member functions
880
882 { return storage_.base(); }
883
884 int base(int rank) const
885 { return storage_.base(rank); }
886
888 { return iterator(*this); }
889
891 { return const_iterator(*this); }
892
894 { return T_iterator(*this); }
895
896 // Deprecated: now extractComponent(...)
897 template<typename P_numtype2>
898 Array<P_numtype2,N_rank> chopComponent(P_numtype2 a, int compNum,
899 int numComponents) const
900 { return extractComponent(a, compNum, numComponents); }
901
902 int cols() const
903 { return length_[1]; }
904
905 int columns() const
906 { return length_[1]; }
907
908 T_array copy() const;
909
910 // data_ always refers to the point (0,0,...,0) which may
911 // not be in the array if the base is not zero in each rank.
912 // These data() routines return a pointer to the first
913 // element in the array (but note that it may not be
914 // stored first in memory if some ranks are stored descending).
915
917 { return dot(storage_.base(), stride_); }
918
919 const T_numtype* restrict data() const
920 { return data_ + dataOffset(); }
921
923 { return data_ + dataOffset(); }
924
925 // These dataZero() routines refer to the point (0,0,...,0)
926 // which may not be in the array if the bases are nonzero.
927
929 { return data_; }
930
932 { return data_; }
933
934 // These dataFirst() routines refer to the element in the
935 // array which falls first in memory.
936
938 {
939 diffType pos = 0;
940
941 // Used to use tinyvector expressions:
942 // return data_ + dot(storage_.base()
943 // + (1 - storage_.ascendingFlag()) * (length_ - 1), stride_);
944
945 for (int i=0; i < N_rank; ++i)
946 pos += (storage_.base(i) + (1-storage_.isRankStoredAscending(i)) *
947 (length_(i)-1)) * stride_(i);
948
949 return pos;
950 }
951
953 { return data_ + dataFirstOffset(); }
954
957
958 int depth() const
959 { return length_[2]; }
960
961 int dimensions() const
962 { return N_rank; }
963
966
967 void dumpStructureInformation(ostream& os = cout) const;
968
970 { return iterator(*this,0); }
971
973 { return const_iterator(*this,0); }
974
975 int extent(int rank) const
976 { return length_[rank]; }
977
979 { return length_; }
980
981 template<typename P_numtype2>
983 int numComponents) const;
984
985 void free()
986 {
988 length_ = 0;
989 }
990
991 bool isMajorRank(int rank) const
992 { return storage_.ordering(rank) == N_rank-1; }
993 bool isMinorRank(int rank) const
994 { return storage_.ordering(rank) != N_rank-1; }
996 { return storage_.isRankStoredAscending(rank); }
997
999
1000 int lbound(int rank) const
1001 { return base(rank); }
1003 { return base(); }
1004
1005 int length(int rank) const
1006 { return length_[rank]; }
1008 { return length_; }
1009
1011
1014
1015 // NEEDS_WORK -- Expose the numReferences() method
1016 // MemoryBlockReference<T_numtype>::numReferences;
1017
1018 // The storage_.ordering_ array is a list of dimensions from
1019 // the most minor (stride 1) to major dimension. Generally,
1020 // ordering(0) will return the dimension which has the smallest
1021 // stride, and ordering(N_rank-1) will return the dimension with
1022 // the largest stride.
1023 int ordering(int storageRankIndex) const
1024 { return storage_.ordering(storageRankIndex); }
1025
1027 { return storage_.ordering(); }
1028
1029 void transposeSelf(int r0, int r1, int r2=0,
1030 int r3=0, int r4=0, int r5=0, int r6=0, int r7=0, int r8=0, int
1031 r9=0, int r10=0);
1032 T_array transpose(int r0, int r1, int r2=0,
1033 int r3=0, int r4=0, int r5=0, int r6=0, int r7=0, int r8=0, int
1034 r9=0, int r10=0) const;
1035
1036 static int rank()
1037 { return rank_; }
1038
1039 void reference(const T_array&);
1041
1042 // Added by Derrick Bass
1045 const TinyVector<int,N_rank>&);
1046
1047 void resize(int extent);
1048 void resize(int extent1, int extent2);
1049 void resize(int extent1, int extent2,
1050 int extent3);
1051 void resize(int extent1, int extent2,
1052 int extent3, int extent4);
1053 void resize(int extent1, int extent2,
1054 int extent3, int extent4, int extent5);
1055 void resize(int extent1, int extent2,
1056 int extent3, int extent4, int extent5,
1057 int extent6);
1058 void resize(int extent1, int extent2,
1059 int extent3, int extent4, int extent5,
1060 int extent6, int extent7);
1061 void resize(int extent1, int extent2,
1062 int extent3, int extent4, int extent5,
1063 int extent6, int extent7, int extent8);
1064 void resize(int extent1, int extent2,
1065 int extent3, int extent4, int extent5,
1066 int extent6, int extent7, int extent8,
1067 int extent9);
1068 void resize(int extent1, int extent2,
1069 int extent3, int extent4, int extent5,
1070 int extent6, int extent7, int extent8,
1071 int extent9, int extent10);
1072 void resize(int extent1, int extent2,
1073 int extent3, int extent4, int extent5,
1074 int extent6, int extent7, int extent8,
1075 int extent9, int extent10,
1076 int extent11);
1077
1078
1079 void resize(Range r1);
1080 void resize(Range r1, Range r2);
1081 void resize(Range r1, Range r2, Range r3);
1082 void resize(Range r1, Range r2, Range r3,
1083 Range r4);
1084 void resize(Range r1, Range r2, Range r3,
1085 Range r4, Range r5);
1086 void resize(Range r1, Range r2, Range r3,
1087 Range r4, Range r5, Range r6);
1088 void resize(Range r1, Range r2, Range r3,
1089 Range r4, Range r5, Range r6,
1090 Range r7);
1091 void resize(Range r1, Range r2, Range r3,
1092 Range r4, Range r5, Range r6,
1093 Range r7, Range r8);
1094 void resize(Range r1, Range r2, Range r3,
1095 Range r4, Range r5, Range r6,
1096 Range r7, Range r8, Range r9);
1097 void resize(Range r1, Range r2, Range r3,
1098 Range r4, Range r5, Range r6,
1099 Range r7, Range r8, Range r9,
1100 Range r10);
1101 void resize(Range r1, Range r2, Range r3,
1102 Range r4, Range r5, Range r6,
1103 Range r7, Range r8, Range r9,
1104 Range r10, Range r11);
1105
1107
1108
1110 N_rank>&);
1112 void resizeAndPreserve(int extent1,
1113 int extent2);
1114 void resizeAndPreserve(int extent1,
1115 int extent2, int extent3);
1116 void resizeAndPreserve(int extent1,
1117 int extent2, int extent3, int extent4);
1118 void resizeAndPreserve(int extent1,
1119 int extent2, int extent3, int extent4,
1120 int extent5);
1121 void resizeAndPreserve(int extent1,
1122 int extent2, int extent3, int extent4,
1123 int extent5, int extent6);
1124 void resizeAndPreserve(int extent1,
1125 int extent2, int extent3, int extent4,
1126 int extent5, int extent6, int extent7);
1127 void resizeAndPreserve(int extent1,
1128 int extent2, int extent3, int extent4,
1129 int extent5, int extent6, int extent7,
1130 int extent8);
1131 void resizeAndPreserve(int extent1,
1132 int extent2, int extent3, int extent4,
1133 int extent5, int extent6, int extent7,
1134 int extent8, int extent9);
1135 void resizeAndPreserve(int extent1,
1136 int extent2, int extent3, int extent4,
1137 int extent5, int extent6, int extent7,
1138 int extent8, int extent9,
1139 int extent10);
1140 void resizeAndPreserve(int extent1,
1141 int extent2, int extent3, int extent4,
1142 int extent5, int extent6, int extent7,
1143 int extent8, int extent9, int extent10,
1144 int extent11);
1145
1146 // NEEDS_WORK -- resizeAndPreserve(Range,...)
1147 // NEEDS_WORK -- resizeAndPreserve(const Domain<N_rank>&);
1148
1151
1152 int rows() const
1153 { return length_[0]; }
1154
1155 void setStorage(GeneralArrayStorage<N_rank>);
1156
1157 void slice(int rank, Range r);
1158
1160 { return length_; }
1161
1163 { return numElements(); }
1164
1171 { return T_base::blockLength(); }
1172
1174 { return stride_; }
1175
1177 { return stride_[rank]; }
1178
1179 bool threadLocal(bool disableLock = true) const
1180 { return T_base::lockReferenceCount(!disableLock); }
1181
1182 int ubound(int rank) const
1183 { return base(rank) + length_(rank) - 1; }
1184
1186 {
1188 for (int i=0; i < N_rank; ++i)
1189 ub(i) = base(i) + extent(i) - 1;
1190 // WAS: ub = base() + extent() - 1;
1191 return ub;
1192 }
1193
1194 int zeroOffset() const
1195 { return zeroOffset_; }
1196
1198 bool isVectorAligned(diffType offset) const
1200
1202 // Debugging routines
1204
1205 bool isInRangeForDim(int i, int d) const {
1206 return i >= base(d) && (i - base(d)) < length_[d];
1207 }
1208
1209 bool isInRange(int i0) const {
1210 return i0 >= base(0) && (i0 - base(0)) < length_[0];
1211 }
1212
1213 bool isInRange(int i0, int i1) const {
1214 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1215 && i1 >= base(1) && (i1 - base(1)) < length_[1];
1216 }
1217
1218 bool isInRange(int i0, int i1, int i2) const {
1219 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1220 && i1 >= base(1) && (i1 - base(1)) < length_[1]
1221 && i2 >= base(2) && (i2 - base(2)) < length_[2];
1222 }
1223
1224 bool isInRange(int i0, int i1, int i2, int i3) const {
1225 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1226 && i1 >= base(1) && (i1 - base(1)) < length_[1]
1227 && i2 >= base(2) && (i2 - base(2)) < length_[2]
1228 && i3 >= base(3) && (i3 - base(3)) < length_[3];
1229 }
1230
1231 bool isInRange(int i0, int i1, int i2, int i3, int i4) const {
1232 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1233 && i1 >= base(1) && (i1 - base(1)) < length_[1]
1234 && i2 >= base(2) && (i2 - base(2)) < length_[2]
1235 && i3 >= base(3) && (i3 - base(3)) < length_[3]
1236 && i4 >= base(4) && (i4 - base(4)) < length_[4];
1237 }
1238
1239 bool isInRange(int i0, int i1, int i2, int i3, int i4, int i5) const {
1240 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1241 && i1 >= base(1) && (i1 - base(1)) < length_[1]
1242 && i2 >= base(2) && (i2 - base(2)) < length_[2]
1243 && i3 >= base(3) && (i3 - base(3)) < length_[3]
1244 && i4 >= base(4) && (i4 - base(4)) < length_[4]
1245 && i5 >= base(5) && (i5 - base(5)) < length_[5];
1246 }
1247
1248 bool isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6) const {
1249 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1250 && i1 >= base(1) && (i1 - base(1)) < length_[1]
1251 && i2 >= base(2) && (i2 - base(2)) < length_[2]
1252 && i3 >= base(3) && (i3 - base(3)) < length_[3]
1253 && i4 >= base(4) && (i4 - base(4)) < length_[4]
1254 && i5 >= base(5) && (i5 - base(5)) < length_[5]
1255 && i6 >= base(6) && (i6 - base(6)) < length_[6];
1256 }
1257
1258 bool isInRange(int i0, int i1, int i2, int i3, int i4,
1259 int i5, int i6, int i7) const {
1260 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1261 && i1 >= base(1) && (i1 - base(1)) < length_[1]
1262 && i2 >= base(2) && (i2 - base(2)) < length_[2]
1263 && i3 >= base(3) && (i3 - base(3)) < length_[3]
1264 && i4 >= base(4) && (i4 - base(4)) < length_[4]
1265 && i5 >= base(5) && (i5 - base(5)) < length_[5]
1266 && i6 >= base(6) && (i6 - base(6)) < length_[6]
1267 && i7 >= base(7) && (i7 - base(7)) < length_[7];
1268 }
1269
1270 bool isInRange(int i0, int i1, int i2, int i3, int i4,
1271 int i5, int i6, int i7, int i8) const {
1272 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1273 && i1 >= base(1) && (i1 - base(1)) < length_[1]
1274 && i2 >= base(2) && (i2 - base(2)) < length_[2]
1275 && i3 >= base(3) && (i3 - base(3)) < length_[3]
1276 && i4 >= base(4) && (i4 - base(4)) < length_[4]
1277 && i5 >= base(5) && (i5 - base(5)) < length_[5]
1278 && i6 >= base(6) && (i6 - base(6)) < length_[6]
1279 && i7 >= base(7) && (i7 - base(7)) < length_[7]
1280 && i8 >= base(8) && (i8 - base(8)) < length_[8];
1281 }
1282
1283 bool isInRange(int i0, int i1, int i2, int i3, int i4,
1284 int i5, int i6, int i7, int i8, int i9) const {
1285 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1286 && i1 >= base(1) && (i1 - base(1)) < length_[1]
1287 && i2 >= base(2) && (i2 - base(2)) < length_[2]
1288 && i3 >= base(3) && (i3 - base(3)) < length_[3]
1289 && i4 >= base(4) && (i4 - base(4)) < length_[4]
1290 && i5 >= base(5) && (i5 - base(5)) < length_[5]
1291 && i6 >= base(6) && (i6 - base(6)) < length_[6]
1292 && i7 >= base(7) && (i7 - base(7)) < length_[7]
1293 && i8 >= base(8) && (i8 - base(8)) < length_[8]
1294 && i9 >= base(9) && (i9 - base(9)) < length_[9];
1295 }
1296
1297 bool isInRange(int i0, int i1, int i2, int i3, int i4,
1298 int i5, int i6, int i7, int i8, int i9, int i10) const {
1299 return i0 >= base(0) && (i0 - base(0)) < length_[0]
1300 && i1 >= base(1) && (i1 - base(1)) < length_[1]
1301 && i2 >= base(2) && (i2 - base(2)) < length_[2]
1302 && i3 >= base(3) && (i3 - base(3)) < length_[3]
1303 && i4 >= base(4) && (i4 - base(4)) < length_[4]
1304 && i5 >= base(5) && (i5 - base(5)) < length_[5]
1305 && i6 >= base(6) && (i6 - base(6)) < length_[6]
1306 && i7 >= base(7) && (i7 - base(7)) < length_[7]
1307 && i8 >= base(8) && (i8 - base(8)) < length_[8]
1308 && i9 >= base(9) && (i9 - base(9)) < length_[9]
1309 && i10 >= base(10) && (i10 - base(10)) < length_[10];
1310 }
1311
1312 bool isInRange(const T_index& index) const {
1313 for (int i=0; i < N_rank; ++i)
1314 if (index[i] < base(i) || (index[i] - base(i)) >= length_[i])
1315 return false;
1316
1317 return true;
1318 }
1319
1320 bool assertInRange(const T_index& BZ_DEBUG_PARAM(index)) const {
1321 BZPRECHECK(isInRange(index), "Array index out of range: " << index
1322 << endl << "Lower bounds: " << storage_.base() << endl
1323 << "Length: " << length_ << endl);
1324 return true;
1325 }
1326
1327 bool assertInRange(int BZ_DEBUG_PARAM(i0)) const {
1328 BZPRECHECK(isInRange(i0), "Array index out of range: " << i0
1329 << endl << "Lower bounds: " << storage_.base() << endl
1330 << "Length: " << length_ << endl);
1331 return true;
1332 }
1333
1334 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1)) const {
1335 BZPRECHECK(isInRange(i0,i1), "Array index out of range: ("
1336 << i0 << ", " << i1 << ")"
1337 << endl << "Lower bounds: " << storage_.base() << endl
1338 << "Length: " << length_ << endl);
1339 return true;
1340 }
1341
1342 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
1343 int BZ_DEBUG_PARAM(i2)) const
1344 {
1345 BZPRECHECK(isInRange(i0,i1,i2), "Array index out of range: ("
1346 << i0 << ", " << i1 << ", " << i2 << ")"
1347 << endl << "Lower bounds: " << storage_.base() << endl
1348 << "Length: " << length_ << endl);
1349 return true;
1350 }
1351
1352 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
1353 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3)) const
1354 {
1355 BZPRECHECK(isInRange(i0,i1,i2,i3), "Array index out of range: ("
1356 << i0 << ", " << i1 << ", " << i2 << ", " << i3 << ")"
1357 << endl << "Lower bounds: " << storage_.base() << endl
1358 << "Length: " << length_ << endl);
1359 return true;
1360 }
1361
1362 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
1363 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3),
1364 int BZ_DEBUG_PARAM(i4)) const
1365 {
1366 BZPRECHECK(isInRange(i0,i1,i2,i3,i4), "Array index out of range: ("
1367 << i0 << ", " << i1 << ", " << i2 << ", " << i3
1368 << ", " << i4 << ")"
1369 << endl << "Lower bounds: " << storage_.base() << endl
1370 << "Length: " << length_ << endl);
1371 return true;
1372 }
1373
1374 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
1375 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
1376 int BZ_DEBUG_PARAM(i5)) const
1377 {
1378 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5), "Array index out of range: ("
1379 << i0 << ", " << i1 << ", " << i2 << ", " << i3
1380 << ", " << i4 << ", " << i5 << ")"
1381 << endl << "Lower bounds: " << storage_.base() << endl
1382 << "Length: " << length_ << endl);
1383 return true;
1384 }
1385
1386 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
1387 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
1388 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6)) const
1389 {
1390 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6),
1391 "Array index out of range: ("
1392 << i0 << ", " << i1 << ", " << i2 << ", " << i3
1393 << ", " << i4 << ", " << i5 << ", " << i6 << ")"
1394 << endl << "Lower bounds: " << storage_.base() << endl
1395 << "Length: " << length_ << endl);
1396 return true;
1397 }
1398
1399 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
1400 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
1401 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6),
1402 int BZ_DEBUG_PARAM(i7)) const
1403 {
1404 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7),
1405 "Array index out of range: ("
1406 << i0 << ", " << i1 << ", " << i2 << ", " << i3
1407 << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7 << ")"
1408 << endl << "Lower bounds: " << storage_.base() << endl
1409 << "Length: " << length_ << endl);
1410 return true;
1411 }
1412
1413 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
1414 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
1415 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7),
1416 int BZ_DEBUG_PARAM(i8)) const
1417 {
1418 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7,i8),
1419 "Array index out of range: ("
1420 << i0 << ", " << i1 << ", " << i2 << ", " << i3
1421 << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7
1422 << ", " << i8 << ")"
1423 << endl << "Lower bounds: " << storage_.base() << endl
1424 << "Length: " << length_ << endl);
1425 return true;
1426 }
1427
1428 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
1429 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
1430 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7),
1431 int BZ_DEBUG_PARAM(i8), int BZ_DEBUG_PARAM(i9)) const
1432 {
1433 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7,i8,i9),
1434 "Array index out of range: ("
1435 << i0 << ", " << i1 << ", " << i2 << ", " << i3
1436 << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7
1437 << ", " << i8 << ", " << i9 << ")"
1438 << endl << "Lower bounds: " << storage_.base() << endl
1439 << "Length: " << length_ << endl);
1440 return true;
1441 }
1442
1443 bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1),
1444 int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4),
1445 int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7),
1446 int BZ_DEBUG_PARAM(i8), int BZ_DEBUG_PARAM(i9),
1447 int BZ_DEBUG_PARAM(i10)) const
1448 {
1449 BZPRECHECK(isInRange(i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10),
1450 "Array index out of range: ("
1451 << i0 << ", " << i1 << ", " << i2 << ", " << i3
1452 << ", " << i4 << ", " << i5 << ", " << i6 << ", " << i7
1453 << ", " << i8 << ", " << i9 << ", " << i10 << ")"
1454 << endl << "Lower bounds: " << storage_.base() << endl
1455 << "Length: " << length_ << endl);
1456 return true;
1457 }
1458
1460 // Subscripting operators
1462
1463 template<int N_rank2>
1465 {
1466 assertInRange(index);
1467 return data_[dot(index, stride_)];
1468 }
1469
1470 template<int N_rank2>
1472 {
1473 assertInRange(index);
1474 return data_[dot(index, stride_)];
1475 }
1476
1478 {
1479 assertInRange(index[0]);
1480 return data_[index[0] * stride_[0]];
1481 }
1482
1484 {
1485 assertInRange(index[0]);
1486 return data_[index[0] * stride_[0]];
1487 }
1488
1490 {
1491 assertInRange(index[0], index[1]);
1492 return data_[index[0] * stride_[0]
1493 + index[1] * stride_[1]];
1494 }
1495
1497 {
1498 assertInRange(index[0], index[1]);
1499 return data_[index[0] * stride_[0]
1500 + index[1] * stride_[1]];
1501 }
1502
1504 {
1505 assertInRange(index[0], index[1], index[2]);
1506 return data_[(index[0]) * stride_[0]
1507 + index[1] * stride_[1]
1508 + index[2] * stride_[2]];
1509 }
1510
1512 {
1513 assertInRange(index[0], index[1], index[2]);
1514 return data_[(index[0]) * stride_[0]
1515 + index[1] * stride_[1]
1516 + index[2] * stride_[2]];
1517 }
1518
1520 {
1521 assertInRange(index[0], index[1], index[2], index[3]);
1522 return data_[(index[0]) * stride_[0]
1523 + index[1] * stride_[1]
1524 + index[2] * stride_[2] + index[3] * stride_[3]];
1525 }
1526
1528 {
1529 assertInRange(index[0], index[1], index[2], index[3]);
1530 return data_[(index[0]) * stride_[0]
1531 + index[1] * stride_[1]
1532 + index[2] * stride_[2] + index[3] * stride_[3]];
1533 }
1534
1536 {
1537 assertInRange(index[0], index[1], index[2], index[3],
1538 index[4]);
1539 return data_[(index[0]) * stride_[0]
1540 + index[1] * stride_[1]
1541 + index[2] * stride_[2] + index[3] * stride_[3]
1542 + index[4] * stride_[4]];
1543 }
1544
1546 {
1547 assertInRange(index[0], index[1], index[2], index[3],
1548 index[4]);
1549 return data_[(index[0]) * stride_[0]
1550 + index[1] * stride_[1]
1551 + index[2] * stride_[2] + index[3] * stride_[3]
1552 + index[4] * stride_[4]];
1553 }
1554
1556 {
1557 assertInRange(index[0], index[1], index[2], index[3],
1558 index[4], index[5]);
1559 return data_[(index[0]) * stride_[0]
1560 + index[1] * stride_[1]
1561 + index[2] * stride_[2] + index[3] * stride_[3]
1562 + index[4] * stride_[4] + index[5] * stride_[5]];
1563 }
1564
1566 {
1567 assertInRange(index[0], index[1], index[2], index[3],
1568 index[4], index[5]);
1569 return data_[(index[0]) * stride_[0]
1570 + index[1] * stride_[1]
1571 + index[2] * stride_[2] + index[3] * stride_[3]
1572 + index[4] * stride_[4] + index[5] * stride_[5]];
1573 }
1574
1576 {
1577 assertInRange(index[0], index[1], index[2], index[3],
1578 index[4], index[5], index[6]);
1579 return data_[(index[0]) * stride_[0]
1580 + index[1] * stride_[1]
1581 + index[2] * stride_[2] + index[3] * stride_[3]
1582 + index[4] * stride_[4] + index[5] * stride_[5]
1583 + index[6] * stride_[6]];
1584 }
1585
1587 {
1588 assertInRange(index[0], index[1], index[2], index[3],
1589 index[4], index[5], index[6]);
1590 return data_[(index[0]) * stride_[0]
1591 + index[1] * stride_[1]
1592 + index[2] * stride_[2] + index[3] * stride_[3]
1593 + index[4] * stride_[4] + index[5] * stride_[5]
1594 + index[6] * stride_[6]];
1595 }
1596
1598 {
1599 assertInRange(index[0], index[1], index[2], index[3],
1600 index[4], index[5], index[6], index[7]);
1601 return data_[(index[0]) * stride_[0]
1602 + index[1] * stride_[1]
1603 + index[2] * stride_[2] + index[3] * stride_[3]
1604 + index[4] * stride_[4] + index[5] * stride_[5]
1605 + index[6] * stride_[6] + index[7] * stride_[7]];
1606 }
1607
1609 {
1610 assertInRange(index[0], index[1], index[2], index[3],
1611 index[4], index[5], index[6], index[7]);
1612 return data_[(index[0]) * stride_[0]
1613 + index[1] * stride_[1]
1614 + index[2] * stride_[2] + index[3] * stride_[3]
1615 + index[4] * stride_[4] + index[5] * stride_[5]
1616 + index[6] * stride_[6] + index[7] * stride_[7]];
1617 }
1618
1620 {
1621 assertInRange(index[0], index[1], index[2], index[3],
1622 index[4], index[5], index[6], index[7], index[8]);
1623 return data_[(index[0]) * stride_[0]
1624 + index[1] * stride_[1]
1625 + index[2] * stride_[2] + index[3] * stride_[3]
1626 + index[4] * stride_[4] + index[5] * stride_[5]
1627 + index[6] * stride_[6] + index[7] * stride_[7]
1628 + index[8] * stride_[8]];
1629 }
1630
1632 {
1633 assertInRange(index[0], index[1], index[2], index[3],
1634 index[4], index[5], index[6], index[7], index[8]);
1635 return data_[(index[0]) * stride_[0]
1636 + index[1] * stride_[1]
1637 + index[2] * stride_[2] + index[3] * stride_[3]
1638 + index[4] * stride_[4] + index[5] * stride_[5]
1639 + index[6] * stride_[6] + index[7] * stride_[7]
1640 + index[8] * stride_[8]];
1641 }
1642
1644 {
1645 assertInRange(index[0], index[1], index[2], index[3],
1646 index[4], index[5], index[6], index[7], index[8], index[9]);
1647 return data_[(index[0]) * stride_[0]
1648 + index[1] * stride_[1]
1649 + index[2] * stride_[2] + index[3] * stride_[3]
1650 + index[4] * stride_[4] + index[5] * stride_[5]
1651 + index[6] * stride_[6] + index[7] * stride_[7]
1652 + index[8] * stride_[8] + index[9] * stride_[9]];
1653 }
1654
1656 {
1657 assertInRange(index[0], index[1], index[2], index[3],
1658 index[4], index[5], index[6], index[7], index[8], index[9]);
1659 return data_[(index[0]) * stride_[0]
1660 + index[1] * stride_[1]
1661 + index[2] * stride_[2] + index[3] * stride_[3]
1662 + index[4] * stride_[4] + index[5] * stride_[5]
1663 + index[6] * stride_[6] + index[7] * stride_[7]
1664 + index[8] * stride_[8] + index[9] * stride_[9]];
1665 }
1666
1668 {
1669 assertInRange(index[0], index[1], index[2], index[3],
1670 index[4], index[5], index[6], index[7], index[8], index[9],
1671 index[10]);
1672 return data_[(index[0]) * stride_[0]
1673 + index[1] * stride_[1]
1674 + index[2] * stride_[2] + index[3] * stride_[3]
1675 + index[4] * stride_[4] + index[5] * stride_[5]
1676 + index[6] * stride_[6] + index[7] * stride_[7]
1677 + index[8] * stride_[8] + index[9] * stride_[9]
1678 + index[10] * stride_[10]];
1679 }
1680
1682 {
1683 assertInRange(index[0], index[1], index[2], index[3],
1684 index[4], index[5], index[6], index[7], index[8], index[9],
1685 index[10]);
1686 return data_[(index[0]) * stride_[0]
1687 + index[1] * stride_[1]
1688 + index[2] * stride_[2] + index[3] * stride_[3]
1689 + index[4] * stride_[4] + index[5] * stride_[5]
1690 + index[6] * stride_[6] + index[7] * stride_[7]
1691 + index[8] * stride_[8] + index[9] * stride_[9]
1692 + index[10] * stride_[10]];
1693 }
1694
1695 const T_numtype& restrict operator()(int i0) const
1696 {
1697 assertInRange(i0);
1698 return data_[(i0) * stride_[0]];
1699 }
1700
1702 {
1703 assertInRange(i0);
1704 return data_[(i0) * stride_[0]];
1705 }
1706
1707 const T_numtype& restrict operator()(int i0, int i1) const
1708 {
1709 assertInRange(i0, i1);
1710 return data_[(i0) * stride_[0] + i1 * stride_[1]];
1711 }
1712
1714 {
1715 assertInRange(i0, i1);
1716 return data_[(i0) * stride_[0] + i1 * stride_[1]];
1717 }
1718
1719 const T_numtype& restrict operator()(int i0, int i1, int i2) const
1720 {
1721 assertInRange(i0, i1, i2);
1722 return data_[(i0) * stride_[0] + i1 * stride_[1]
1723 + i2 * stride_[2]];
1724 }
1725
1726 T_numtype& restrict operator()(int i0, int i1, int i2)
1727 {
1728 assertInRange(i0, i1, i2);
1729 return data_[(i0) * stride_[0] + i1 * stride_[1]
1730 + i2 * stride_[2]];
1731 }
1732
1733 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3) const
1734 {
1735 assertInRange(i0, i1, i2, i3);
1736 return data_[(i0) * stride_[0] + i1 * stride_[1]
1737 + i2 * stride_[2] + i3 * stride_[3]];
1738 }
1739
1740 T_numtype& restrict operator()(int i0, int i1, int i2, int i3)
1741 {
1742 assertInRange(i0, i1, i2, i3);
1743 return data_[(i0) * stride_[0] + i1 * stride_[1]
1744 + i2 * stride_[2] + i3 * stride_[3]];
1745 }
1746
1747 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1748 int i4) const
1749 {
1750 assertInRange(i0, i1, i2, i3, i4);
1751 return data_[(i0) * stride_[0] + i1 * stride_[1]
1752 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]];
1753 }
1754
1755 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1756 int i4)
1757 {
1758 assertInRange(i0, i1, i2, i3, i4);
1759 return data_[(i0) * stride_[0] + i1 * stride_[1]
1760 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]];
1761 }
1762
1763 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1764 int i4, int i5) const
1765 {
1766 assertInRange(i0, i1, i2, i3, i4, i5);
1767 return data_[(i0) * stride_[0] + i1 * stride_[1]
1768 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1769 + i5 * stride_[5]];
1770 }
1771
1772 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1773 int i4, int i5)
1774 {
1775 assertInRange(i0, i1, i2, i3, i4, i5);
1776 return data_[(i0) * stride_[0] + i1 * stride_[1]
1777 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1778 + i5 * stride_[5]];
1779 }
1780
1781 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1782 int i4, int i5, int i6) const
1783 {
1784 assertInRange(i0, i1, i2, i3, i4, i5, i6);
1785 return data_[(i0) * stride_[0] + i1 * stride_[1]
1786 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1787 + i5 * stride_[5] + i6 * stride_[6]];
1788 }
1789
1790 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1791 int i4, int i5, int i6)
1792 {
1793 assertInRange(i0, i1, i2, i3, i4, i5, i6);
1794 return data_[(i0) * stride_[0] + i1 * stride_[1]
1795 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1796 + i5 * stride_[5] + i6 * stride_[6]];
1797 }
1798
1799 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1800 int i4, int i5, int i6, int i7) const
1801 {
1802 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7);
1803 return data_[(i0) * stride_[0] + i1 * stride_[1]
1804 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1805 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]];
1806 }
1807
1808 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1809 int i4, int i5, int i6, int i7)
1810 {
1811 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7);
1812 return data_[(i0) * stride_[0] + i1 * stride_[1]
1813 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1814 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]];
1815 }
1816
1817 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1818 int i4, int i5, int i6, int i7, int i8) const
1819 {
1820 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8);
1821 return data_[(i0) * stride_[0] + i1 * stride_[1]
1822 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1823 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
1824 + i8 * stride_[8]];
1825 }
1826
1827 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1828 int i4, int i5, int i6, int i7, int i8)
1829 {
1830 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8);
1831 return data_[(i0) * stride_[0] + i1 * stride_[1]
1832 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1833 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
1834 + i8 * stride_[8]];
1835 }
1836
1837 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1838 int i4, int i5, int i6, int i7, int i8, int i9) const
1839 {
1840 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);
1841 return data_[(i0) * stride_[0] + i1 * stride_[1]
1842 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1843 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
1844 + i8 * stride_[8] + i9 * stride_[9]];
1845 }
1846
1847 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1848 int i4, int i5, int i6, int i7, int i8, int i9)
1849 {
1850 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);
1851 return data_[(i0) * stride_[0] + i1 * stride_[1]
1852 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1853 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
1854 + i8 * stride_[8] + i9 * stride_[9]];
1855 }
1856
1857 const T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1858 int i4, int i5, int i6, int i7, int i8, int i9, int i10) const
1859 {
1860 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8,
1861 i9, i10);
1862 return data_[(i0) * stride_[0] + i1 * stride_[1]
1863 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1864 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
1865 + i8 * stride_[8] + i9 * stride_[9] + i10 * stride_[10]];
1866 }
1867
1868 T_numtype& restrict operator()(int i0, int i1, int i2, int i3,
1869 int i4, int i5, int i6, int i7, int i8, int i9, int i10)
1870 {
1871 assertInRange(i0, i1, i2, i3, i4, i5, i6, i7, i8,
1872 i9, i10);
1873 return data_[(i0) * stride_[0] + i1 * stride_[1]
1874 + i2 * stride_[2] + i3 * stride_[3] + i4 * stride_[4]
1875 + i5 * stride_[5] + i6 * stride_[6] + i7 * stride_[7]
1876 + i8 * stride_[8] + i9 * stride_[9] + i10 * stride_[10]];
1877 }
1878
1879 /*
1880 * Slicing to produce subarrays. If the number of Range arguments is
1881 * fewer than N_rank, then missing arguments are treated like Range::all().
1882 */
1883
1885 { return const_cast<T_array&>(*this); }
1886
1887 T_array operator()(const RectDomain<N_rank>& subdomain) const
1888 {
1889 return T_array(noConst(), subdomain);
1890 }
1891
1892 /* Operator added by Julian Cummings */
1893 T_array operator()(const StridedDomain<N_rank>& subdomain) const
1894 {
1895 return T_array(noConst(), subdomain);
1896 }
1897
1899 {
1900 return T_array(noConst(), r0);
1901 }
1902
1904 {
1905 return T_array(noConst(), r0, r1);
1906 }
1907
1909 {
1910 return T_array(noConst(), r0, r1, r2);
1911 }
1912
1913 T_array operator()(Range r0, Range r1, Range r2, Range r3) const
1914 {
1915 return T_array(noConst(), r0, r1, r2, r3);
1916 }
1917
1918 T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4) const
1919 {
1920 return T_array(noConst(), r0, r1, r2, r3, r4);
1921 }
1922
1924 Range r5) const
1925 {
1926 return T_array(noConst(), r0, r1, r2, r3, r4, r5);
1927 }
1928
1930 Range r5, Range r6) const
1931 {
1932 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6);
1933 }
1934
1936 Range r5, Range r6, Range r7) const
1937 {
1938 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7);
1939 }
1940
1942 Range r5, Range r6, Range r7, Range r8) const
1943 {
1944 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7, r8);
1945 }
1946
1948 Range r5, Range r6, Range r7, Range r8, Range r9) const
1949 {
1950 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7, r8, r9);
1951 }
1952
1954 Range r5, Range r6, Range r7, Range r8, Range r9, Range r10) const
1955 {
1956 return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10);
1957 }
1958
1959 // Allow any mixture of Range, int and Vector<int> objects as
1960 // operands for operator(): A(Range(3,7), 5, Range(2,4))
1961
1962 /*
1963 * These versions of operator() allow any combination of int
1964 * and Range operands to be used. Each int operand reduces
1965 * the rank of the resulting array by one.
1966 *
1967 * e.g. Array<int,4> A(20,20,20,20);
1968 * Array<int,2> B = A(Range(5,15), 3, 5, Range(8,9));
1969 *
1970 * SliceInfo is a helper class defined in <blitz/arrayslice.h>.
1971 * It counts the number of Range vs. int arguments and does some
1972 * other helpful things.
1973 *
1974 * Once partial specialization becomes widely implemented, these
1975 * operators may be expanded to accept Vector<int> arguments
1976 * and produce ArrayPick<T,N> objects.
1977 *
1978 * This operator() is not provided with a single argument because
1979 * the appropriate cases exist above.
1980 */
1981
1982#ifdef BZ_HAVE_PARTIAL_ORDERING
1983
1984 template<typename T1, typename T2>
1985 typename SliceInfo<T_numtype,T1,T2>::T_slice
1986 operator()(T1 r1, T2 r2) const
1987 {
1988 typedef typename SliceInfo<T_numtype,T1,T2>::T_slice slice;
1989 return slice(noConst(), r1, r2, nilArraySection(), nilArraySection(), nilArraySection(),
1990 nilArraySection(), nilArraySection(), nilArraySection(),
1991 nilArraySection(), nilArraySection(), nilArraySection());
1992 }
1993
1994 template<typename T1, typename T2, typename T3>
1995 typename SliceInfo<T_numtype,T1,T2,T3>::T_slice
1996 operator()(T1 r1, T2 r2, T3 r3) const
1997 {
1998 typedef typename SliceInfo<T_numtype,T1,T2,T3>::T_slice slice;
1999 return slice(noConst(), r1, r2, r3, nilArraySection(), nilArraySection(), nilArraySection(),
2000 nilArraySection(), nilArraySection(), nilArraySection(),
2001 nilArraySection(), nilArraySection());
2002 }
2003
2004 template<typename T1, typename T2, typename T3, typename T4>
2005 typename SliceInfo<T_numtype,T1,T2,T3,T4>::T_slice
2006 operator()(T1 r1, T2 r2, T3 r3, T4 r4) const
2007 {
2008 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4>::T_slice slice;
2009 return slice(noConst(), r1, r2, r3, r4, nilArraySection(), nilArraySection(),
2010 nilArraySection(), nilArraySection(), nilArraySection(),
2011 nilArraySection(), nilArraySection());
2012 }
2013
2014 template<typename T1, typename T2, typename T3, typename T4, typename T5>
2015 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5>::T_slice
2016 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5) const
2017 {
2018 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5>::T_slice slice;
2019 return slice(noConst(), r1, r2, r3, r4, r5, nilArraySection(),
2020 nilArraySection(), nilArraySection(), nilArraySection(),
2021 nilArraySection(), nilArraySection());
2022 }
2023
2024 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
2025 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6>::T_slice
2026 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6) const
2027 {
2028 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6>::T_slice slice;
2029 return slice(noConst(), r1, r2, r3, r4, r5, r6, nilArraySection(), nilArraySection(), nilArraySection(),
2030 nilArraySection(), nilArraySection());
2031 }
2032
2033 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
2034 typename T7>
2035 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7>::T_slice
2036 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7) const
2037 {
2038 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7>::T_slice slice;
2039 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, nilArraySection(), nilArraySection(),
2040 nilArraySection(), nilArraySection());
2041 }
2042
2043 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
2044 typename T7, typename T8>
2045 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8>::T_slice
2046 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8) const
2047 {
2048 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8>::T_slice slice;
2049 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8,
2050 nilArraySection(), nilArraySection(), nilArraySection());
2051 }
2052
2053 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
2054 typename T7, typename T8, typename T9>
2055 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_slice
2056 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8, T9 r9) const
2057 {
2058 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9>::T_slice slice;
2059 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8, r9, nilArraySection(), nilArraySection());
2060 }
2061
2062 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
2063 typename T7, typename T8, typename T9, typename T10>
2064 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_slice
2065 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8, T9 r9, T10 r10) const
2066 {
2067 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::T_slice slice;
2068 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, nilArraySection());
2069 }
2070
2071 template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
2072 typename T7, typename T8, typename T9, typename T10, typename T11>
2073 typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_slice
2074 operator()(T1 r1, T2 r2, T3 r3, T4 r4, T5 r5, T6 r6, T7 r7, T8 r8, T9 r9, T10 r10, T11 r11) const
2075 {
2076 typedef typename SliceInfo<T_numtype,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::T_slice slice;
2077 return slice(noConst(), r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11);
2078 }
2079
2080#endif // BZ_HAVE_PARTIAL_ORDERING
2081
2082 /*
2083 * These versions of operator() are provided to support tensor-style
2084 * array notation, e.g.
2085 *
2086 * Array<float, 2> A, B;
2087 * firstIndex i;
2088 * secondIndex j;
2089 * thirdIndex k;
2090 * Array<float, 3> C = A(i,j) * B(j,k);
2091 */
2092
2093 template<int N0>
2094 _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0> >
2100
2101 template<int N0, int N1>
2108
2109 template<int N0, int N1, int N2>
2117
2118 template<int N0, int N1, int N2, int N3>
2126
2127 template<int N0, int N1, int N2, int N3, int N4>
2136
2137 template<int N0, int N1, int N2, int N3, int N4, int N5>
2139 N4, N5> >
2147
2148 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6>
2150 N4, N5, N6> >
2158
2159 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
2160 int N7>
2162 N4, N5, N6, N7> >
2171
2172 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
2173 int N7, int N8>
2175 N4, N5, N6, N7, N8> >
2184
2185 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
2186 int N7, int N8, int N9>
2188 N4, N5, N6, N7, N8, N9> >
2197
2198 template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
2199 int N7, int N8, int N9, int N10>
2201 N4, N5, N6, N7, N8, N9, N10> >
2211
2213 // Support for multicomponent arrays
2215
2216 /*
2217 * See <blitz/array/multi.h> for an explanation of the traits class
2218 * multicomponent_traits.
2219 */
2220
2222 operator[](const unsigned component) {
2223 typedef typename multicomponent_traits<T_numtype>::T_element T_compType;
2224
2225 return extractComponent(T_compType(),component,
2226 multicomponent_traits<T_numtype>::numComponents);
2227 }
2228
2230 operator[](const unsigned component) const {
2231 typedef typename multicomponent_traits<T_numtype>::T_element T_compType;
2232
2233 return extractComponent(T_compType(),component,
2234 multicomponent_traits<T_numtype>::numComponents);
2235 }
2236
2238 operator[](const int component) {
2239 return operator[](static_cast<unsigned>(component));
2240 }
2241
2243 operator[](const int component) const {
2244 return operator[](static_cast<unsigned>(component));
2245 }
2246
2248 // Indirection
2250
2251 template<typename T_indexContainer>
2253 operator[](const T_indexContainer& index)
2254 {
2256 const_cast<T_indexContainer&>(index));
2257 }
2258
2260 // Assignment Operators
2262
2265
2275
2277
2278 // Was:
2279 // T_array& operator=(T_numtype);
2280
2281#ifdef BZ_NEW_EXPRESSION_TEMPLATES
2282
2283 // we need this because we can't use default assignment op so it
2284 // must be overridden
2286
2287 // we can't define a generic template for the assignment operator
2288 // because it will cause the list initialization assignment above to
2289 // not work when implict conversions to T_numtype are necessary.
2290
2291 //template<typename T> T_array& operator=(const T&);
2292 template<typename T_expr> T_array& operator=(const ETBase<T_expr>&);
2293
2304
2315
2316 template<typename T_expr> T_array& operator+=(const ETBase<T_expr>&);
2317 template<typename T_expr> T_array& operator-=(const ETBase<T_expr>&);
2318 template<typename T_expr> T_array& operator*=(const ETBase<T_expr>&);
2319 template<typename T_expr> T_array& operator/=(const ETBase<T_expr>&);
2320 template<typename T_expr> T_array& operator%=(const ETBase<T_expr>&);
2321 template<typename T_expr> T_array& operator^=(const ETBase<T_expr>&);
2322 template<typename T_expr> T_array& operator&=(const ETBase<T_expr>&);
2323 template<typename T_expr> T_array& operator|=(const ETBase<T_expr>&);
2324 template<typename T_expr> T_array& operator>>=(const ETBase<T_expr>&);
2325 template<typename T_expr> T_array& operator<<=(const ETBase<T_expr>&);
2326
2327#else
2338
2339 // Array operands
2341
2342 template<typename P_numtype2>
2344 template<typename P_numtype2>
2346 template<typename P_numtype2>
2348 template<typename P_numtype2>
2350 template<typename P_numtype2>
2352 template<typename P_numtype2>
2354 template<typename P_numtype2>
2356 template<typename P_numtype2>
2358 template<typename P_numtype2>
2360 template<typename P_numtype2>
2362 template<typename P_numtype2>
2364
2365 // Array expression operands
2366 template<typename T_expr>
2368 template<typename T_expr>
2370 template<typename T_expr>
2372 template<typename T_expr>
2374 template<typename T_expr>
2376 template<typename T_expr>
2378 template<typename T_expr>
2380 template<typename T_expr>
2382 template<typename T_expr>
2384 template<typename T_expr>
2386 template<typename T_expr>
2388
2390
2391#endif
2392
2393public:
2394
2396//iterator getInitializationIterator() { return begin(); }
2397
2398 bool canCollapse(int outerRank, int innerRank) const {
2399#ifdef BZ_DEBUG_TRAVERSE
2400 BZ_DEBUG_MESSAGE("stride(" << innerRank << ")=" << stride(innerRank)
2401 << ", extent()=" << extent(innerRank) << ", stride(outerRank)="
2402 << stride(outerRank));
2403#endif
2404 return (stride(innerRank) * extent(innerRank) == stride(outerRank));
2405 }
2406
2407protected:
2409 // Implementation routines
2411
2415 const RectDomain<N_rank>&);
2417 const StridedDomain<N_rank>&);
2421 Range r1, Range r2);
2423 Range r1, Range r2, Range r3);
2425 Range r1, Range r2, Range r3, Range r4);
2427 Range r1, Range r2, Range r3, Range r4, Range r5);
2429 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6);
2431 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
2432 Range r7);
2434 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
2435 Range r7, Range r8);
2437 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
2438 Range r7, Range r8, Range r9);
2440 Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
2441 Range r7, Range r8, Range r9, Range r10);
2442
2444
2445 template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4,
2446 typename R5, typename R6, typename R7, typename R8, typename R9, typename R10>
2447 void constructSlice(Array<T_numtype, N_rank2>& array, R0 r0, R1 r1, R2 r2,
2448 R3 r3, R4 r4, R5 r5, R6 r6, R7 r7, R8 r8, R9 r9, R10 r10);
2449
2450 template<int N_rank2>
2451 void slice(int& setRank, Range r, Array<T_numtype,N_rank2>& array,
2452 TinyVector<int,N_rank2>& rankMap, int sourceRank);
2453
2454 template<int N_rank2>
2455 void slice(int& setRank, int i, Array<T_numtype,N_rank2>& array,
2456 TinyVector<int,N_rank2>& rankMap, int sourceRank);
2457
2458 template<int N_rank2>
2459 void slice(int&, nilArraySection, Array<T_numtype,N_rank2>&,
2461 { }
2462
2463 void doTranspose(int destRank, int sourceRank, T_array& array);
2464
2465private:
2466 // serialization support
2467#ifdef BZ_HAVE_BOOST_SERIALIZATION
2468 friend class boost::serialization::access;
2469
2470 template<class T_arch>
2471 void serialize(T_arch& ar, const unsigned int version) {
2472 ar & boost::serialization::base_object<MemoryBlockReference<P_numtype> >(*this);
2473 ar & length_;
2474 ar & storage_;
2475 ar & stride_;
2476 ar & zeroOffset_;
2477 };
2478#endif
2479
2480protected:
2482 // Data members
2484
2485 // NB: adding new data members may require changes to ctors, reference()
2486
2487 /*
2488 * For a description of the storage_ members, see the comments for class
2489 * GeneralArrayStorage<N_rank> above.
2490 *
2491 * length_[] contains the extent of each rank. E.g. a 10x20x30 array
2492 * would have length_ = { 10, 20, 30}.
2493 * stride_[] contains the stride to move to the next element along each
2494 * rank.
2495 * zeroOffset_ is the distance from the first element in the array
2496 * to the point (0,0,...,0). If base_ is zero and all ranks are
2497 * stored ascending, then zeroOffset_ is zero. This value
2498 * is needed because to speed up indexing, the data_ member
2499 * (inherited from MemoryBlockReference) always refers to
2500 * (0,0,...,0).
2501 */
2502 GeneralArrayStorage<N_rank> storage_;
2506};
2507
2508
2509/*
2510 * Global Functions
2511 */
2512
2513template<typename T_numtype>
2514ostream& operator<<(ostream&, const Array<T_numtype,1>&);
2515
2516template<typename T_numtype, int N_rank>
2517ostream& operator<<(ostream&, const Array<T_numtype,N_rank>&);
2518
2519template<typename T_numtype, int N_rank>
2520istream& operator>>(istream& is, Array<T_numtype,N_rank>& x);
2521
2522template <typename P_numtype,int N_rank>
2525 a.reference(b);
2526 b.reference(c);
2527}
2528
2529template <typename P_expr>
2531 const _bz_ArrayExpr<P_expr>& expr) {
2532 find(indices,
2534}
2535
2536template <typename P_numtype, int N_rank>
2538 const Array<P_numtype,N_rank>& exprVals) {
2539 indices.resize(exprVals.size());
2540 typename Array<P_numtype,N_rank>::const_iterator it, end = exprVals.end();
2541 int j=0;
2542 for (it = exprVals.begin(); it != end; ++it)
2543 if (*it)
2544 indices(j++) = it.position();
2545 if (j)
2546 indices.resizeAndPreserve(j);
2547 else
2548 indices.free();
2549 return;
2550}
2551
2552
2553}
2554
2555/*
2556 * Removed the "kitchen-sink inclusion" here because it made
2557 * dependencies very difficult to figure out.
2558 */
2559#include <blitz/array.cc>
2560#include <blitz/tinyvec2.cc>
2561
2562
2563#endif // BZ_ARRAY_H
Definition array-impl.h:73
Declaration of class Array, the "Swiss army knife" of Blitz expression template classes.
Definition et-forward.h:13
int isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9, int i10) const
Definition array-impl.h:1297
void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7, int extent8, int extent9, int extent10)
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7)
Scalar operand assignment.
const T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9, int i10) const
Definition array-impl.h:1857
int cols() const
Definition array-impl.h:902
sizeType storageSize() const
Returns the length of the array storage.
Definition array-impl.h:1170
void transposeSelf(int r0, int r1, int r2=0, int r3=0, int r4=0, int r5=0, int r6=0, int r7=0, int r8=0, int r9=0, int r10=0)
const T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6) const
Definition array-impl.h:1781
void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8)
void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6)
int base(int rank) const
Definition array-impl.h:884
const T_numtype & operator()(const TinyVector< int, 4 > &index) const
Definition array-impl.h:1519
void computeStrides()
Scalar operand assignment.
Array< P_numtype2, N_rank > chopComponent(P_numtype2 a, int compNum, int numComponents) const
Definition array-impl.h:898
int depth() const
Definition array-impl.h:958
void makeUnique()
T_numtype & operator()(TinyVector< int, 1 > index)
Definition array-impl.h:1483
int ubound(int rank) const
Definition array-impl.h:1182
Array< P_numtype2, N_rank > extractComponent(P_numtype2, int compNum, int numComponents) const
T_array & operator^=(const T_numtype &)
Scalar operand assignment.
void slice(int &, nilArraySection, Array< T_numtype, N_rank2 > &, TinyVector< int, N_rank2 > &, int)
Scalar operand assignment.
Definition array-impl.h:2459
const T_numtype & operator()(const TinyVector< int, N_rank2 > &index) const
Definition array-impl.h:1464
MemoryBlockReference< P_numtype > T_base
Definition array-impl.h:113
T_array & operator<<=(const T_array &)
Scalar operand assignment.
Array(const TinyVector< int, N_rank-1 > &shape, int lastExtent, const GeneralArrayStorage< N_rank > &storage)
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4), int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7), int BZ_DEBUG_PARAM(i8), int BZ_DEBUG_PARAM(i9)) const
Definition array-impl.h:1428
Array(int length0, int length1, int length2, int length3, int length4, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:231
T_array & operator^=(const ETBase< T_expr > &)
Scalar operand assignment.
T_array & initialize(T_numtype)
Scalar operand assignment.
T_numtype & operator()(const TinyVector< int, 7 > &index)
Definition array-impl.h:1586
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2)) const
Definition array-impl.h:1342
T_numtype & operator()(const TinyVector< int, 9 > &index)
Definition array-impl.h:1631
T_array & operator*=(const T_array &)
Scalar operand assignment.
void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7, int extent8)
void resize(int extent1, int extent2, int extent3, int extent4, int extent5)
Array(const TinyVector< int, N_rank > &extent, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:455
void calculateZeroOffset()
Scalar operand assignment.
Array(int length0, int length1, int length2, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:208
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1, N2, N3, N4, N5, N6, N7, N8 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >, IndexPlaceholder< N2 >, IndexPlaceholder< N3 >, IndexPlaceholder< N4 >, IndexPlaceholder< N5 >, IndexPlaceholder< N6 >, IndexPlaceholder< N7 >, IndexPlaceholder< N8 >) const
Definition array-impl.h:2176
const T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5) const
Definition array-impl.h:1763
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4), int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6)) const
Definition array-impl.h:1386
Array(T_numtype *dataFirst, TinyVector< int, N_rank > shape, TinyVector< diffType, N_rank > stride, GeneralArrayStorage< N_rank > storage=T_default_storage(contiguousData))
Construct an array from an existing block of memory, with a given set of strides.
Definition array-impl.h:379
void resize(int extent1, int extent2, int extent3, int extent4)
Array(int length0, int length1, int length2, int length3, int length4, int length5, int length6, int length7, int length8, int length9, int length10, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:329
TinyVector< int, N_rank > length_
Definition array-impl.h:2503
int isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8) const
Definition array-impl.h:1270
T_numtype & operator()(const TinyVector< int, 5 > &index)
Definition array-impl.h:1545
Array(int length0, int length1, int length2, int length3, int length4, int length5, int length6, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:259
T_array reindex(const TinyVector< int, N_rank > &)
const T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) const
Definition array-impl.h:1837
const T_numtype & operator()(int i0) const
Definition array-impl.h:1695
TinyVector< diffType, N_rank > stride_
Definition array-impl.h:2504
void resizeAndPreserve(int extent)
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1, N2 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >, IndexPlaceholder< N2 >) const
Definition array-impl.h:2111
const T_numtype & operator()(const TinyVector< int, 11 > &index) const
Definition array-impl.h:1667
void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9, Range r10)
Array< T_numtype, N_rank > T_array
Definition array-impl.h:135
int isMinorRank(int rank) const
Definition array-impl.h:993
const_iterator begin() const
Definition array-impl.h:890
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4)) const
Definition array-impl.h:1362
Array(Range r0, Range r1, Range r2, Range r3, Range r4, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:541
T_numtype & operator()(int i0, int i1, int i2, int i3, int i4)
Definition array-impl.h:1755
T_numtype & operator()(int i0)
Definition array-impl.h:1701
Array(GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:178
P_numtype T_numtype
Definition array-impl.h:133
T_iterator beginFast() const
Definition array-impl.h:893
int isMajorRank(int rank) const
Definition array-impl.h:991
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0)
Scalar operand assignment.
Array(const TinyVector< int, N_rank > &lbounds, const TinyVector< int, N_rank > &extent, const GeneralArrayStorage< N_rank > &storage=T_default_storage())
T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5)
Definition array-impl.h:1772
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5)
Definition array-impl.h:814
T_array & operator-=(const ETBase< T_expr > &)
Scalar operand assignment.
int zeroOffset() const
Definition array-impl.h:1194
int isInRange(int i0, int i1, int i2) const
Definition array-impl.h:1218
diffType dataFirstOffset() const
Definition array-impl.h:937
const T_numtype * dataFirst() const
Definition array-impl.h:952
const_iterator end() const
Definition array-impl.h:972
const T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8) const
Definition array-impl.h:1817
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7)
Definition array-impl.h:826
int assertInRange(int BZ_DEBUG_PARAM(i0)) const
Definition array-impl.h:1327
int canCollapse(int outerRank, int innerRank) const
Scalar operand assignment.
Definition array-impl.h:2398
void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4)
void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7, int extent8, int extent9, int extent10, int extent11)
void constructSlice(Array< T_numtype, N_rank2 > &array, R0 r0, R1 r1, R2 r2, R3 r3, R4 r4, R5 r5, R6 r6, R7 r7, R8 r8, R9 r9, R10 r10)
Scalar operand assignment.
Array(Range r0, Range r1, Range r2, Range r3, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:521
Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:647
void weakReference(const T_array &)
T_array transpose(int r0, int r1, int r2=0, int r3=0, int r4=0, int r5=0, int r6=0, int r7=0, int r8=0, int r9=0, int r10=0) const
void slice(int &setRank, int i, Array< T_numtype, N_rank2 > &array, TinyVector< int, N_rank2 > &rankMap, int sourceRank)
Scalar operand assignment.
int isStorageContiguous() const
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9) const
Definition array-impl.h:1947
T_array & operator<<=(const ETBase< T_expr > &)
Scalar operand assignment.
Array(Array< T_numtype, N_rank > &array, Range r0)
Definition array-impl.h:787
const T_numtype & operator()(TinyVector< int, 2 > index) const
Definition array-impl.h:1489
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2)
Scalar operand assignment.
T_array & operator+=(const T_array &)
Scalar operand assignment.
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, N10 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >, IndexPlaceholder< N2 >, IndexPlaceholder< N3 >, IndexPlaceholder< N4 >, IndexPlaceholder< N5 >, IndexPlaceholder< N6 >, IndexPlaceholder< N7 >, IndexPlaceholder< N8 >, IndexPlaceholder< N9 >, IndexPlaceholder< N10 >) const
Definition array-impl.h:2202
T_array & operator%=(const ETBase< T_expr > &)
Scalar operand assignment.
Array(Array< T_numtype, N_rank2 > &array, R0 r0, R1 r1, R2 r2, R3 r3, R4 r4, R5 r5, R6 r6, R7 r7, R8 r8, R9 r9, R10 r10)
Definition array-impl.h:871
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8)
Definition array-impl.h:832
T_array & operator=(const Array< T_numtype, N_rank > &)
Scalar operand assignment.
T_numtype & operator()(const TinyVector< int, 8 > &index)
Definition array-impl.h:1608
T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7)
Definition array-impl.h:1808
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7) const
Definition array-impl.h:1935
T_array copy() const
void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7, int extent8, int extent9, int extent10, int extent11)
T_array reverse(int rank)
ArrayIterator< T_numtype, N_rank > iterator
Definition array-impl.h:138
Array(T_numtype *dataFirst, TinyVector< int, N_rank > shape, GeneralArrayStorage< N_rank > storage=T_default_storage(contiguousData))
Definition array-impl.h:354
const T_numtype & operator()(int i0, int i1, int i2) const
Definition array-impl.h:1719
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >, IndexPlaceholder< N2 >, IndexPlaceholder< N3 >, IndexPlaceholder< N4 >, IndexPlaceholder< N5 >, IndexPlaceholder< N6 >, IndexPlaceholder< N7 >, IndexPlaceholder< N8 >, IndexPlaceholder< N9 >) const
Definition array-impl.h:2189
void resize(Range r1, Range r2, Range r3, Range r4)
const Array< typename multicomponent_traits< T_numtype >::T_element, N_rank > operator[](const unsigned component) const
Definition array-impl.h:2230
T_array & operator+=(const T_numtype &)
Scalar operand assignment.
void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7, int extent8)
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4)
Scalar operand assignment.
Array(Range r0, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:478
T_numtype & operator()(const TinyVector< int, 10 > &index)
Definition array-impl.h:1655
T_numtype & operator()(TinyVector< int, 3 > index)
Definition array-impl.h:1511
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4), int BZ_DEBUG_PARAM(i5)) const
Definition array-impl.h:1374
T_array & operator&=(const T_numtype &)
Scalar operand assignment.
T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6)
Definition array-impl.h:1790
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5) const
Definition array-impl.h:1923
TinyVector< int, N_rank > lbound() const
Definition array-impl.h:1002
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3)) const
Definition array-impl.h:1352
int isVectorAligned(diffType offset) const
Returns true if the array is aligned on a simd vector width.
Definition array-impl.h:1198
Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:563
Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9, Range r10, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:716
FastArrayIterator< T_numtype, N_rank > T_iterator
Definition array-impl.h:136
int isInRange(int i0, int i1, int i2, int i3, int i4, int i5) const
Definition array-impl.h:1239
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5)
Scalar operand assignment.
Array(T_numtype *dataFirst, TinyVector< int, N_rank > shape, TinyVector< diffType, N_rank > stride, preexistingMemoryPolicy deletionPolicy, GeneralArrayStorage< N_rank > storage=T_default_storage(contiguousData))
Construct an array from an existing block of memory, with a given set of strides.
Definition array-impl.h:429
const TinyVector< int, N_rank > & shape() const
Definition array-impl.h:1159
T_array & operator|=(const T_numtype &)
Scalar operand assignment.
T_numtype * dataZero()
Definition array-impl.h:931
void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7)
int isInRange(int i0, int i1) const
Definition array-impl.h:1213
const TinyVector< diffType, N_rank > & stride() const
Definition array-impl.h:1173
IndirectArray< T_array, T_indexContainer > operator[](const T_indexContainer &index)
Definition array-impl.h:2253
const T_numtype & operator()(TinyVector< int, 3 > index) const
Definition array-impl.h:1503
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8) const
Definition array-impl.h:1941
void resize(int extent1, int extent2, int extent3)
static const int rank_
Definition array-impl.h:157
Array(int length0, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:186
T_array & noConst() const
Definition array-impl.h:1884
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1)) const
Definition array-impl.h:1334
Array(int length0, int length1, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:194
int isInRangeForDim(int i, int d) const
Definition array-impl.h:1205
Array< typename multicomponent_traits< T_numtype >::T_element, N_rank > operator[](const int component)
Definition array-impl.h:2238
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0 > > operator()(IndexPlaceholder< N0 >) const
Definition array-impl.h:2095
const T_numtype & operator()(const TinyVector< int, 9 > &index) const
Definition array-impl.h:1619
int length(int rank) const
Definition array-impl.h:1005
int isInRange(int i0) const
Definition array-impl.h:1209
void resize(const TinyVector< int, N_rank > &)
T_array & operator%=(const T_numtype &)
Scalar operand assignment.
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1, N2, N3, N4 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >, IndexPlaceholder< N2 >, IndexPlaceholder< N3 >, IndexPlaceholder< N4 >) const
Definition array-impl.h:2129
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1, N2, N3, N4, N5 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >, IndexPlaceholder< N2 >, IndexPlaceholder< N3 >, IndexPlaceholder< N4 >, IndexPlaceholder< N5 >) const
Definition array-impl.h:2140
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4), int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7), int BZ_DEBUG_PARAM(i8)) const
Definition array-impl.h:1413
TinyVector< int, N_rank > ubound() const
Definition array-impl.h:1185
Array(_bz_ArrayExpr< T_expr > expr)
Construct an array from an expression.
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9)
Scalar operand assignment.
void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9, Range r10, Range r11)
T_array & operator/=(const T_array &)
Scalar operand assignment.
const T_numtype & operator()(const TinyVector< int, 7 > &index) const
Definition array-impl.h:1575
void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7)
T_array & operator&=(const T_array &)
Scalar operand assignment.
static int rank()
Definition array-impl.h:1036
T_array & operator/=(const T_numtype &)
Scalar operand assignment.
T_array & operator-=(const T_array &)
Scalar operand assignment.
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >) const
Definition array-impl.h:2103
T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8)
Definition array-impl.h:1827
int isInRange(int i0, int i1, int i2, int i3) const
Definition array-impl.h:1224
int ordering(int storageRankIndex) const
Definition array-impl.h:1023
T_array & operator*=(const T_numtype &)
Scalar operand assignment.
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9, Range r10)
Definition array-impl.h:844
T_array & operator/=(const ETBase< T_expr > &)
Scalar operand assignment.
T_array & operator^=(const T_array &)
Scalar operand assignment.
T_array operator()(Range r0, Range r1, Range r2) const
Definition array-impl.h:1908
int extent(int rank) const
Definition array-impl.h:975
const TinyVector< int, N_rank > & extent() const
Definition array-impl.h:978
Array(Array< T_numtype, N_rank > &array, const StridedDomain< N_rank > &subdomain)
Definition array-impl.h:858
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9, Range r10) const
Definition array-impl.h:1953
const T_numtype & operator()(const TinyVector< int, 10 > &index) const
Definition array-impl.h:1643
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9)
Definition array-impl.h:838
void reverseSelf(int rank)
T_numtype & operator()(int i0, int i1)
Definition array-impl.h:1713
Array(int length0, int length1, int length2, int length3, int length4, int length5, int length6, int length7, int length8, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:292
Array(int length0, int length1, int length2, int length3, int length4, int length5, int length6, int length7, int length8, int length9, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:310
diffType stride(int rank) const
Definition array-impl.h:1176
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4)
Definition array-impl.h:808
void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7, int extent8, int extent9, int extent10)
ConstArrayIterator< T_numtype, N_rank > const_iterator
Definition array-impl.h:139
T_array & operator+=(const ETBase< T_expr > &)
Scalar operand assignment.
void constructSubarray(Array< T_numtype, N_rank > &array, const RectDomain< N_rank > &)
Scalar operand assignment.
Array(int length0, int length1, int length2, int length3, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:219
const T_numtype & operator()(const TinyVector< int, 5 > &index) const
Definition array-impl.h:1535
int isInRange(int i0, int i1, int i2, int i3, int i4) const
Definition array-impl.h:1231
void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9)
Array(int length0, int length1, int length2, int length3, int length4, int length5, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:244
const T_numtype & operator()(const TinyVector< int, 6 > &index) const
Definition array-impl.h:1555
T_numtype & operator()(int i0, int i1, int i2, int i3)
Definition array-impl.h:1740
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3)
Definition array-impl.h:802
T_numtype & operator()(int i0, int i1, int i2)
Definition array-impl.h:1726
T_numtype * data()
Definition array-impl.h:922
ListInitializationSwitch< T_array > operator=(T_numtype x)
Scalar operand assignment.
Definition array-impl.h:2271
T_numtype & operator()(const TinyVector< int, 11 > &index)
Definition array-impl.h:1681
void resize(int extent1, int extent2)
T_array & operator>>=(const T_array &)
Scalar operand assignment.
Array< typename multicomponent_traits< T_numtype >::T_element, N_rank > operator[](const unsigned component)
Definition array-impl.h:2222
iterator begin()
Definition array-impl.h:887
void resizeAndPreserve(int extent1, int extent2, int extent3)
sizeType size() const
Definition array-impl.h:1162
TinyVector< int, N_rank > T_index
Definition array-impl.h:134
T_array & operator<<=(const T_numtype &)
Scalar operand assignment.
void slice(int rank, Range r)
const T_numtype & operator()(int i0, int i1, int i2, int i3) const
Definition array-impl.h:1733
Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:680
int threadLocal(int disableLock=1) const
Definition array-impl.h:1179
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4), int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7)) const
Definition array-impl.h:1399
T_array & operator>>=(const ETBase< T_expr > &)
Scalar operand assignment.
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1, N2, N3 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >, IndexPlaceholder< N2 >, IndexPlaceholder< N3 >) const
Definition array-impl.h:2120
T_array operator()(Range r0, Range r1) const
Definition array-impl.h:1903
void resize(Range r1)
void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7, int extent8, int extent9)
int isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7) const
Definition array-impl.h:1258
T_numtype & operator()(const TinyVector< int, 4 > &index)
Definition array-impl.h:1527
const TinyVector< int, N_rank > & ordering() const
Definition array-impl.h:1026
T_array operator()(Range r0, Range r1, Range r2, Range r3) const
Definition array-impl.h:1913
int lbound(int rank) const
Definition array-impl.h:1000
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2)
Definition array-impl.h:797
T_array operator()(const RectDomain< N_rank > &subdomain) const
Definition array-impl.h:1887
GeneralArrayStorage< N_rank > storage_
Definition array-impl.h:2502
const T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7) const
Definition array-impl.h:1799
T_array operator()(const StridedDomain< N_rank > &subdomain) const
Definition array-impl.h:1893
Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:588
const T_numtype & operator()(int i0, int i1, int i2, int i3, int i4) const
Definition array-impl.h:1747
int dimensions() const
Definition array-impl.h:961
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4) const
Definition array-impl.h:1918
const T_numtype * data() const
Definition array-impl.h:919
T_numtype & operator()(TinyVector< int, 2 > index)
Definition array-impl.h:1496
int isRankStoredAscending(int rank) const
Definition array-impl.h:995
void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7)
void free()
Definition array-impl.h:985
diffType dataOffset() const
Definition array-impl.h:916
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8)
Scalar operand assignment.
T_array & operator=(const ETBase< T_expr > &)
Scalar operand assignment.
int rows() const
Definition array-impl.h:1152
T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
Definition array-impl.h:1847
void setStorage(GeneralArrayStorage< N_rank >)
const T_numtype & operator()(TinyVector< int, 1 > index) const
Definition array-impl.h:1477
int isInRange(const T_index &index) const
Definition array-impl.h:1312
void resize(int extent)
void resizeAndPreserve(int extent1, int extent2)
T_array & operator-=(const T_numtype &)
Scalar operand assignment.
T_array & operator&=(const ETBase< T_expr > &)
Scalar operand assignment.
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1)
Scalar operand assignment.
void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6)
void setupStorage(int rank)
Scalar operand assignment.
const T_numtype & operator()(int i0, int i1) const
Definition array-impl.h:1707
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1)
Definition array-impl.h:792
Array(T_numtype *dataFirst, TinyVector< int, N_rank > shape, preexistingMemoryPolicy deletionPolicy, GeneralArrayStorage< N_rank > storage=T_default_storage(contiguousData))
Construct an array from an existing block of memory.
Definition array-impl.h:402
sizeType numElements() const
Definition array-impl.h:1012
Array(Range r0, Range r1, Range r2, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:504
T_numtype & operator()(const TinyVector< int, 6 > &index)
Definition array-impl.h:1565
void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5)
diffType zeroOffset_
Definition array-impl.h:2505
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1, N2, N3, N4, N5, N6, N7 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >, IndexPlaceholder< N2 >, IndexPlaceholder< N3 >, IndexPlaceholder< N4 >, IndexPlaceholder< N5 >, IndexPlaceholder< N6 >, IndexPlaceholder< N7 >) const
Definition array-impl.h:2163
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6) const
Definition array-impl.h:1929
int isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) const
Definition array-impl.h:1283
int isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6) const
Definition array-impl.h:1248
void resizeAndPreserve(const TinyVector< int, N_rank > &)
RectDomain< N_rank > domain() const
Definition array-impl.h:964
const Array< typename multicomponent_traits< T_numtype >::T_element, N_rank > operator[](const int component) const
Definition array-impl.h:2243
void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6)
int columns() const
Definition array-impl.h:905
Array(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:616
T_array operator()(Range r0) const
Definition array-impl.h:1898
int assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2), int BZ_DEBUG_PARAM(i3), int BZ_DEBUG_PARAM(i4), int BZ_DEBUG_PARAM(i5), int BZ_DEBUG_PARAM(i6), int BZ_DEBUG_PARAM(i7), int BZ_DEBUG_PARAM(i8), int BZ_DEBUG_PARAM(i9), int BZ_DEBUG_PARAM(i10)) const
Definition array-impl.h:1443
int assertInRange(const T_index &BZ_DEBUG_PARAM(index)) const
Definition array-impl.h:1320
void resize(Range r1, Range r2, Range r3, Range r4, Range r5)
T_numtype * dataFirst()
Definition array-impl.h:955
void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6, int extent7, int extent8, int extent9)
Array(Range r0, Range r1, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:489
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6)
Definition array-impl.h:820
T_array & operator|=(const ETBase< T_expr > &)
Scalar operand assignment.
const T_numtype * dataZero() const
Definition array-impl.h:928
void constructSubarray(Array< T_numtype, N_rank > &array, const StridedDomain< N_rank > &)
Scalar operand assignment.
Array(const Array< T_numtype, N_rank > &array)
Definition array-impl.h:757
Array(Array< T_numtype, N_rank > &array, const RectDomain< N_rank > &subdomain)
Definition array-impl.h:851
iterator end()
Definition array-impl.h:969
T_array & operator>>=(const T_numtype &)
Scalar operand assignment.
void doTranspose(int destRank, int sourceRank, T_array &array)
Scalar operand assignment.
void resize(Range r1, Range r2)
T_array & operator%=(const T_array &)
Scalar operand assignment.
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, Range r8, Range r9, Range r10)
Scalar operand assignment.
T_array & operator*=(const ETBase< T_expr > &)
Scalar operand assignment.
void reindexSelf(const TinyVector< int, N_rank > &)
GeneralArrayStorage< N_rank > T_default_storage
Definition array-impl.h:154
const TinyVector< int, N_rank > & length() const
Definition array-impl.h:1007
const T_numtype & operator()(const TinyVector< int, 8 > &index) const
Definition array-impl.h:1597
void reference(const T_array &)
T_array & operator|=(const T_array &)
Scalar operand assignment.
T_numtype & operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9, int i10)
Definition array-impl.h:1868
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6)
Scalar operand assignment.
T_numtype & operator()(const TinyVector< int, N_rank2 > &index)
Definition array-impl.h:1471
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1, N2, N3, N4, N5, N6 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >, IndexPlaceholder< N2 >, IndexPlaceholder< N3 >, IndexPlaceholder< N4 >, IndexPlaceholder< N5 >, IndexPlaceholder< N6 >) const
Definition array-impl.h:2151
Array(int length0, int length1, int length2, int length3, int length4, int length5, int length6, int length7, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition array-impl.h:275
const TinyVector< int, N_rank > & base() const
Definition array-impl.h:881
void dumpStructureInformation(ostream &os=cout) const
T_numtype * getInitializationIterator()
Scalar operand assignment.
Definition array-impl.h:2395
void constructSubarray(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3)
Scalar operand assignment.
void slice(int &setRank, Range r, Array< T_numtype, N_rank2 > &array, TinyVector< int, N_rank2 > &rankMap, int sourceRank)
Scalar operand assignment.
void resize(Range r1, Range r2, Range r3)
Definition array-impl.h:76
Definition etbase.h:38
ETBase()
Definition etbase.h:42
Definition et-forward.h:18
Definition tinymat2.h:65
Definition array-impl.h:85
Definition listinit.h:71
Definition memblock.h:307
MemoryBlockReference()
Definition memblock.h:367
void changeToNullBlock()
Definition memblock.h:462
bool lockReferenceCount(bool lockingPolicy) const
Definition memblock.h:451
T_type *restrict data_
Definition memblock.h:313
sizeType blockLength() const
Definition memblock.h:435
Definition range.h:65
T_numtype first(T_numtype lowRange=0) const
Definition range.h:228
bool isAscendingContiguous() const
Definition range.h:253
int length(int=0) const
Definition range.h:242
Definition range.h:58
The TinyVector class is a one-dimensional, fixed length vector that implements the blitz expression t...
Definition tinyvec2.h:73
Definition tinymat2.h:62
Definition tvecglobs.h:70
static T_ret product(const TinyVector< T_numtype1, N_length > &a)
Definition tvecglobs.h:83
static bool isVectorAligned(const T *restrict pointer)
Test if a pointer to T is simd aligned.
Definition simdtypes.h:46
#define restrict
Definition compiler.h:95
Definition array-impl.h:66
ostream & operator<<(ostream &, const Array< T_numtype, 1 > &)
ptrdiff_t diffType
Definition blitz.h:111
N_length const TinyVector< T_numtype2, N_length > & b
Definition tvecglobs.h:49
istream & operator>>(istream &is, Array< T_numtype, N_rank > &x)
void find(Array< TinyVector< int, N_rank >, 1 > &, const Array< P_numtype, N_rank > &)
Definition array-impl.h:2537
void swap(Array< P_numtype, N_rank > &, Array< P_numtype, N_rank > &)
Definition array-impl.h:2523
size_t sizeType
Definition blitz.h:110
preexistingMemoryPolicy
Definition memblock.h:49
@ deleteDataWhenDone
Definition memblock.h:51
@ duplicateData
Definition memblock.h:50
@ neverDeleteData
Definition memblock.h:52
N_length & a
Definition tvecglobs.h:47
#define _bz_inline2
Definition tuning.h:126
#define BZ_ETPARM(X)
Definition tuning.h:138