blitz  Version 1.0.2
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 
66 namespace blitz {
67 
68 /*
69  * Forward declarations
70  */
71 
72 template<typename T_numtype, int N_rank>
74 
75 template<typename T_numtype, int N_rank>
77 
78 template<typename T_numtype, int N_rank>
80 
81 template<typename P_expr>
83 
84 template<typename T_array, typename T_index>
86 
87 template <typename P_numtype,int N_rank>
89 
90 template <typename P_numtype, int N_rank>
92 
93 
105 template<typename P_numtype, int N_rank>
106 class Array : public MemoryBlockReference<P_numtype>
107 #ifdef BZ_NEW_EXPRESSION_TEMPLATES
108  , public ETBase<Array<P_numtype,N_rank> >
109 #endif
110 {
111 
112 private:
114  using T_base::data_;
115 
116 public:
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>
169  explicit Array(_bz_ArrayExpr<T_expr> 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))
357  : MemoryBlockReference<T_numtype>(_bz_returntype<sizeType>::product(shape), dataFirst,
359  storage_(storage)
360  {
361  BZPRECONDITION(dataFirst != 0);
362 
363  length_ = shape;
364  computeStrides();
365  data_ += zeroOffset_;
366 
367  }
368 
379  Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
381  GeneralArrayStorage<N_rank> storage =
382  T_default_storage(contiguousData))
383  : MemoryBlockReference<T_numtype>(_bz_returntype<sizeType>::product(shape), dataFirst,
385  storage_(storage)
386  {
387  BZPRECONDITION(dataFirst != 0);
388 
389  length_ = shape;
390  stride_ = stride;
392  data_ += zeroOffset_;
393  }
394 
402  Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
403  preexistingMemoryPolicy deletionPolicy,
404  GeneralArrayStorage<N_rank> storage =
405  T_default_storage(contiguousData))
406  : MemoryBlockReference<T_numtype>(_bz_returntype<sizeType>::product(shape), dataFirst,
407  deletionPolicy),
408  storage_(storage)
409  {
410  BZPRECONDITION(dataFirst != 0);
411 
412  length_ = shape;
413  computeStrides();
414  data_ += zeroOffset_;
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 
429  Array(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape,
431  preexistingMemoryPolicy deletionPolicy,
432  GeneralArrayStorage<N_rank> storage =
433  T_default_storage(contiguousData))
434  : MemoryBlockReference<T_numtype>(_bz_returntype<sizeType>::product(shape), dataFirst,
435  deletionPolicy),
436  storage_(storage)
437  {
438  BZPRECONDITION(dataFirst != 0);
439 
440  length_ = shape;
441  stride_ = stride;
443  data_ += zeroOffset_;
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 
468  Array(const TinyVector<int, N_rank>& lbounds,
469  const TinyVector<int, N_rank>& extent,
470  const GeneralArrayStorage<N_rank>& storage
471  = T_default_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 
489  Array(Range r0, Range r1,
490  GeneralArrayStorage<N_rank> storage = T_default_storage())
491  : storage_(storage)
492  {
493  BZPRECONDITION(r0.isAscendingContiguous() &&
494  r1.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  */
773  Array(const TinyVector<int,N_rank-1>& shape,
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 
887  iterator begin()
888  { return iterator(*this); }
889 
890  const_iterator begin() const
891  { return const_iterator(*this); }
892 
893  T_iterator beginFast() const
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 
922  T_numtype* restrict data()
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 
928  const T_numtype* restrict dataZero() const
929  { return data_; }
930 
931  T_numtype* restrict dataZero()
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 
952  const T_numtype* restrict dataFirst() const
953  { return data_ + dataFirstOffset(); }
954 
955  T_numtype* restrict dataFirst()
956  { return data_ + dataFirstOffset(); }
957 
958  int depth() const
959  { return length_[2]; }
960 
961  int dimensions() const
962  { return N_rank; }
963 
965  { return RectDomain<N_rank>(lbound(), ubound()); }
966 
967  void dumpStructureInformation(ostream& os = cout) const;
968 
969  iterator end()
970  { return iterator(*this,0); }
971 
972  const_iterator end() const
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>
982  Array<P_numtype2,N_rank> extractComponent(P_numtype2, int compNum,
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; }
995  bool isRankStoredAscending(int rank) const
996  { return storage_.isRankStoredAscending(rank); }
997 
998  bool isStorageContiguous() const;
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 
1010  void makeUnique();
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&);
1040  void weakReference(const T_array&);
1041 
1042  // Added by Derrick Bass
1043  T_array reindex(const TinyVector<int,N_rank>&);
1044  void reindexSelf(
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 
1106  void resize(const TinyVector<int,N_rank>&);
1107 
1108 
1109  void resizeAndPreserve(const TinyVector<int,
1110  N_rank>&);
1111  void resizeAndPreserve(int extent);
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 
1149  T_array reverse(int rank);
1150  void reverseSelf(int rank);
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 
1162  sizeType size() const
1163  { return numElements(); }
1164 
1171  { return T_base::blockLength(); }
1172 
1174  { return stride_; }
1175 
1176  diffType stride(int rank) const
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
1199  { return simdTypes<T_numtype>::isVectorAligned(dataFirst()+offset); };
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>
1464  const T_numtype& restrict operator()(const TinyVector<int,N_rank2>& index) const
1465  {
1466  assertInRange(index);
1467  return data_[dot(index, stride_)];
1468  }
1469 
1470  template<int N_rank2>
1471  T_numtype& restrict operator()(const TinyVector<int,N_rank2>& index)
1472  {
1473  assertInRange(index);
1474  return data_[dot(index, stride_)];
1475  }
1476 
1477  const T_numtype& restrict operator()(TinyVector<int,1> index) const
1478  {
1479  assertInRange(index[0]);
1480  return data_[index[0] * stride_[0]];
1481  }
1482 
1483  T_numtype& operator()(TinyVector<int,1> index)
1484  {
1485  assertInRange(index[0]);
1486  return data_[index[0] * stride_[0]];
1487  }
1488 
1489  const T_numtype& restrict operator()(TinyVector<int,2> index) const
1490  {
1491  assertInRange(index[0], index[1]);
1492  return data_[index[0] * stride_[0]
1493  + index[1] * stride_[1]];
1494  }
1495 
1496  T_numtype& operator()(TinyVector<int,2> index)
1497  {
1498  assertInRange(index[0], index[1]);
1499  return data_[index[0] * stride_[0]
1500  + index[1] * stride_[1]];
1501  }
1502 
1503  const T_numtype& restrict operator()(TinyVector<int,3> index) const
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 
1511  T_numtype& operator()(TinyVector<int,3> index)
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 
1519  const T_numtype& restrict operator()(const TinyVector<int,4>& index) const
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 
1527  T_numtype& operator()(const TinyVector<int,4>& index)
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 
1535  const T_numtype& restrict operator()(const TinyVector<int,5>& index) const
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 
1545  T_numtype& operator()(const TinyVector<int,5>& index)
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 
1555  const T_numtype& restrict operator()(const TinyVector<int,6>& index) const
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 
1565  T_numtype& operator()(const TinyVector<int,6>& index)
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 
1575  const T_numtype& restrict operator()(const TinyVector<int,7>& index) const
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 
1586  T_numtype& operator()(const TinyVector<int,7>& index)
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 
1597  const T_numtype& restrict operator()(const TinyVector<int,8>& index) const
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 
1608  T_numtype& operator()(const TinyVector<int,8>& index)
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 
1619  const T_numtype& restrict operator()(const TinyVector<int,9>& index) const
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 
1631  T_numtype& operator()(const TinyVector<int,9>& index)
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 
1643  const T_numtype& restrict operator()(const TinyVector<int,10>& index) const
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 
1655  T_numtype& operator()(const TinyVector<int,10>& index)
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 
1667  const T_numtype& restrict operator()(const TinyVector<int,11>& index) const
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 
1681  T_numtype& operator()(const TinyVector<int,11>& index)
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 
1701  T_numtype& restrict operator()(int i0)
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 
1713  T_numtype& restrict operator()(int i0, int i1)
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 
1884  T_array& noConst() const
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 
1898  T_array operator()(Range r0) const
1899  {
1900  return T_array(noConst(), r0);
1901  }
1902 
1903  T_array operator()(Range r0, Range r1) const
1904  {
1905  return T_array(noConst(), r0, r1);
1906  }
1907 
1908  T_array operator()(Range r0, Range r1, Range r2) const
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 
1923  T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
1924  Range r5) const
1925  {
1926  return T_array(noConst(), r0, r1, r2, r3, r4, r5);
1927  }
1928 
1929  T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
1930  Range r5, Range r6) const
1931  {
1932  return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6);
1933  }
1934 
1935  T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
1936  Range r5, Range r6, Range r7) const
1937  {
1938  return T_array(noConst(), r0, r1, r2, r3, r4, r5, r6, r7);
1939  }
1940 
1941  T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
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 
1947  T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
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 
1953  T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4,
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> >
2096  {
2097  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0> >
2098  (noConst());
2099  }
2100 
2101  template<int N0, int N1>
2102  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1> >
2104  {
2105  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2106  N1> >(noConst());
2107  }
2108 
2109  template<int N0, int N1, int N2>
2110  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1, N2> >
2112  IndexPlaceholder<N2>) const
2113  {
2114  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2115  N1, N2> >(noConst());
2116  }
2117 
2118  template<int N0, int N1, int N2, int N3>
2119  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1, N2, N3> >
2122  {
2123  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2124  N1, N2, N3> >(noConst());
2125  }
2126 
2127  template<int N0, int N1, int N2, int N3, int N4>
2128  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1, N2, N3, N4> >
2131  IndexPlaceholder<N4>) const
2132  {
2133  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2134  N1, N2, N3, N4> >(noConst());
2135  }
2136 
2137  template<int N0, int N1, int N2, int N3, int N4, int N5>
2138  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1, N2, N3,
2139  N4, N5> >
2142  IndexPlaceholder<N5>) const
2143  {
2144  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2145  N1, N2, N3, N4, N5> >(noConst());
2146  }
2147 
2148  template<int N0, int N1, int N2, int N3, int N4, int N5, int N6>
2149  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1, N2, N3,
2150  N4, N5, N6> >
2154  {
2155  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2156  N1, N2, N3, N4, N5, N6> >(noConst());
2157  }
2158 
2159  template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
2160  int N7>
2161  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1, N2, N3,
2162  N4, N5, N6, N7> >
2166  IndexPlaceholder<N7>) const
2167  {
2168  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2169  N1, N2, N3, N4, N5, N6, N7> >(noConst());
2170  }
2171 
2172  template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
2173  int N7, int N8>
2174  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1, N2, N3,
2175  N4, N5, N6, N7, N8> >
2179  IndexPlaceholder<N8>) const
2180  {
2181  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2182  N1, N2, N3, N4, N5, N6, N7, N8> >(noConst());
2183  }
2184 
2185  template<int N0, int N1, int N2, int N3, int N4, int N5, int N6,
2186  int N7, int N8, int N9>
2187  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1, N2, N3,
2188  N4, N5, N6, N7, N8, N9> >
2193  {
2194  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2195  N1, N2, N3, N4, N5, N6, N7, N8, N9> >(noConst());
2196  }
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>
2200  _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0, N1, N2, N3,
2201  N4, N5, N6, N7, N8, N9, N10> >
2206  IndexPlaceholder<N10>) const
2207  {
2208  return _bz_ArrayExpr<ArrayIndexMapping<typename asExpr<T_array >::T_expr, N0,
2209  N1, N2, N3, N4, N5, N6, N7, N8, N9, N10> >(noConst());
2210  }
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 
2272  {
2273  return ListInitializationSwitch<T_array>(*this, x);
2274  }
2275 
2276  T_array& initialize(T_numtype);
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
2285  T_array& operator=(const Array<T_numtype,N_rank>&);
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 
2294  T_array& operator+=(const T_array&);
2295  T_array& operator-=(const T_array&);
2296  T_array& operator*=(const T_array&);
2297  T_array& operator/=(const T_array&);
2298  T_array& operator%=(const T_array&);
2299  T_array& operator^=(const T_array&);
2300  T_array& operator&=(const T_array&);
2301  T_array& operator|=(const T_array&);
2302  T_array& operator>>=(const T_array&);
2303  T_array& operator<<=(const T_array&);
2304 
2305  T_array& operator+=(const T_numtype&);
2306  T_array& operator-=(const T_numtype&);
2307  T_array& operator*=(const T_numtype&);
2308  T_array& operator/=(const T_numtype&);
2309  T_array& operator%=(const T_numtype&);
2310  T_array& operator^=(const T_numtype&);
2311  T_array& operator&=(const T_numtype&);
2312  T_array& operator|=(const T_numtype&);
2313  T_array& operator>>=(const T_numtype&);
2314  T_array& operator<<=(const T_numtype&);
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
2328  T_array& operator+=(T_numtype);
2329  T_array& operator-=(T_numtype);
2330  T_array& operator*=(T_numtype);
2331  T_array& operator/=(T_numtype);
2332  T_array& operator%=(T_numtype);
2333  T_array& operator^=(T_numtype);
2334  T_array& operator&=(T_numtype);
2335  T_array& operator|=(T_numtype);
2336  T_array& operator>>=(T_numtype);
2337  T_array& operator<<=(T_numtype);
2338 
2339  // Array operands
2340  T_array& operator=(const Array<T_numtype,N_rank>&);
2341 
2342  template<typename P_numtype2>
2343  T_array& operator=(const Array<P_numtype2,N_rank>&);
2344  template<typename P_numtype2>
2345  T_array& operator+=(const Array<P_numtype2,N_rank>&);
2346  template<typename P_numtype2>
2347  T_array& operator-=(const Array<P_numtype2,N_rank>&);
2348  template<typename P_numtype2>
2349  T_array& operator*=(const Array<P_numtype2,N_rank>&);
2350  template<typename P_numtype2>
2351  T_array& operator/=(const Array<P_numtype2,N_rank>&);
2352  template<typename P_numtype2>
2353  T_array& operator%=(const Array<P_numtype2,N_rank>&);
2354  template<typename P_numtype2>
2355  T_array& operator^=(const Array<P_numtype2,N_rank>&);
2356  template<typename P_numtype2>
2357  T_array& operator&=(const Array<P_numtype2,N_rank>&);
2358  template<typename P_numtype2>
2359  T_array& operator|=(const Array<P_numtype2,N_rank>&);
2360  template<typename P_numtype2>
2361  T_array& operator>>=(const Array<P_numtype2,N_rank>&);
2362  template<typename P_numtype2>
2363  T_array& operator<<=(const Array<P_numtype2,N_rank>&);
2364 
2365  // Array expression operands
2366  template<typename T_expr>
2367  inline T_array& operator=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2368  template<typename T_expr>
2369  inline T_array& operator+=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2370  template<typename T_expr>
2371  inline T_array& operator-=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2372  template<typename T_expr>
2373  inline T_array& operator*=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2374  template<typename T_expr>
2375  inline T_array& operator/=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2376  template<typename T_expr>
2377  inline T_array& operator%=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2378  template<typename T_expr>
2379  inline T_array& operator^=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2380  template<typename T_expr>
2381  inline T_array& operator&=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2382  template<typename T_expr>
2383  inline T_array& operator|=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2384  template<typename T_expr>
2385  inline T_array& operator>>=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2386  template<typename T_expr>
2387  inline T_array& operator<<=(BZ_ETPARM(_bz_ArrayExpr<T_expr>) expr);
2388 
2390 
2391 #endif
2392 
2393 public:
2394 
2395  T_numtype* restrict getInitializationIterator() { return dataFirst(); }
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 
2407 protected:
2409  // Implementation routines
2411 
2412  _bz_inline2 void computeStrides();
2413  _bz_inline2 void setupStorage(int rank);
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 
2443  void calculateZeroOffset();
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 
2465 private:
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 
2480 protected:
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 
2513 template<typename T_numtype>
2514 ostream& operator<<(ostream&, const Array<T_numtype,1>&);
2515 
2516 template<typename T_numtype, int N_rank>
2517 ostream& operator<<(ostream&, const Array<T_numtype,N_rank>&);
2518 
2519 template<typename T_numtype, int N_rank>
2520 istream& operator>>(istream& is, Array<T_numtype,N_rank>& x);
2521 
2522 template <typename P_numtype,int N_rank>
2525  a.reference(b);
2526  b.reference(c);
2527 }
2528 
2529 template <typename P_expr>
2531  const _bz_ArrayExpr<P_expr>& expr) {
2532  find(indices,
2533  static_cast< Array<typename P_expr::T_numtype,P_expr::rank> >(expr));
2534 }
2535 
2536 template <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
int base(int rank) const
Definition: array-impl.h:884
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5)
Definition: array-impl.h:814
Array< P_numtype2, N_rank > extractComponent(P_numtype2, int compNum, int numComponents) const
bool isAscendingContiguous() const
Definition: range.h:253
_bz_global blitz::IndexPlaceholder< 9 > r
Definition: indexexpr.h:265
istream & operator>>(istream &is, Array< T_numtype, N_rank > &x)
Definition: array-impl.h:73
void makeUnique()
void reverseSelf(int rank)
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
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 extent)
GeneralArrayStorage< N_rank > T_default_storage
Set default storage order.
Definition: array-impl.h:154
Definition: range.h:58
sizeType size() const
Definition: array-impl.h:1162
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5) const
Definition: array-impl.h:1923
void changeToNullBlock()
Definition: memblock.h:462
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
T_numtype & operator()(TinyVector< int, 3 > index)
Definition: array-impl.h:1511
T_array & noConst() const
Definition: array-impl.h:1884
Array(Array< T_numtype, N_rank > &array, Range r0)
Definition: array-impl.h:787
void setStorage(GeneralArrayStorage< N_rank >)
T_iterator beginFast() const
Definition: array-impl.h:893
T_numtype & operator()(const TinyVector< int, 11 > &index)
Definition: array-impl.h:1681
void constructSubarray(Array< T_numtype, N_rank > &array, const RectDomain< N_rank > &)
_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
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
void resizeAndPreserve(const TinyVector< int, N_rank > &)
bool 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
int ubound(int rank) const
Definition: array-impl.h:1182
_bz_global blitz::IndexPlaceholder< 0 > i
Definition: indexexpr.h:256
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
T_numtype *restrict dataZero()
Definition: array-impl.h:931
int length(int=0) const
Definition: range.h:242
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2)
Definition: array-impl.h:797
bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1)) const
Definition: array-impl.h:1334
bool isInRange(int i0, int i1, int i2, int i3) const
Definition: array-impl.h:1224
Array(T_numtype *restrict dataFirst, TinyVector< int, N_rank > shape, GeneralArrayStorage< N_rank > storage=T_default_storage(contiguousData))
Definition: array-impl.h:354
T_numtype &restrict 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
T_numtype & operator()(const TinyVector< int, 6 > &index)
Definition: array-impl.h:1565
T_numtype &restrict operator()(int i0, int i1)
Definition: array-impl.h:1713
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
Array(T_numtype *restrict 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
const T_numtype &restrict operator()(int i0, int i1) const
Definition: array-impl.h:1707
bool isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6) const
Definition: array-impl.h:1248
Array(int length0, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:186
Array(Range r0, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:478
void free()
Definition: array-impl.h:985
bool 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
Array(int length0, int length1, int length2, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:208
_bz_global blitz::IndexPlaceholder< 1 > j
Definition: indexexpr.h:257
const Array< typename multicomponent_traits< T_numtype >::T_element, N_rank > operator[](const int component) const
Definition: array-impl.h:2243
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
_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_numtype & operator()(const TinyVector< int, 4 > &index)
Definition: array-impl.h:1527
const T_numtype &restrict operator()(const TinyVector< int, 11 > &index) const
Definition: array-impl.h:1667
diffType dataOffset() const
Definition: array-impl.h:916
Array(Array< T_numtype, N_rank > &array, const StridedDomain< N_rank > &subdomain)
Definition: array-impl.h:858
Array(Range r0, Range r1, Range r2, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:504
bool 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
Array(_bz_ArrayExpr< T_expr > expr)
Construct an array from an expression.
T_array operator()(Range r0, Range r1) const
Definition: array-impl.h:1903
Definition: listinit.h:71
bool isInRange(int i0, int i1) const
Definition: array-impl.h:1213
const TinyVector< diffType, N_rank > & stride() const
Definition: array-impl.h:1173
T_numtype & operator()(TinyVector< int, 1 > index)
Definition: array-impl.h:1483
void doTranspose(int destRank, int sourceRank, T_array &array)
T_numtype &restrict operator()(int i0, int i1, int i2, int i3)
Definition: array-impl.h:1740
Array(const Array< T_numtype, N_rank > &array)
Definition: array-impl.h:757
bool assertInRange(int BZ_DEBUG_PARAM(i0), int BZ_DEBUG_PARAM(i1), int BZ_DEBUG_PARAM(i2)) const
Definition: array-impl.h:1342
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)
T_numtype & operator()(const TinyVector< int, 10 > &index)
Definition: array-impl.h:1655
T_array & operator&=(T_numtype)
Scalar operand assignment.
const T_numtype &restrict operator()(const TinyVector< int, N_rank2 > &index) const
Definition: array-impl.h:1464
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 length(int rank) const
Definition: array-impl.h:1005
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0 > > operator()(IndexPlaceholder< N0 >) const
Definition: array-impl.h:2095
TinyVector< int, N_rank > T_index
Definition: array-impl.h:134
diffType zeroOffset_
Definition: array-impl.h:2505
bool isInRange(int i0) const
Definition: array-impl.h:1209
Array< P_numtype2, N_rank > chopComponent(P_numtype2 a, int compNum, int numComponents) const
Definition: array-impl.h:898
bool isVectorAligned(diffType offset) const
Returns true if the array is aligned on a simd vector width.
Definition: array-impl.h:1198
bool threadLocal(bool disableLock=true) const
Definition: array-impl.h:1179
T_array & operator>>=(T_numtype)
Scalar operand assignment.
static const int rank_
Definition: array-impl.h:157
T_array & operator+=(T_numtype)
Scalar operand assignment.
const T_numtype &restrict operator()(TinyVector< int, 3 > index) const
Definition: array-impl.h:1503
const Array< typename multicomponent_traits< T_numtype >::T_element, N_rank > operator[](const unsigned component) const
Definition: array-impl.h:2230
bool 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
Definition: tvecglobs.h:70
const_iterator end() const
Definition: array-impl.h:972
T_array & operator<<=(T_numtype)
Scalar operand assignment.
T_array operator()(const RectDomain< N_rank > &subdomain) const
Definition: array-impl.h:1887
Array(const TinyVector< int, N_rank > &extent, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:455
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
const T_numtype &restrict operator()(int i0, int i1, int i2) const
Definition: array-impl.h:1719
int ordering(int storageRankIndex) const
Definition: array-impl.h:1023
sizeType blockLength() const
Returns the allocated length of the memory block.
Definition: memblock.h:435
T_numtype *restrict getInitializationIterator()
Definition: array-impl.h:2395
Array(int length0, int length1, int length2, int length3, int length4, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:231
T_numtype &restrict operator()(int i0, int i1, int i2, int i3, int i4)
Definition: array-impl.h:1755
static bool isVectorAligned(const T *restrict pointer)
Test if a pointer to T is simd aligned.
Definition: simdtypes.h:46
int dimensions() const
Definition: array-impl.h:961
Definition: et-forward.h:10
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
const T_numtype &restrict operator()(const TinyVector< int, 9 > &index) const
Definition: array-impl.h:1619
T_array reindex(const TinyVector< int, N_rank > &)
Definition: memblock.h:50
T_array operator()(const StridedDomain< N_rank > &subdomain) const
Definition: array-impl.h:1893
IndirectArray< T_array, T_indexContainer > operator[](const T_indexContainer &index)
Definition: array-impl.h:2253
bool isInRange(int i0, int i1, int i2) const
Definition: array-impl.h:1218
T_numtype &restrict operator()(int i0)
Definition: array-impl.h:1701
Array(Range r0, Range r1, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:489
_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
T_array copy() const
static T_ret product(const TinyVector< T_numtype1, N_length > &a)
Definition: tvecglobs.h:83
void slice(int rank, Range r)
TinyVector< diffType, N_rank > stride_
Definition: array-impl.h:2504
const T_numtype &restrict operator()(int i0, int i1, int i2, int i3) const
Definition: array-impl.h:1733
Array(T_numtype *restrict 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 T_numtype &restrict 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
const T_numtype &restrict operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7) const
Definition: array-impl.h:1799
ArrayIterator< T_numtype, N_rank > iterator
Definition: array-impl.h:138
Array(int length0, int length1, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:194
diffType dataFirstOffset() const
Definition: array-impl.h:937
T_numtype &restrict operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6)
Definition: array-impl.h:1790
bool canCollapse(int outerRank, int innerRank) const
Definition: array-impl.h:2398
bool isInRange(int i0, int i1, int i2, int i3, int i4) const
Definition: array-impl.h:1231
T_array operator()(Range r0, Range r1, Range r2, Range r3) const
Definition: array-impl.h:1913
T_array & initialize(T_numtype)
Scalar operand assignment.
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
bool isInRange(int i0, int i1, int i2, int i3, int i4, int i5) const
Definition: array-impl.h:1239
bool 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
const T_numtype &restrict operator()(const TinyVector< int, 5 > &index) const
Definition: array-impl.h:1535
bool 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
TinyVector< int, N_rank > ubound() const
Definition: array-impl.h:1185
T_array operator()(Range r0) const
Definition: array-impl.h:1898
bool isMajorRank(int rank) const
Definition: array-impl.h:991
void slice(int &, nilArraySection, Array< T_numtype, N_rank2 > &, TinyVector< int, N_rank2 > &, int)
Definition: array-impl.h:2459
Definition: array-impl.h:82
const T_numtype &restrict operator()(const TinyVector< int, 8 > &index) const
Definition: array-impl.h:1597
T_type *restrict data_
Definition: memblock.h:313
iterator end()
Definition: array-impl.h:969
T_numtype & operator()(const TinyVector< int, 8 > &index)
Definition: array-impl.h:1608
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1)
Definition: array-impl.h:792
Definition: array-impl.h:66
Array(Range r0, Range r1, Range r2, Range r3, Range r4, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:541
_bz_inline2 void setupStorage(int rank)
diffType stride(int rank) const
Definition: array-impl.h:1176
Array< typename multicomponent_traits< T_numtype >::T_element, N_rank > operator[](const unsigned component)
Definition: array-impl.h:2222
Definition: et-forward.h:48
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
ptrdiff_t diffType
Definition: blitz.h:111
const T_numtype &restrict operator()(int i0, int i1, int i2, int i3, int i4) const
Definition: array-impl.h:1747
const T_numtype &restrict operator()(const TinyVector< int, 10 > &index) const
Definition: array-impl.h:1643
T_numtype &restrict operator()(int i0, int i1, int i2, int i3, int i4, int i5)
Definition: array-impl.h:1772
void calculateZeroOffset()
bool 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
_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
bool assertInRange(const T_index &BZ_DEBUG_PARAM(index)) const
Definition: array-impl.h:1320
T_array & operator^=(T_numtype)
Scalar operand assignment.
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)
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
static int rank()
Definition: array-impl.h:1036
int columns() const
Definition: array-impl.h:905
T_array & operator/=(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)
Definition: array-impl.h:820
T_numtype &restrict operator()(const TinyVector< int, N_rank2 > &index)
Definition: array-impl.h:1471
bool 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
int depth() const
Definition: array-impl.h:958
sizeType storageSize() const
Returns the length of the array storage.
Definition: array-impl.h:1170
const TinyVector< int, N_rank > & extent() const
Definition: array-impl.h:978
Definition: array-impl.h:85
bool 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
_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
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
FastArrayIterator< T_numtype, N_rank > T_iterator
Definition: array-impl.h:136
size_t sizeType
Definition: blitz.h:110
Array(GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:178
bool isStorageContiguous() const
GeneralArrayStorage< N_rank > storage_
Definition: array-impl.h:2502
bool isRankStoredAscending(int rank) const
Definition: array-impl.h:995
sizeType numElements() const
Definition: array-impl.h:1012
bool isInRange(const T_index &index) const
Definition: array-impl.h:1312
const TinyVector< int, N_rank > & ordering() const
Definition: array-impl.h:1026
const T_numtype &restrict operator()(int i0) const
Definition: array-impl.h:1695
const TinyVector< int, N_rank > & base() const
Definition: array-impl.h:881
const T_numtype &restrict operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6) const
Definition: array-impl.h:1781
void swap(Array< P_numtype, N_rank > &, Array< P_numtype, N_rank > &)
Definition: array-impl.h:2523
Definition: memblock.h:67
int zeroOffset() const
Definition: array-impl.h:1194
int cols() const
Definition: array-impl.h:902
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
ConstArrayIterator< T_numtype, N_rank > const_iterator
Definition: array-impl.h:139
Array< typename multicomponent_traits< T_numtype >::T_element, N_rank > operator[](const int component)
Definition: array-impl.h:2238
Array< T_numtype, N_rank > T_array
Definition: array-impl.h:135
Definition: memblock.h:51
Array(Array< T_numtype, N_rank > &array, const RectDomain< N_rank > &subdomain)
Definition: array-impl.h:851
Array(int length0, int length1, int length2, int length3, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:219
Declaration of class Array, the "Swiss army knife" of Blitz expression template classes.
Definition: array-impl.h:106
N_length & a
Definition: tvecglobs.h:47
T_numtype &restrict 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
T_array & operator|=(T_numtype)
Scalar operand assignment.
RectDomain< N_rank > domain() const
Definition: array-impl.h:964
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3)
Definition: array-impl.h:802
void find(Array< TinyVector< int, N_rank >, 1 > &, const Array< P_numtype, N_rank > &)
Definition: array-impl.h:2537
#define _bz_inline2
Definition: tuning.h:126
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
bool lockReferenceCount(bool lockingPolicy) const
Definition: memblock.h:451
_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
const T_numtype &restrict operator()(const TinyVector< int, 6 > &index) const
Definition: array-impl.h:1555
preexistingMemoryPolicy
Definition: memblock.h:49
const T_numtype &restrict operator()(TinyVector< int, 2 > index) const
Definition: array-impl.h:1489
bool isMinorRank(int rank) const
Definition: array-impl.h:993
int lbound(int rank) const
Definition: array-impl.h:1000
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
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
T_numtype &restrict operator()(int i0, int i1, int i2)
Definition: array-impl.h:1726
const T_numtype &restrict operator()(TinyVector< int, 1 > index) const
Definition: array-impl.h:1477
Array(T_numtype *restrict 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
T_array & operator%=(T_numtype)
Scalar operand assignment.
Definition: memblock.h:52
#define BZ_ETPARM(X)
Definition: tuning.h:138
Definition: array-impl.h:76
TinyVector< int, N_rank > length_
Definition: array-impl.h:2503
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6) const
Definition: array-impl.h:1929
const TinyVector< int, N_rank > & length() const
Definition: array-impl.h:1007
T_array operator()(Range r0, Range r1, Range r2, Range r3, Range r4) const
Definition: array-impl.h:1918
T_numtype & operator()(const TinyVector< int, 5 > &index)
Definition: array-impl.h:1545
T_numtype *restrict dataFirst()
Definition: array-impl.h:955
T_numtype &restrict operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8)
Definition: array-impl.h:1827
bool 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 reference(const T_array &)
ListInitializationSwitch< T_array > operator=(T_numtype x)
Scalar operand assignment.
Definition: array-impl.h:2271
T_array reverse(int rank)
N_length const TinyVector< T_numtype2, N_length > & b
Definition: tvecglobs.h:49
Definition: range.h:65
bool assertInRange(int BZ_DEBUG_PARAM(i0)) const
Definition: array-impl.h:1327
const T_numtype *restrict dataFirst() const
Definition: array-impl.h:952
const T_numtype *restrict dataZero() const
Definition: array-impl.h:928
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 > lbound() const
Definition: array-impl.h:1002
const T_numtype &restrict operator()(int i0, int i1, int i2, int i3, int i4, int i5) const
Definition: array-impl.h:1763
T_numtype *restrict data()
Definition: array-impl.h:922
P_numtype T_numtype
Definition: array-impl.h:133
#define restrict
Definition: compiler.h:95
T_array & operator*=(T_numtype)
Scalar operand assignment.
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
_bz_inline2 void computeStrides()
const TinyVector< int, N_rank > & shape() const
Definition: array-impl.h:1159
Array(Array< T_numtype, N_rank > &array, Range r0, Range r1, Range r2, Range r3, Range r4)
Definition: array-impl.h:808
T_array & operator-=(T_numtype)
Scalar operand assignment.
const T_numtype &restrict 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(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
bool isInRangeForDim(int i, int d) const
Definition: array-impl.h:1205
Array(Range r0, Range r1, Range r2, Range r3, GeneralArrayStorage< N_rank > storage=T_default_storage())
Definition: array-impl.h:521
_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_numtype &restrict operator()(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7)
Definition: array-impl.h:1808
const T_numtype &restrict 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
T_numtype first(T_numtype lowRange=0) const
Definition: range.h:228
T_array operator()(Range r0, Range r1, Range r2) const
Definition: array-impl.h:1908
_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(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
void dumpStructureInformation(ostream &os=cout) const
const_iterator begin() const
Definition: array-impl.h:890
MemoryBlockReference< P_numtype > T_base
Definition: array-impl.h:113
_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
const T_numtype &restrict operator()(const TinyVector< int, 7 > &index) const
Definition: array-impl.h:1575
int rows() const
Definition: array-impl.h:1152
const T_numtype *restrict data() const
Definition: array-impl.h:919
T_numtype & operator()(const TinyVector< int, 9 > &index)
Definition: array-impl.h:1631
Definition: array-impl.h:79
iterator begin()
Definition: array-impl.h:887
void weakReference(const T_array &)
bool isInRange(int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7) const
Definition: array-impl.h:1258
int extent(int rank) const
Definition: array-impl.h:975
void reindexSelf(const TinyVector< int, N_rank > &)
bool 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
const T_numtype &restrict operator()(const TinyVector< int, 4 > &index) const
Definition: array-impl.h:1519
T_numtype & operator()(TinyVector< int, 2 > index)
Definition: array-impl.h:1496
T_numtype & operator()(const TinyVector< int, 7 > &index)
Definition: array-impl.h:1586
_bz_ArrayExpr< ArrayIndexMapping< typename asExpr< T_array >::T_expr, N0, N1 > > operator()(IndexPlaceholder< N0 >, IndexPlaceholder< N1 >) const
Definition: array-impl.h:2103