ARTS  2.0.49
matpackVI.cc
Go to the documentation of this file.
1 /* Copyright (C) 2002-2008 Stefan Buehler <sbuehler@ltu.se>
2 
3  This program is free software; you can redistribute it and/or modify it
4  under the terms of the GNU General Public License as published by the
5  Free Software Foundation; either version 2, or (at your option) any
6  later version.
7 
8  This program is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  GNU General Public License for more details.
12 
13  You should have received a copy of the GNU General Public License
14  along with this program; if not, write to the Free Software
15  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
16  USA. */
17 
25 #include "matpackVI.h"
26 
27 // Functions for ConstTensor6View:
28 // ------------------------------
29 
31 Index ConstTensor6View::nvitrines() const
32 {
33  return mvr.mextent;
34 }
35 
37 Index ConstTensor6View::nshelves() const
38 {
39  return msr.mextent;
40 }
41 
43 Index ConstTensor6View::nbooks() const
44 {
45  return mbr.mextent;
46 }
47 
49 Index ConstTensor6View::npages() const
50 {
51  return mpr.mextent;
52 }
53 
55 Index ConstTensor6View::nrows() const
56 {
57  return mrr.mextent;
58 }
59 
61 Index ConstTensor6View::ncols() const
62 {
63  return mcr.mextent;
64 }
65 
66 // Const index operators:
67 
68 // Result 6D (1 combination)
69 // ------
70 ConstTensor6View ConstTensor6View::operator()
71  ( const Range& v, const Range& s, const Range& b,
72  const Range& p, const Range& r, const Range& c) const
73 {
74  return ConstTensor6View(mdata,
75  mvr, msr, mbr, mpr, mrr, mcr,
76  v, s, b, p, r, c);
77 }
78 
79 // Result 5D (6 combinations)
80 // -----|
81 ConstTensor5View ConstTensor6View::operator()
82  ( const Range& v, const Range& s, const Range& b,
83  const Range& p, const Range& r, Index c) const
84 {
85  CHECK(c);
86  return ConstTensor5View(mdata + OFFSET(c),
87  mvr, msr, mbr, mpr, mrr,
88  v, s, b, p, r);
89 }
90 
91 // ----|-
92 ConstTensor5View ConstTensor6View::operator()
93  ( const Range& v, const Range& s, const Range& b,
94  const Range& p, Index r, const Range& c) const
95 {
96  CHECK(r);
97  return ConstTensor5View(mdata + OFFSET(r),
98  mvr, msr, mbr, mpr, mcr,
99  v, s, b, p, c);
100 }
101 
102 // ---|--
103 ConstTensor5View ConstTensor6View::operator()
104  ( const Range& v, const Range& s, const Range& b,
105  Index p, const Range& r, const Range& c) const
106 {
107  CHECK(p);
108  return ConstTensor5View(mdata + OFFSET(p),
109  mvr, msr, mbr, mrr, mcr,
110  v, s, b, r, c);
111 }
112 
113 // --|---
114 ConstTensor5View ConstTensor6View::operator()
115  ( const Range& v, const Range& s, Index b,
116  const Range& p, const Range& r, const Range& c) const
117 {
118  CHECK(b);
119  return ConstTensor5View(mdata + OFFSET(b),
120  mvr, msr, mpr, mrr, mcr,
121  v, s, p, r, c);
122 }
123 
124 // -|----
125 ConstTensor5View ConstTensor6View::operator()
126  ( const Range& v, Index s, const Range& b,
127  const Range& p, const Range& r, const Range& c) const
128 {
129  CHECK(s);
130  return ConstTensor5View(mdata + OFFSET(s),
131  mvr, mbr, mpr, mrr, mcr,
132  v, b, p, r, c);
133 }
134 
135 // |-----
136 ConstTensor5View ConstTensor6View::operator()
137  ( Index v, const Range& s, const Range& b,
138  const Range& p, const Range& r, const Range& c) const
139 {
140  CHECK(v);
141  return ConstTensor5View(mdata + OFFSET(v),
142  msr, mbr, mpr, mrr, mcr,
143  s, b, p, r, c);
144 }
145 
146 
147 // Result 4D (5+4+3+2+1 = 15 combinations)
148 // ----||
149 ConstTensor4View ConstTensor6View::operator()
150  ( const Range& v, const Range& s, const Range& b,
151  const Range& p, Index r, Index c) const
152 {
153  CHECK(r);
154  CHECK(c);
155  return ConstTensor4View(mdata + OFFSET(r) + OFFSET(c),
156  mvr, msr, mbr, mpr,
157  v, s, b, p );
158 }
159 
160 // ---|-|
161 ConstTensor4View ConstTensor6View::operator()
162  ( const Range& v, const Range& s, const Range& b,
163  Index p, const Range& r, Index c) const
164 {
165  CHECK(p);
166  CHECK(c);
167  return ConstTensor4View(mdata + OFFSET(p) + OFFSET(c),
168  mvr, msr, mbr, mrr,
169  v, s, b, r );
170 }
171 
172 // --|--|
173 ConstTensor4View ConstTensor6View::operator()
174  ( const Range& v, const Range& s, Index b,
175  const Range& p, const Range& r, Index c) const
176 {
177  CHECK(b);
178  CHECK(c);
179  return ConstTensor4View(mdata + OFFSET(b) + OFFSET(c),
180  mvr, msr, mpr, mrr,
181  v, s, p, r );
182 }
183 
184 // -|---|
185 ConstTensor4View ConstTensor6View::operator()
186  ( const Range& v, Index s, const Range& b,
187  const Range& p, const Range& r, Index c) const
188 {
189  CHECK(s);
190  CHECK(c);
191  return ConstTensor4View(mdata + OFFSET(s) + OFFSET(c),
192  mvr, mbr, mpr, mrr,
193  v, b, p, r );
194 }
195 
196 // |----|
197 ConstTensor4View ConstTensor6View::operator()
198  ( Index v, const Range& s, const Range& b,
199  const Range& p, const Range& r, Index c) const
200 {
201  CHECK(v);
202  CHECK(c);
203  return ConstTensor4View(mdata + OFFSET(v) + OFFSET(c),
204  msr, mbr, mpr, mrr,
205  s, b, p, r );
206 }
207 
208 // ---||-
209 ConstTensor4View ConstTensor6View::operator()
210  ( const Range& v, const Range& s, const Range& b,
211  Index p, Index r, const Range& c) const
212 {
213  CHECK(p);
214  CHECK(r);
215  return ConstTensor4View(mdata + OFFSET(p) + OFFSET(r),
216  mvr, msr, mbr, mcr,
217  v, s, b, c );
218 }
219 
220 // --|-|-
221 ConstTensor4View ConstTensor6View::operator()
222  ( const Range& v, const Range& s, Index b,
223  const Range& p, Index r, const Range& c) const
224 {
225  CHECK(b);
226  CHECK(r);
227  return ConstTensor4View(mdata + OFFSET(b) + OFFSET(r),
228  mvr, msr, mpr, mcr,
229  v, s, p, c );
230 }
231 
232 // -|--|-
233 ConstTensor4View ConstTensor6View::operator()
234  ( const Range& v, Index s, const Range& b,
235  const Range& p, Index r, const Range& c) const
236 {
237  CHECK(s);
238  CHECK(r);
239  return ConstTensor4View(mdata + OFFSET(s) + OFFSET(r),
240  mvr, mbr, mpr, mcr,
241  v, b, p, c );
242 }
243 
244 // |---|-
245 ConstTensor4View ConstTensor6View::operator()
246  ( Index v, const Range& s, const Range& b,
247  const Range& p, Index r, const Range& c) const
248 {
249  CHECK(v);
250  CHECK(r);
251  return ConstTensor4View(mdata + OFFSET(v) + OFFSET(r),
252  msr, mbr, mpr, mcr,
253  s, b, p, c );
254 }
255 
256 // --||--
257 ConstTensor4View ConstTensor6View::operator()
258  ( const Range& v, const Range& s, Index b,
259  Index p, const Range& r, const Range& c) const
260 {
261  CHECK(b);
262  CHECK(p);
263  return ConstTensor4View(mdata + OFFSET(b) + OFFSET(p),
264  mvr, msr, mrr, mcr,
265  v, s, r, c );
266 }
267 
268 // -|-|--
269 ConstTensor4View ConstTensor6View::operator()
270  ( const Range& v, Index s, const Range& b,
271  Index p, const Range& r, const Range& c) const
272 {
273  CHECK(s);
274  CHECK(p);
275  return ConstTensor4View(mdata + OFFSET(s) + OFFSET(p),
276  mvr, mbr, mrr, mcr,
277  v, b, r, c );
278 }
279 
280 // |--|--
281 ConstTensor4View ConstTensor6View::operator()
282  ( Index v, const Range& s, const Range& b,
283  Index p, const Range& r, const Range& c) const
284 {
285  CHECK(v);
286  CHECK(p);
287  return ConstTensor4View(mdata + OFFSET(v) + OFFSET(p),
288  msr, mbr, mrr, mcr,
289  s, b, r, c );
290 }
291 
292 // -||---
293 ConstTensor4View ConstTensor6View::operator()
294  ( const Range& v, Index s, Index b,
295  const Range& p, const Range& r, const Range& c) const
296 {
297  CHECK(s);
298  CHECK(b);
299  return ConstTensor4View(mdata + OFFSET(s) + OFFSET(b),
300  mvr, mpr, mrr, mcr,
301  v, p, r, c );
302 }
303 
304 // |-|---
305 ConstTensor4View ConstTensor6View::operator()
306  ( Index v, const Range& s, Index b,
307  const Range& p, const Range& r, const Range& c) const
308 {
309  CHECK(v);
310  CHECK(b);
311  return ConstTensor4View(mdata + OFFSET(v) + OFFSET(b),
312  msr, mpr, mrr, mcr,
313  s, p, r, c );
314 }
315 
316 // ||----
317 ConstTensor4View ConstTensor6View::operator()
318  ( Index v, Index s, const Range& b,
319  const Range& p, const Range& r, const Range& c) const
320 {
321  CHECK(v);
322  CHECK(s);
323  return ConstTensor4View(mdata + OFFSET(v) + OFFSET(s),
324  mbr, mpr, mrr, mcr,
325  b, p, r, c );
326 }
327 
328 
329 // Result 3D (4+3+2+1+ 3+2+1+ 2+1 +1 = 20 combinations)
330 // ---|||
331 ConstTensor3View ConstTensor6View::operator()
332  ( const Range& v, const Range& s, const Range& b,
333  Index p, Index r, Index c) const
334 {
335  CHECK(p);
336  CHECK(r);
337  CHECK(c);
338  return ConstTensor3View(mdata + OFFSET(p) + OFFSET(r) + OFFSET(c),
339  mvr, msr, mbr,
340  v, s, b );
341 }
342 
343 // --|-||
344 ConstTensor3View ConstTensor6View::operator()
345  ( const Range& v, const Range& s, Index b,
346  const Range& p, Index r, Index c) const
347 {
348  CHECK(b);
349  CHECK(r);
350  CHECK(c);
351  return ConstTensor3View(mdata + OFFSET(b) + OFFSET(r) + OFFSET(c),
352  mvr, msr, mpr,
353  v, s, p );
354 }
355 
356 // -|--||
357 ConstTensor3View ConstTensor6View::operator()
358  ( const Range& v, Index s, const Range& b,
359  const Range& p, Index r, Index c) const
360 {
361  CHECK(s);
362  CHECK(r);
363  CHECK(c);
364  return ConstTensor3View(mdata + OFFSET(s) + OFFSET(r) + OFFSET(c),
365  mvr, mbr, mpr,
366  v, b, p );
367 }
368 
369 // |---||
370 ConstTensor3View ConstTensor6View::operator()
371  ( Index v, const Range& s, const Range& b,
372  const Range& p, Index r, Index c) const
373 {
374  CHECK(v);
375  CHECK(r);
376  CHECK(c);
377  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(r) + OFFSET(c),
378  msr, mbr, mpr,
379  s, b, p );
380 }
381 
382 // --||-|
383 ConstTensor3View ConstTensor6View::operator()
384  ( const Range& v, const Range& s, Index b,
385  Index p, const Range& r, Index c) const
386 {
387  CHECK(b);
388  CHECK(p);
389  CHECK(c);
390  return ConstTensor3View(mdata + OFFSET(b) + OFFSET(p) + OFFSET(c),
391  mvr, msr, mrr,
392  v, s, r );
393 }
394 
395 // -|-|-|
396 ConstTensor3View ConstTensor6View::operator()
397  ( const Range& v, Index s, const Range& b,
398  Index p, const Range& r, Index c) const
399 {
400  CHECK(s);
401  CHECK(p);
402  CHECK(c);
403  return ConstTensor3View(mdata + OFFSET(s) + OFFSET(p) + OFFSET(c),
404  mvr, mbr, mrr,
405  v, b, r );
406 }
407 
408 // |--|-|
409 ConstTensor3View ConstTensor6View::operator()
410  ( Index v, const Range& s, const Range& b,
411  Index p, const Range& r, Index c) const
412 {
413  CHECK(v);
414  CHECK(p);
415  CHECK(c);
416  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(p) + OFFSET(c),
417  msr, mbr, mrr,
418  s, b, r );
419 }
420 
421 // -||--|
422 ConstTensor3View ConstTensor6View::operator()
423  ( const Range& v, Index s, Index b,
424  const Range& p, const Range& r, Index c) const
425 {
426  CHECK(s);
427  CHECK(b);
428  CHECK(c);
429  return ConstTensor3View(mdata + OFFSET(s) + OFFSET(b) + OFFSET(c),
430  mvr, mpr, mrr,
431  v, p, r );
432 }
433 
434 // |-|--|
435 ConstTensor3View ConstTensor6View::operator()
436  ( Index v, const Range& s, Index b,
437  const Range& p, const Range& r, Index c) const
438 {
439  CHECK(v);
440  CHECK(b);
441  CHECK(c);
442  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(b) + OFFSET(c),
443  msr, mpr, mrr,
444  s, p, r );
445 }
446 
447 // ||---|
448 ConstTensor3View ConstTensor6View::operator()
449  ( Index v, Index s, const Range& b,
450  const Range& p, const Range& r, Index c) const
451 {
452  CHECK(v);
453  CHECK(s);
454  CHECK(c);
455  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(s) + OFFSET(c),
456  mbr, mpr, mrr,
457  b, p, r );
458 }
459 
460 // --|||-
461 ConstTensor3View ConstTensor6View::operator()
462  ( const Range& v, const Range& s, Index b,
463  Index p, Index r, const Range& c) const
464 {
465  CHECK(b);
466  CHECK(p);
467  CHECK(r);
468  return ConstTensor3View(mdata + OFFSET(b) + OFFSET(p) + OFFSET(r),
469  mvr, msr, mcr,
470  v, s, c );
471 }
472 
473 // -|-||-
474 ConstTensor3View ConstTensor6View::operator()
475  ( const Range& v, Index s, const Range& b,
476  Index p, Index r, const Range& c) const
477 {
478  CHECK(s);
479  CHECK(p);
480  CHECK(r);
481  return ConstTensor3View(mdata + OFFSET(s) + OFFSET(p) + OFFSET(r),
482  mvr, mbr, mcr,
483  v, b, c );
484 }
485 
486 // |--||-
487 ConstTensor3View ConstTensor6View::operator()
488  ( Index v, const Range& s, const Range& b,
489  Index p, Index r, const Range& c) const
490 {
491  CHECK(v);
492  CHECK(p);
493  CHECK(r);
494  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(p) + OFFSET(r),
495  msr, mbr, mcr,
496  s, b, c );
497 }
498 
499 // -||-|-
500 ConstTensor3View ConstTensor6View::operator()
501  ( const Range& v, Index s, Index b,
502  const Range& p, Index r, const Range& c) const
503 {
504  CHECK(s);
505  CHECK(b);
506  CHECK(r);
507  return ConstTensor3View(mdata + OFFSET(s) + OFFSET(b) + OFFSET(r),
508  mvr, mpr, mcr,
509  v, p, c );
510 }
511 
512 // |-|-|-
513 ConstTensor3View ConstTensor6View::operator()
514  ( Index v, const Range& s, Index b,
515  const Range& p, Index r, const Range& c) const
516 {
517  CHECK(v);
518  CHECK(b);
519  CHECK(r);
520  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(b) + OFFSET(r),
521  msr, mpr, mcr,
522  s, p, c );
523 }
524 
525 // ||--|-
526 ConstTensor3View ConstTensor6View::operator()
527  ( Index v, Index s, const Range& b,
528  const Range& p, Index r, const Range& c) const
529 {
530  CHECK(v);
531  CHECK(s);
532  CHECK(r);
533  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(s) + OFFSET(r),
534  mbr, mpr, mcr,
535  b, p, c );
536 }
537 
538 // -|||--
539 ConstTensor3View ConstTensor6View::operator()
540  ( const Range& v, Index s, Index b,
541  Index p, const Range& r, const Range& c) const
542 {
543  CHECK(s);
544  CHECK(b);
545  CHECK(p);
546  return ConstTensor3View(mdata + OFFSET(s) + OFFSET(b) + OFFSET(p),
547  mvr, mrr, mcr,
548  v, r, c );
549 }
550 
551 // |-||--
552 ConstTensor3View ConstTensor6View::operator()
553  ( Index v, const Range& s, Index b,
554  Index p, const Range& r, const Range& c) const
555 {
556  CHECK(v);
557  CHECK(b);
558  CHECK(p);
559  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(b) + OFFSET(p),
560  msr, mrr, mcr,
561  s, r, c );
562 }
563 
564 // ||-|--
565 ConstTensor3View ConstTensor6View::operator()
566  ( Index v, Index s, const Range& b,
567  Index p, const Range& r, const Range& c) const
568 {
569  CHECK(v);
570  CHECK(s);
571  CHECK(p);
572  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(s) + OFFSET(p),
573  mbr, mrr, mcr,
574  b, r, c );
575 }
576 
577 // |||---
578 ConstTensor3View ConstTensor6View::operator()
579  ( Index v, Index s, Index b,
580  const Range& p, const Range& r, const Range& c) const
581 {
582  CHECK(v);
583  CHECK(s);
584  CHECK(b);
585  return ConstTensor3View(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b),
586  mpr, mrr, mcr,
587  p, r, c );
588 }
589 
590 
591 // Result 2D (15 combinations)
592 // IIII--
593 ConstMatrixView ConstTensor6View::operator()
594  ( Index v, Index s, Index b,
595  Index p, const Range& r, const Range& c) const
596 {
597  CHECK(v);
598  CHECK(s);
599  CHECK(b);
600  CHECK(p);
601  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(p),
602  mrr, mcr,
603  r, c );
604 }
605 
606 // III-I-
607 ConstMatrixView ConstTensor6View::operator()
608  ( Index v, Index s, Index b,
609  const Range& p, Index r, const Range& c) const
610 {
611  CHECK(v);
612  CHECK(s);
613  CHECK(b);
614  CHECK(r);
615  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(r),
616  mpr, mcr,
617  p, c );
618 }
619 
620 // II-II-
621 ConstMatrixView ConstTensor6View::operator()
622  ( Index v, Index s, const Range& b,
623  Index p, Index r, const Range& c) const
624 {
625  CHECK(v);
626  CHECK(s);
627  CHECK(p);
628  CHECK(r);
629  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(p) + OFFSET(r),
630  mbr, mcr,
631  b, c );
632 }
633 
634 // I-III-
635 ConstMatrixView ConstTensor6View::operator()
636  ( Index v, const Range& s, Index b,
637  Index p, Index r, const Range& c) const
638 {
639  CHECK(v);
640  CHECK(b);
641  CHECK(p);
642  CHECK(r);
643  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(b) + OFFSET(p) + OFFSET(r),
644  msr, mcr,
645  s, c );
646 }
647 
648 // -IIII-
649 ConstMatrixView ConstTensor6View::operator()
650  ( const Range& v, Index s, Index b,
651  Index p, Index r, const Range& c) const
652 {
653  CHECK(s);
654  CHECK(b);
655  CHECK(p);
656  CHECK(r);
657  return ConstMatrixView(mdata + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(r),
658  mvr, mcr,
659  v, c );
660 }
661 
662 // III--I
663 ConstMatrixView ConstTensor6View::operator()
664  ( Index v, Index s, Index b,
665  const Range& p, const Range& r, Index c) const
666 {
667  CHECK(v);
668  CHECK(s);
669  CHECK(b);
670  CHECK(c);
671  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(c),
672  mpr, mrr,
673  p, r );
674 }
675 
676 // II-I-I
677 ConstMatrixView ConstTensor6View::operator()
678  ( Index v, Index s, const Range& b,
679  Index p, const Range& r, Index c) const
680 {
681  CHECK(v);
682  CHECK(s);
683  CHECK(p);
684  CHECK(c);
685  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(p) + OFFSET(c),
686  mbr, mrr,
687  b, r );
688 }
689 
690 // I-II-I
691 ConstMatrixView ConstTensor6View::operator()
692  ( Index v, const Range& s, Index b,
693  Index p, const Range& r, Index c) const
694 {
695  CHECK(v);
696  CHECK(b);
697  CHECK(p);
698  CHECK(c);
699  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(b) + OFFSET(p) + OFFSET(c),
700  msr, mrr,
701  s, r );
702 }
703 
704 // -III-I
705 ConstMatrixView ConstTensor6View::operator()
706  ( const Range& v, Index s, Index b,
707  Index p, const Range& r, Index c) const
708 {
709  CHECK(s);
710  CHECK(b);
711  CHECK(p);
712  CHECK(c);
713  return ConstMatrixView(mdata + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(c),
714  mvr, mrr,
715  v, r );
716 }
717 
718 // II--II
719 ConstMatrixView ConstTensor6View::operator()
720  ( Index v, Index s, const Range& b,
721  const Range& p, Index r, Index c) const
722 {
723  CHECK(v);
724  CHECK(s);
725  CHECK(r);
726  CHECK(c);
727  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(r) + OFFSET(c),
728  mbr, mpr,
729  b, p );
730 }
731 
732 // I-I-II
733 ConstMatrixView ConstTensor6View::operator()
734  ( Index v, const Range& s, Index b,
735  const Range& p, Index r, Index c) const
736 {
737  CHECK(v);
738  CHECK(b);
739  CHECK(r);
740  CHECK(c);
741  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(b) + OFFSET(r) + OFFSET(c),
742  msr, mpr,
743  s, p );
744 }
745 
746 // -II-II
747 ConstMatrixView ConstTensor6View::operator()
748  ( const Range& v, Index s, Index b,
749  const Range& p, Index r, Index c) const
750 {
751  CHECK(s);
752  CHECK(b);
753  CHECK(r);
754  CHECK(c);
755  return ConstMatrixView(mdata + OFFSET(s) + OFFSET(b) + OFFSET(r) + OFFSET(c),
756  mvr, mpr,
757  v, p );
758 }
759 
760 // I--III
761 ConstMatrixView ConstTensor6View::operator()
762  ( Index v, const Range& s, const Range& b,
763  Index p, Index r, Index c) const
764 {
765  CHECK(v);
766  CHECK(p);
767  CHECK(r);
768  CHECK(c);
769  return ConstMatrixView(mdata + OFFSET(v) + OFFSET(p) + OFFSET(r) + OFFSET(c),
770  msr, mbr,
771  s, b );
772 }
773 
774 // -I-III
775 ConstMatrixView ConstTensor6View::operator()
776  ( const Range& v, Index s, const Range& b,
777  Index p, Index r, Index c) const
778 {
779  CHECK(s);
780  CHECK(p);
781  CHECK(r);
782  CHECK(c);
783  return ConstMatrixView(mdata + OFFSET(s) + OFFSET(p) + OFFSET(r) + OFFSET(c),
784  mvr, mbr,
785  v, b );
786 }
787 
788 // --IIII
789 ConstMatrixView ConstTensor6View::operator()
790  ( const Range& v, const Range& s, Index b,
791  Index p, Index r, Index c) const
792 {
793  CHECK(b);
794  CHECK(p);
795  CHECK(r);
796  CHECK(c);
797  return ConstMatrixView(mdata + OFFSET(b) + OFFSET(p) + OFFSET(r) + OFFSET(c),
798  mvr, msr,
799  v, s );
800 }
801 
802 
803 // Result 1D (6 combinations)
804 // IIIII-
805 ConstVectorView ConstTensor6View::operator()
806  ( Index v, Index s, Index b,
807  Index p, Index r, const Range& c) const
808 {
809  CHECK(v);
810  CHECK(s);
811  CHECK(b);
812  CHECK(p);
813  CHECK(r);
814  return ConstVectorView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(r),
815  mcr,
816  c );
817 }
818 
819 // IIII-I
820 ConstVectorView ConstTensor6View::operator()
821  ( Index v, Index s, Index b,
822  Index p, const Range& r, Index c) const
823 {
824  CHECK(v);
825  CHECK(s);
826  CHECK(b);
827  CHECK(p);
828  CHECK(c);
829  return ConstVectorView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(c),
830  mrr,
831  r );
832 }
833 
834 // III-II
835 ConstVectorView ConstTensor6View::operator()
836  ( Index v, Index s, Index b,
837  const Range& p, Index r, Index c) const
838 {
839  CHECK(v);
840  CHECK(s);
841  CHECK(b);
842  CHECK(r);
843  CHECK(c);
844  return ConstVectorView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(r) + OFFSET(c),
845  mpr,
846  p );
847 }
848 
849 // II-III
850 ConstVectorView ConstTensor6View::operator()
851  ( Index v, Index s, const Range& b,
852  Index p, Index r, Index c) const
853 {
854  CHECK(v);
855  CHECK(s);
856  CHECK(p);
857  CHECK(r);
858  CHECK(c);
859  return ConstVectorView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(p) + OFFSET(r) + OFFSET(c),
860  mbr,
861  b );
862 }
863 
864 // I-IIII
865 ConstVectorView ConstTensor6View::operator()
866  ( Index v, const Range& s, Index b,
867  Index p, Index r, Index c) const
868 {
869  CHECK(v);
870  CHECK(b);
871  CHECK(p);
872  CHECK(r);
873  CHECK(c);
874  return ConstVectorView(mdata + OFFSET(v) + OFFSET(b) + OFFSET(p) + OFFSET(r) + OFFSET(c),
875  msr,
876  s );
877 }
878 
879 // -IIIII
880 ConstVectorView ConstTensor6View::operator()
881  ( const Range& v, Index s, Index b,
882  Index p, Index r, Index c) const
883 {
884  CHECK(s);
885  CHECK(b);
886  CHECK(p);
887  CHECK(r);
888  CHECK(c);
889  return ConstVectorView(mdata + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(r) + OFFSET(c),
890  mvr,
891  v );
892 }
893 
894 
895 
896 
898 ConstIterator6D ConstTensor6View::begin() const
899 {
900  return ConstIterator6D( ConstTensor5View(mdata+mvr.mstart,
901  msr,
902  mbr,
903  mpr,
904  mrr,
905  mcr),
906  mvr.mstride);
907 }
908 
910 ConstIterator6D ConstTensor6View::end() const
911 {
912  return ConstIterator6D( ConstTensor5View(mdata + mvr.mstart +
913  (mvr.mextent)*mvr.mstride,
914  msr,
915  mbr,
916  mpr,
917  mrr,
918  mcr),
919  mvr.mstride );
920 }
921 
923 ConstTensor6View::ConstTensor6View(const ConstTensor5View& a) :
924  mvr(0,1,
925  a.msr.mextent*
926  a.mbr.mextent*
927  a.mpr.mextent*
928  a.mrr.mextent*
929  a.mcr.mextent),
930  msr(a.msr),
931  mbr(a.mbr),
932  mpr(a.mpr),
933  mrr(a.mrr),
934  mcr(a.mcr),
935  mdata(a.mdata)
936 {
937  // Nothing to do here.
938 }
939 
942 ConstTensor6View::ConstTensor6View() :
943  mvr(0,0,1), msr(0,0,1), mbr(0,0,1),
944  mpr(0,0,1), mrr(0,0,1), mcr(0,0,1),
945  mdata(NULL)
946 {
947  // Nothing to do here.
948 }
949 
954 ConstTensor6View::ConstTensor6View(Numeric *data,
955  const Range& v,
956  const Range& s,
957  const Range& b,
958  const Range& p,
959  const Range& r,
960  const Range& c) :
961  mvr(v),
962  msr(s),
963  mbr(b),
964  mpr(p),
965  mrr(r),
966  mcr(c),
967  mdata(data)
968 {
969  // Nothing to do here.
970 }
971 
979 ConstTensor6View::ConstTensor6View(Numeric *data,
980  const Range& pv,
981  const Range& ps,
982  const Range& pb,
983  const Range& pp,
984  const Range& pr,
985  const Range& pc,
986  const Range& nv,
987  const Range& ns,
988  const Range& nb,
989  const Range& np,
990  const Range& nr,
991  const Range& nc) :
992  mvr(pv,nv),
993  msr(ps,ns),
994  mbr(pb,nb),
995  mpr(pp,np),
996  mrr(pr,nr),
997  mcr(pc,nc),
998  mdata(data)
999 {
1000  // Nothing to do here.
1001 }
1002 
1006 ostream& operator<<(ostream& os, const ConstTensor6View& v)
1007 {
1008  // Page iterators:
1009  ConstIterator6D ip=v.begin();
1010  const ConstIterator6D end_page=v.end();
1011 
1012  if ( ip!=end_page )
1013  {
1014  os << *ip;
1015  ++ip;
1016  }
1017 
1018  for ( ; ip!=end_page; ++ip )
1019  {
1020  os << "\n\n";
1021  os << *ip;
1022  }
1023 
1024  return os;
1025 }
1026 
1027 
1028 // Functions for Tensor6View:
1029 // -------------------------
1030 
1031 // Const index operators:
1032 
1033 // Result 6D (1 combination)
1034 // ------
1035 ConstTensor6View Tensor6View::operator()
1036  ( const Range& v, const Range& s, const Range& b,
1037  const Range& p, const Range& r, const Range& c) const
1038 {
1039  return ConstTensor6View::operator()(v,s,b,p,r,c);
1040 }
1041 
1042 
1043 // Result 5D (6 combinations)
1044 // -----|
1045 ConstTensor5View Tensor6View::operator()
1046  ( const Range& v, const Range& s, const Range& b,
1047  const Range& p, const Range& r, Index c) const
1048 {
1049  return ConstTensor6View::operator()(v,s,b,p,r,c);
1050 }
1051 
1052 // ----|-
1053 ConstTensor5View Tensor6View::operator()
1054  ( const Range& v, const Range& s, const Range& b,
1055  const Range& p, Index r, const Range& c) const
1056 {
1057  return ConstTensor6View::operator()(v,s,b,p,r,c);
1058 }
1059 
1060 // ---|--
1061 ConstTensor5View Tensor6View::operator()
1062  ( const Range& v, const Range& s, const Range& b,
1063  Index p, const Range& r, const Range& c) const
1064 {
1065  return ConstTensor6View::operator()(v,s,b,p,r,c);
1066 }
1067 
1068 // --|---
1069 ConstTensor5View Tensor6View::operator()
1070  ( const Range& v, const Range& s, Index b,
1071  const Range& p, const Range& r, const Range& c) const
1072 {
1073  return ConstTensor6View::operator()(v,s,b,p,r,c);
1074 }
1075 
1076 // -|----
1077 ConstTensor5View Tensor6View::operator()
1078  ( const Range& v, Index s, const Range& b,
1079  const Range& p, const Range& r, const Range& c) const
1080 {
1081  return ConstTensor6View::operator()(v,s,b,p,r,c);
1082 }
1083 
1084 // |-----
1085 ConstTensor5View Tensor6View::operator()
1086  ( Index v, const Range& s, const Range& b,
1087  const Range& p, const Range& r, const Range& c) const
1088 {
1089  return ConstTensor6View::operator()(v,s,b,p,r,c);
1090 }
1091 
1092 
1093 // Result 4D (5+4+3+2+1 = 15 combinations)
1094 // ----||
1095 ConstTensor4View Tensor6View::operator()
1096  ( const Range& v, const Range& s, const Range& b,
1097  const Range& p, Index r, Index c) const
1098 {
1099  return ConstTensor6View::operator()(v,s,b,p,r,c);
1100 }
1101 
1102 // ---|-|
1103 ConstTensor4View Tensor6View::operator()
1104  ( const Range& v, const Range& s, const Range& b,
1105  Index p, const Range& r, Index c) const
1106 {
1107  return ConstTensor6View::operator()(v,s,b,p,r,c);
1108 }
1109 
1110 // --|--|
1111 ConstTensor4View Tensor6View::operator()
1112  ( const Range& v, const Range& s, Index b,
1113  const Range& p, const Range& r, Index c) const
1114 {
1115  return ConstTensor6View::operator()(v,s,b,p,r,c);
1116 }
1117 
1118 // -|---|
1119 ConstTensor4View Tensor6View::operator()
1120  ( const Range& v, Index s, const Range& b,
1121  const Range& p, const Range& r, Index c) const
1122 {
1123  return ConstTensor6View::operator()(v,s,b,p,r,c);
1124 }
1125 
1126 // |----|
1127 ConstTensor4View Tensor6View::operator()
1128  ( Index v, const Range& s, const Range& b,
1129  const Range& p, const Range& r, Index c) const
1130 {
1131  return ConstTensor6View::operator()(v,s,b,p,r,c);
1132 }
1133 
1134 // ---||-
1135 ConstTensor4View Tensor6View::operator()
1136  ( const Range& v, const Range& s, const Range& b,
1137  Index p, Index r, const Range& c) const
1138 {
1139  return ConstTensor6View::operator()(v,s,b,p,r,c);
1140 }
1141 
1142 // --|-|-
1143 ConstTensor4View Tensor6View::operator()
1144  ( const Range& v, const Range& s, Index b,
1145  const Range& p, Index r, const Range& c) const
1146 {
1147  return ConstTensor6View::operator()(v,s,b,p,r,c);
1148 }
1149 
1150 // -|--|-
1151 ConstTensor4View Tensor6View::operator()
1152  ( const Range& v, Index s, const Range& b,
1153  const Range& p, Index r, const Range& c) const
1154 {
1155  return ConstTensor6View::operator()(v,s,b,p,r,c);
1156 }
1157 
1158 // |---|-
1159 ConstTensor4View Tensor6View::operator()
1160  ( Index v, const Range& s, const Range& b,
1161  const Range& p, Index r, const Range& c) const
1162 {
1163  return ConstTensor6View::operator()(v,s,b,p,r,c);
1164 }
1165 
1166 // --||--
1167 ConstTensor4View Tensor6View::operator()
1168  ( const Range& v, const Range& s, Index b,
1169  Index p, const Range& r, const Range& c) const
1170 {
1171  return ConstTensor6View::operator()(v,s,b,p,r,c);
1172 }
1173 
1174 // -|-|--
1175 ConstTensor4View Tensor6View::operator()
1176  ( const Range& v, Index s, const Range& b,
1177  Index p, const Range& r, const Range& c) const
1178 {
1179  return ConstTensor6View::operator()(v,s,b,p,r,c);
1180 }
1181 
1182 // |--|--
1183 ConstTensor4View Tensor6View::operator()
1184  ( Index v, const Range& s, const Range& b,
1185  Index p, const Range& r, const Range& c) const
1186 {
1187  return ConstTensor6View::operator()(v,s,b,p,r,c);
1188 }
1189 
1190 // -||---
1191 ConstTensor4View Tensor6View::operator()
1192  ( const Range& v, Index s, Index b,
1193  const Range& p, const Range& r, const Range& c) const
1194 {
1195  return ConstTensor6View::operator()(v,s,b,p,r,c);
1196 }
1197 
1198 // |-|---
1199 ConstTensor4View Tensor6View::operator()
1200  ( Index v, const Range& s, Index b,
1201  const Range& p, const Range& r, const Range& c) const
1202 {
1203  return ConstTensor6View::operator()(v,s,b,p,r,c);
1204 }
1205 
1206 // ||----
1207 ConstTensor4View Tensor6View::operator()
1208  ( Index v, Index s, const Range& b,
1209  const Range& p, const Range& r, const Range& c) const
1210 {
1211  return ConstTensor6View::operator()(v,s,b,p,r,c);
1212 }
1213 
1214 
1215 // Result 3D (4+3+2+1+ 3+2+1+ 2+1 +1 = 20 combinations)
1216 // ---|||
1217 ConstTensor3View Tensor6View::operator()
1218  ( const Range& v, const Range& s, const Range& b,
1219  Index p, Index r, Index c) const
1220 {
1221  return ConstTensor6View::operator()(v,s,b,p,r,c);
1222 }
1223 
1224 // --|-||
1225 ConstTensor3View Tensor6View::operator()
1226  ( const Range& v, const Range& s, Index b,
1227  const Range& p, Index r, Index c) const
1228 {
1229  return ConstTensor6View::operator()(v,s,b,p,r,c);
1230 }
1231 
1232 // -|--||
1233 ConstTensor3View Tensor6View::operator()
1234  ( const Range& v, Index s, const Range& b,
1235  const Range& p, Index r, Index c) const
1236 {
1237  return ConstTensor6View::operator()(v,s,b,p,r,c);
1238 }
1239 
1240 // |---||
1241 ConstTensor3View Tensor6View::operator()
1242  ( Index v, const Range& s, const Range& b,
1243  const Range& p, Index r, Index c) const
1244 {
1245  return ConstTensor6View::operator()(v,s,b,p,r,c);
1246 }
1247 
1248 // --||-|
1249 ConstTensor3View Tensor6View::operator()
1250  ( const Range& v, const Range& s, Index b,
1251  Index p, const Range& r, Index c) const
1252 {
1253  return ConstTensor6View::operator()(v,s,b,p,r,c);
1254 }
1255 
1256 // -|-|-|
1257 ConstTensor3View Tensor6View::operator()
1258  ( const Range& v, Index s, const Range& b,
1259  Index p, const Range& r, Index c) const
1260 {
1261  return ConstTensor6View::operator()(v,s,b,p,r,c);
1262 }
1263 
1264 // |--|-|
1265 ConstTensor3View Tensor6View::operator()
1266  ( Index v, const Range& s, const Range& b,
1267  Index p, const Range& r, Index c) const
1268 {
1269  return ConstTensor6View::operator()(v,s,b,p,r,c);
1270 }
1271 
1272 // -||--|
1273 ConstTensor3View Tensor6View::operator()
1274  ( const Range& v, Index s, Index b,
1275  const Range& p, const Range& r, Index c) const
1276 {
1277  return ConstTensor6View::operator()(v,s,b,p,r,c);
1278 }
1279 
1280 // |-|--|
1281 ConstTensor3View Tensor6View::operator()
1282  ( Index v, const Range& s, Index b,
1283  const Range& p, const Range& r, Index c) const
1284 {
1285  return ConstTensor6View::operator()(v,s,b,p,r,c);
1286 }
1287 
1288 // ||---|
1289 ConstTensor3View Tensor6View::operator()
1290  ( Index v, Index s, const Range& b,
1291  const Range& p, const Range& r, Index c) const
1292 {
1293  return ConstTensor6View::operator()(v,s,b,p,r,c);
1294 }
1295 
1296 // --|||-
1297 ConstTensor3View Tensor6View::operator()
1298  ( const Range& v, const Range& s, Index b,
1299  Index p, Index r, const Range& c) const
1300 {
1301  return ConstTensor6View::operator()(v,s,b,p,r,c);
1302 }
1303 
1304 // -|-||-
1305 ConstTensor3View Tensor6View::operator()
1306  ( const Range& v, Index s, const Range& b,
1307  Index p, Index r, const Range& c) const
1308 {
1309  return ConstTensor6View::operator()(v,s,b,p,r,c);
1310 }
1311 
1312 // |--||-
1313 ConstTensor3View Tensor6View::operator()
1314  ( Index v, const Range& s, const Range& b,
1315  Index p, Index r, const Range& c) const
1316 {
1317  return ConstTensor6View::operator()(v,s,b,p,r,c);
1318 }
1319 
1320 // -||-|-
1321 ConstTensor3View Tensor6View::operator()
1322  ( const Range& v, Index s, Index b,
1323  const Range& p, Index r, const Range& c) const
1324 {
1325  return ConstTensor6View::operator()(v,s,b,p,r,c);
1326 }
1327 
1328 // |-|-|-
1329 ConstTensor3View Tensor6View::operator()
1330  ( Index v, const Range& s, Index b,
1331  const Range& p, Index r, const Range& c) const
1332 {
1333  return ConstTensor6View::operator()(v,s,b,p,r,c);
1334 }
1335 
1336 // ||--|-
1337 ConstTensor3View Tensor6View::operator()
1338  ( Index v, Index s, const Range& b,
1339  const Range& p, Index r, const Range& c) const
1340 {
1341  return ConstTensor6View::operator()(v,s,b,p,r,c);
1342 }
1343 
1344 // -|||--
1345 ConstTensor3View Tensor6View::operator()
1346  ( const Range& v, Index s, Index b,
1347  Index p, const Range& r, const Range& c) const
1348 {
1349  return ConstTensor6View::operator()(v,s,b,p,r,c);
1350 }
1351 
1352 // |-||--
1353 ConstTensor3View Tensor6View::operator()
1354  ( Index v, const Range& s, Index b,
1355  Index p, const Range& r, const Range& c) const
1356 {
1357  return ConstTensor6View::operator()(v,s,b,p,r,c);
1358 }
1359 
1360 // ||-|--
1361 ConstTensor3View Tensor6View::operator()
1362  ( Index v, Index s, const Range& b,
1363  Index p, const Range& r, const Range& c) const
1364 {
1365  return ConstTensor6View::operator()(v,s,b,p,r,c);
1366 }
1367 
1368 // |||---
1369 ConstTensor3View Tensor6View::operator()
1370  ( Index v, Index s, Index b,
1371  const Range& p, const Range& r, const Range& c) const
1372 {
1373  return ConstTensor6View::operator()(v,s,b,p,r,c);
1374 }
1375 
1376 
1377 // Result 2D (15 combinations)
1378 // IIII--
1379 ConstMatrixView Tensor6View::operator()
1380  ( Index v, Index s, Index b,
1381  Index p, const Range& r, const Range& c) const
1382 {
1383  return ConstTensor6View::operator()(v,s,b,p,r,c);
1384 }
1385 
1386 // III-I-
1387 ConstMatrixView Tensor6View::operator()
1388  ( Index v, Index s, Index b,
1389  const Range& p, Index r, const Range& c) const
1390 {
1391  return ConstTensor6View::operator()(v,s,b,p,r,c);
1392 }
1393 
1394 // II-II-
1395 ConstMatrixView Tensor6View::operator()
1396  ( Index v, Index s, const Range& b,
1397  Index p, Index r, const Range& c) const
1398 {
1399  return ConstTensor6View::operator()(v,s,b,p,r,c);
1400 }
1401 
1402 // I-III-
1403 ConstMatrixView Tensor6View::operator()
1404  ( Index v, const Range& s, Index b,
1405  Index p, Index r, const Range& c) const
1406 {
1407  return ConstTensor6View::operator()(v,s,b,p,r,c);
1408 }
1409 
1410 // -IIII-
1411 ConstMatrixView Tensor6View::operator()
1412  ( const Range& v, Index s, Index b,
1413  Index p, Index r, const Range& c) const
1414 {
1415  return ConstTensor6View::operator()(v,s,b,p,r,c);
1416 }
1417 
1418 // III--I
1419 ConstMatrixView Tensor6View::operator()
1420  ( Index v, Index s, Index b,
1421  const Range& p, const Range& r, Index c) const
1422 {
1423  return ConstTensor6View::operator()(v,s,b,p,r,c);
1424 }
1425 
1426 // II-I-I
1427 ConstMatrixView Tensor6View::operator()
1428  ( Index v, Index s, const Range& b,
1429  Index p, const Range& r, Index c) const
1430 {
1431  return ConstTensor6View::operator()(v,s,b,p,r,c);
1432 }
1433 
1434 // I-II-I
1435 ConstMatrixView Tensor6View::operator()
1436  ( Index v, const Range& s, Index b,
1437  Index p, const Range& r, Index c) const
1438 {
1439  return ConstTensor6View::operator()(v,s,b,p,r,c);
1440 }
1441 
1442 // -III-I
1443 ConstMatrixView Tensor6View::operator()
1444  ( const Range& v, Index s, Index b,
1445  Index p, const Range& r, Index c) const
1446 {
1447  return ConstTensor6View::operator()(v,s,b,p,r,c);
1448 }
1449 
1450 // II--II
1451 ConstMatrixView Tensor6View::operator()
1452  ( Index v, Index s, const Range& b,
1453  const Range& p, Index r, Index c) const
1454 {
1455  return ConstTensor6View::operator()(v,s,b,p,r,c);
1456 }
1457 
1458 // I-I-II
1459 ConstMatrixView Tensor6View::operator()
1460  ( Index v, const Range& s, Index b,
1461  const Range& p, Index r, Index c) const
1462 {
1463  return ConstTensor6View::operator()(v,s,b,p,r,c);
1464 }
1465 
1466 // -II-II
1467 ConstMatrixView Tensor6View::operator()
1468  ( const Range& v, Index s, Index b,
1469  const Range& p, Index r, Index c) const
1470 {
1471  return ConstTensor6View::operator()(v,s,b,p,r,c);
1472 }
1473 
1474 // I--III
1475 ConstMatrixView Tensor6View::operator()
1476  ( Index v, const Range& s, const Range& b,
1477  Index p, Index r, Index c) const
1478 {
1479  return ConstTensor6View::operator()(v,s,b,p,r,c);
1480 }
1481 
1482 // -I-III
1483 ConstMatrixView Tensor6View::operator()
1484  ( const Range& v, Index s, const Range& b,
1485  Index p, Index r, Index c) const
1486 {
1487  return ConstTensor6View::operator()(v,s,b,p,r,c);
1488 }
1489 
1490 // --IIII
1491 ConstMatrixView Tensor6View::operator()
1492  ( const Range& v, const Range& s, Index b,
1493  Index p, Index r, Index c) const
1494 {
1495  return ConstTensor6View::operator()(v,s,b,p,r,c);
1496 }
1497 
1498 
1499 // Result 1D (6 combinations)
1500 // IIIII-
1501 ConstVectorView Tensor6View::operator()
1502  ( Index v, Index s, Index b,
1503  Index p, Index r, const Range& c) const
1504 {
1505  return ConstTensor6View::operator()(v,s,b,p,r,c);
1506 }
1507 
1508 // IIII-I
1509 ConstVectorView Tensor6View::operator()
1510  ( Index v, Index s, Index b,
1511  Index p, const Range& r, Index c) const
1512 {
1513  return ConstTensor6View::operator()(v,s,b,p,r,c);
1514 }
1515 
1516 // III-II
1517 ConstVectorView Tensor6View::operator()
1518  ( Index v, Index s, Index b,
1519  const Range& p, Index r, Index c) const
1520 {
1521  return ConstTensor6View::operator()(v,s,b,p,r,c);
1522 }
1523 
1524 // II-III
1525 ConstVectorView Tensor6View::operator()
1526  ( Index v, Index s, const Range& b,
1527  Index p, Index r, Index c) const
1528 {
1529  return ConstTensor6View::operator()(v,s,b,p,r,c);
1530 }
1531 
1532 // I-IIII
1533 ConstVectorView Tensor6View::operator()
1534  ( Index v, const Range& s, Index b,
1535  Index p, Index r, Index c) const
1536 {
1537  return ConstTensor6View::operator()(v,s,b,p,r,c);
1538 }
1539 
1540 // -IIIII
1541 ConstVectorView Tensor6View::operator()
1542  ( const Range& v, Index s, Index b,
1543  Index p, Index r, Index c) const
1544 {
1545  return ConstTensor6View::operator()(v,s,b,p,r,c);
1546 }
1547 
1548 
1549 
1550 // Non-const index operators:
1551 
1552 // Result 6D (1 combination)
1553 // ------
1554 Tensor6View Tensor6View::operator()
1555  ( const Range& v, const Range& s, const Range& b,
1556  const Range& p, const Range& r, const Range& c)
1557 {
1558  return Tensor6View(mdata,
1559  mvr, msr, mbr, mpr, mrr, mcr,
1560  v, s, b, p, r, c);
1561 }
1562 
1563 
1564 // Result 5D (6 combinations)
1565 // -----|
1566 Tensor5View Tensor6View::operator()
1567  ( const Range& v, const Range& s, const Range& b,
1568  const Range& p, const Range& r, Index c)
1569 {
1570  CHECK(c);
1571  return Tensor5View(mdata + OFFSET(c),
1572  mvr, msr, mbr, mpr, mrr,
1573  v, s, b, p, r);
1574 }
1575 
1576 // ----|-
1577 Tensor5View Tensor6View::operator()
1578  ( const Range& v, const Range& s, const Range& b,
1579  const Range& p, Index r, const Range& c)
1580 {
1581  CHECK(r);
1582  return Tensor5View(mdata + OFFSET(r),
1583  mvr, msr, mbr, mpr, mcr,
1584  v, s, b, p, c);
1585 }
1586 
1587 // ---|--
1588 Tensor5View Tensor6View::operator()
1589  ( const Range& v, const Range& s, const Range& b,
1590  Index p, const Range& r, const Range& c)
1591 {
1592  CHECK(p);
1593  return Tensor5View(mdata + OFFSET(p),
1594  mvr, msr, mbr, mrr, mcr,
1595  v, s, b, r, c);
1596 }
1597 
1598 // --|---
1599 Tensor5View Tensor6View::operator()
1600  ( const Range& v, const Range& s, Index b,
1601  const Range& p, const Range& r, const Range& c)
1602 {
1603  CHECK(b);
1604  return Tensor5View(mdata + OFFSET(b),
1605  mvr, msr, mpr, mrr, mcr,
1606  v, s, p, r, c);
1607 }
1608 
1609 // -|----
1610 Tensor5View Tensor6View::operator()
1611  ( const Range& v, Index s, const Range& b,
1612  const Range& p, const Range& r, const Range& c)
1613 {
1614  CHECK(s);
1615  return Tensor5View(mdata + OFFSET(s),
1616  mvr, mbr, mpr, mrr, mcr,
1617  v, b, p, r, c);
1618 }
1619 
1620 // |-----
1621 Tensor5View Tensor6View::operator()
1622  ( Index v, const Range& s, const Range& b,
1623  const Range& p, const Range& r, const Range& c)
1624 {
1625  CHECK(v);
1626  return Tensor5View(mdata + OFFSET(v),
1627  msr, mbr, mpr, mrr, mcr,
1628  s, b, p, r, c);
1629 }
1630 
1631 
1632 // Result 4D (5+4+3+2+1 = 15 combinations)
1633 // ----||
1634 Tensor4View Tensor6View::operator()
1635  ( const Range& v, const Range& s, const Range& b,
1636  const Range& p, Index r, Index c)
1637 {
1638  CHECK(r);
1639  CHECK(c);
1640  return Tensor4View(mdata + OFFSET(r) + OFFSET(c),
1641  mvr, msr, mbr, mpr,
1642  v, s, b, p );
1643 }
1644 
1645 // ---|-|
1646 Tensor4View Tensor6View::operator()
1647  ( const Range& v, const Range& s, const Range& b,
1648  Index p, const Range& r, Index c)
1649 {
1650  CHECK(p);
1651  CHECK(c);
1652  return Tensor4View(mdata + OFFSET(p) + OFFSET(c),
1653  mvr, msr, mbr, mrr,
1654  v, s, b, r );
1655 }
1656 
1657 // --|--|
1658 Tensor4View Tensor6View::operator()
1659  ( const Range& v, const Range& s, Index b,
1660  const Range& p, const Range& r, Index c)
1661 {
1662  CHECK(b);
1663  CHECK(c);
1664  return Tensor4View(mdata + OFFSET(b) + OFFSET(c),
1665  mvr, msr, mpr, mrr,
1666  v, s, p, r );
1667 }
1668 
1669 // -|---|
1670 Tensor4View Tensor6View::operator()
1671  ( const Range& v, Index s, const Range& b,
1672  const Range& p, const Range& r, Index c)
1673 {
1674  CHECK(s);
1675  CHECK(c);
1676  return Tensor4View(mdata + OFFSET(s) + OFFSET(c),
1677  mvr, mbr, mpr, mrr,
1678  v, b, p, r );
1679 }
1680 
1681 // |----|
1682 Tensor4View Tensor6View::operator()
1683  ( Index v, const Range& s, const Range& b,
1684  const Range& p, const Range& r, Index c)
1685 {
1686  CHECK(v);
1687  CHECK(c);
1688  return Tensor4View(mdata + OFFSET(v) + OFFSET(c),
1689  msr, mbr, mpr, mrr,
1690  s, b, p, r );
1691 }
1692 
1693 // ---||-
1694 Tensor4View Tensor6View::operator()
1695  ( const Range& v, const Range& s, const Range& b,
1696  Index p, Index r, const Range& c)
1697 {
1698  CHECK(p);
1699  CHECK(r);
1700  return Tensor4View(mdata + OFFSET(p) + OFFSET(r),
1701  mvr, msr, mbr, mcr,
1702  v, s, b, c );
1703 }
1704 
1705 // --|-|-
1706 Tensor4View Tensor6View::operator()
1707  ( const Range& v, const Range& s, Index b,
1708  const Range& p, Index r, const Range& c)
1709 {
1710  CHECK(b);
1711  CHECK(r);
1712  return Tensor4View(mdata + OFFSET(b) + OFFSET(r),
1713  mvr, msr, mpr, mcr,
1714  v, s, p, c );
1715 }
1716 
1717 // -|--|-
1718 Tensor4View Tensor6View::operator()
1719  ( const Range& v, Index s, const Range& b,
1720  const Range& p, Index r, const Range& c)
1721 {
1722  CHECK(s);
1723  CHECK(r);
1724  return Tensor4View(mdata + OFFSET(s) + OFFSET(r),
1725  mvr, mbr, mpr, mcr,
1726  v, b, p, c );
1727 }
1728 
1729 // |---|-
1730 Tensor4View Tensor6View::operator()
1731  ( Index v, const Range& s, const Range& b,
1732  const Range& p, Index r, const Range& c)
1733 {
1734  CHECK(v);
1735  CHECK(r);
1736  return Tensor4View(mdata + OFFSET(v) + OFFSET(r),
1737  msr, mbr, mpr, mcr,
1738  s, b, p, c );
1739 }
1740 
1741 // --||--
1742 Tensor4View Tensor6View::operator()
1743  ( const Range& v, const Range& s, Index b,
1744  Index p, const Range& r, const Range& c)
1745 {
1746  CHECK(b);
1747  CHECK(p);
1748  return Tensor4View(mdata + OFFSET(b) + OFFSET(p),
1749  mvr, msr, mrr, mcr,
1750  v, s, r, c );
1751 }
1752 
1753 // -|-|--
1754 Tensor4View Tensor6View::operator()
1755  ( const Range& v, Index s, const Range& b,
1756  Index p, const Range& r, const Range& c)
1757 {
1758  CHECK(s);
1759  CHECK(p);
1760  return Tensor4View(mdata + OFFSET(s) + OFFSET(p),
1761  mvr, mbr, mrr, mcr,
1762  v, b, r, c );
1763 }
1764 
1765 // |--|--
1766 Tensor4View Tensor6View::operator()
1767  ( Index v, const Range& s, const Range& b,
1768  Index p, const Range& r, const Range& c)
1769 {
1770  CHECK(v);
1771  CHECK(p);
1772  return Tensor4View(mdata + OFFSET(v) + OFFSET(p),
1773  msr, mbr, mrr, mcr,
1774  s, b, r, c );
1775 }
1776 
1777 // -||---
1778 Tensor4View Tensor6View::operator()
1779  ( const Range& v, Index s, Index b,
1780  const Range& p, const Range& r, const Range& c)
1781 {
1782  CHECK(s);
1783  CHECK(b);
1784  return Tensor4View(mdata + OFFSET(s) + OFFSET(b),
1785  mvr, mpr, mrr, mcr,
1786  v, p, r, c );
1787 }
1788 
1789 // |-|---
1790 Tensor4View Tensor6View::operator()
1791  ( Index v, const Range& s, Index b,
1792  const Range& p, const Range& r, const Range& c)
1793 {
1794  CHECK(v);
1795  CHECK(b);
1796  return Tensor4View(mdata + OFFSET(v) + OFFSET(b),
1797  msr, mpr, mrr, mcr,
1798  s, p, r, c );
1799 }
1800 
1801 // ||----
1802 Tensor4View Tensor6View::operator()
1803  ( Index v, Index s, const Range& b,
1804  const Range& p, const Range& r, const Range& c)
1805 {
1806  CHECK(v);
1807  CHECK(s);
1808  return Tensor4View(mdata + OFFSET(v) + OFFSET(s),
1809  mbr, mpr, mrr, mcr,
1810  b, p, r, c );
1811 }
1812 
1813 
1814 // Result 3D (4+3+2+1+ 3+2+1+ 2+1 +1 = 20 combinations)
1815 // ---|||
1816 Tensor3View Tensor6View::operator()
1817  ( const Range& v, const Range& s, const Range& b,
1818  Index p, Index r, Index c)
1819 {
1820  CHECK(p);
1821  CHECK(r);
1822  CHECK(c);
1823  return Tensor3View(mdata + OFFSET(p) + OFFSET(r) + OFFSET(c),
1824  mvr, msr, mbr,
1825  v, s, b );
1826 }
1827 
1828 // --|-||
1829 Tensor3View Tensor6View::operator()
1830  ( const Range& v, const Range& s, Index b,
1831  const Range& p, Index r, Index c)
1832 {
1833  CHECK(b);
1834  CHECK(r);
1835  CHECK(c);
1836  return Tensor3View(mdata + OFFSET(b) + OFFSET(r) + OFFSET(c),
1837  mvr, msr, mpr,
1838  v, s, p );
1839 }
1840 
1841 // -|--||
1842 Tensor3View Tensor6View::operator()
1843  ( const Range& v, Index s, const Range& b,
1844  const Range& p, Index r, Index c)
1845 {
1846  CHECK(s);
1847  CHECK(r);
1848  CHECK(c);
1849  return Tensor3View(mdata + OFFSET(s) + OFFSET(r) + OFFSET(c),
1850  mvr, mbr, mpr,
1851  v, b, p );
1852 }
1853 
1854 // |---||
1855 Tensor3View Tensor6View::operator()
1856  ( Index v, const Range& s, const Range& b,
1857  const Range& p, Index r, Index c)
1858 {
1859  CHECK(v);
1860  CHECK(r);
1861  CHECK(c);
1862  return Tensor3View(mdata + OFFSET(v) + OFFSET(r) + OFFSET(c),
1863  msr, mbr, mpr,
1864  s, b, p );
1865 }
1866 
1867 // --||-|
1868 Tensor3View Tensor6View::operator()
1869  ( const Range& v, const Range& s, Index b,
1870  Index p, const Range& r, Index c)
1871 {
1872  CHECK(b);
1873  CHECK(p);
1874  CHECK(c);
1875  return Tensor3View(mdata + OFFSET(b) + OFFSET(p) + OFFSET(c),
1876  mvr, msr, mrr,
1877  v, s, r );
1878 }
1879 
1880 // -|-|-|
1881 Tensor3View Tensor6View::operator()
1882  ( const Range& v, Index s, const Range& b,
1883  Index p, const Range& r, Index c)
1884 {
1885  CHECK(s);
1886  CHECK(p);
1887  CHECK(c);
1888  return Tensor3View(mdata + OFFSET(s) + OFFSET(p) + OFFSET(c),
1889  mvr, mbr, mrr,
1890  v, b, r );
1891 }
1892 
1893 // |--|-|
1894 Tensor3View Tensor6View::operator()
1895  ( Index v, const Range& s, const Range& b,
1896  Index p, const Range& r, Index c)
1897 {
1898  CHECK(v);
1899  CHECK(p);
1900  CHECK(c);
1901  return Tensor3View(mdata + OFFSET(v) + OFFSET(p) + OFFSET(c),
1902  msr, mbr, mrr,
1903  s, b, r );
1904 }
1905 
1906 // -||--|
1907 Tensor3View Tensor6View::operator()
1908  ( const Range& v, Index s, Index b,
1909  const Range& p, const Range& r, Index c)
1910 {
1911  CHECK(s);
1912  CHECK(b);
1913  CHECK(c);
1914  return Tensor3View(mdata + OFFSET(s) + OFFSET(b) + OFFSET(c),
1915  mvr, mpr, mrr,
1916  v, p, r );
1917 }
1918 
1919 // |-|--|
1920 Tensor3View Tensor6View::operator()
1921  ( Index v, const Range& s, Index b,
1922  const Range& p, const Range& r, Index c)
1923 {
1924  CHECK(v);
1925  CHECK(b);
1926  CHECK(c);
1927  return Tensor3View(mdata + OFFSET(v) + OFFSET(b) + OFFSET(c),
1928  msr, mpr, mrr,
1929  s, p, r );
1930 }
1931 
1932 // ||---|
1933 Tensor3View Tensor6View::operator()
1934  ( Index v, Index s, const Range& b,
1935  const Range& p, const Range& r, Index c)
1936 {
1937  CHECK(v);
1938  CHECK(s);
1939  CHECK(c);
1940  return Tensor3View(mdata + OFFSET(v) + OFFSET(s) + OFFSET(c),
1941  mbr, mpr, mrr,
1942  b, p, r );
1943 }
1944 
1945 // --|||-
1946 Tensor3View Tensor6View::operator()
1947  ( const Range& v, const Range& s, Index b,
1948  Index p, Index r, const Range& c)
1949 {
1950  CHECK(b);
1951  CHECK(p);
1952  CHECK(r);
1953  return Tensor3View(mdata + OFFSET(b) + OFFSET(p) + OFFSET(r),
1954  mvr, msr, mcr,
1955  v, s, c );
1956 }
1957 
1958 // -|-||-
1959 Tensor3View Tensor6View::operator()
1960  ( const Range& v, Index s, const Range& b,
1961  Index p, Index r, const Range& c)
1962 {
1963  CHECK(s);
1964  CHECK(p);
1965  CHECK(r);
1966  return Tensor3View(mdata + OFFSET(s) + OFFSET(p) + OFFSET(r),
1967  mvr, mbr, mcr,
1968  v, b, c );
1969 }
1970 
1971 // |--||-
1972 Tensor3View Tensor6View::operator()
1973  ( Index v, const Range& s, const Range& b,
1974  Index p, Index r, const Range& c)
1975 {
1976  CHECK(v);
1977  CHECK(p);
1978  CHECK(r);
1979  return Tensor3View(mdata + OFFSET(v) + OFFSET(p) + OFFSET(r),
1980  msr, mbr, mcr,
1981  s, b, c );
1982 }
1983 
1984 // -||-|-
1985 Tensor3View Tensor6View::operator()
1986  ( const Range& v, Index s, Index b,
1987  const Range& p, Index r, const Range& c)
1988 {
1989  CHECK(s);
1990  CHECK(b);
1991  CHECK(r);
1992  return Tensor3View(mdata + OFFSET(s) + OFFSET(b) + OFFSET(r),
1993  mvr, mpr, mcr,
1994  v, p, c );
1995 }
1996 
1997 // |-|-|-
1998 Tensor3View Tensor6View::operator()
1999  ( Index v, const Range& s, Index b,
2000  const Range& p, Index r, const Range& c)
2001 {
2002  CHECK(v);
2003  CHECK(b);
2004  CHECK(r);
2005  return Tensor3View(mdata + OFFSET(v) + OFFSET(b) + OFFSET(r),
2006  msr, mpr, mcr,
2007  s, p, c );
2008 }
2009 
2010 // ||--|-
2011 Tensor3View Tensor6View::operator()
2012  ( Index v, Index s, const Range& b,
2013  const Range& p, Index r, const Range& c)
2014 {
2015  CHECK(v);
2016  CHECK(s);
2017  CHECK(r);
2018  return Tensor3View(mdata + OFFSET(v) + OFFSET(s) + OFFSET(r),
2019  mbr, mpr, mcr,
2020  b, p, c );
2021 }
2022 
2023 // -|||--
2024 Tensor3View Tensor6View::operator()
2025  ( const Range& v, Index s, Index b,
2026  Index p, const Range& r, const Range& c)
2027 {
2028  CHECK(s);
2029  CHECK(b);
2030  CHECK(p);
2031  return Tensor3View(mdata + OFFSET(s) + OFFSET(b) + OFFSET(p),
2032  mvr, mrr, mcr,
2033  v, r, c );
2034 }
2035 
2036 // |-||--
2037 Tensor3View Tensor6View::operator()
2038  ( Index v, const Range& s, Index b,
2039  Index p, const Range& r, const Range& c)
2040 {
2041  CHECK(v);
2042  CHECK(b);
2043  CHECK(p);
2044  return Tensor3View(mdata + OFFSET(v) + OFFSET(b) + OFFSET(p),
2045  msr, mrr, mcr,
2046  s, r, c );
2047 }
2048 
2049 // ||-|--
2050 Tensor3View Tensor6View::operator()
2051  ( Index v, Index s, const Range& b,
2052  Index p, const Range& r, const Range& c)
2053 {
2054  CHECK(v);
2055  CHECK(s);
2056  CHECK(p);
2057  return Tensor3View(mdata + OFFSET(v) + OFFSET(s) + OFFSET(p),
2058  mbr, mrr, mcr,
2059  b, r, c );
2060 }
2061 
2062 // |||---
2063 Tensor3View Tensor6View::operator()
2064  ( Index v, Index s, Index b,
2065  const Range& p, const Range& r, const Range& c)
2066 {
2067  CHECK(v);
2068  CHECK(s);
2069  CHECK(b);
2070  return Tensor3View(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b),
2071  mpr, mrr, mcr,
2072  p, r, c );
2073 }
2074 
2075 
2076 // Result 2D (15 combinations)
2077 // IIII--
2078 MatrixView Tensor6View::operator()
2079  ( Index v, Index s, Index b,
2080  Index p, const Range& r, const Range& c)
2081 {
2082  CHECK(v);
2083  CHECK(s);
2084  CHECK(b);
2085  CHECK(p);
2086  return MatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(p),
2087  mrr, mcr,
2088  r, c );
2089 }
2090 
2091 // III-I-
2092 MatrixView Tensor6View::operator()
2093  ( Index v, Index s, Index b,
2094  const Range& p, Index r, const Range& c)
2095 {
2096  CHECK(v);
2097  CHECK(s);
2098  CHECK(b);
2099  CHECK(r);
2100  return MatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(r),
2101  mpr, mcr,
2102  p, c );
2103 }
2104 
2105 // II-II-
2106 MatrixView Tensor6View::operator()
2107  ( Index v, Index s, const Range& b,
2108  Index p, Index r, const Range& c)
2109 {
2110  CHECK(v);
2111  CHECK(s);
2112  CHECK(p);
2113  CHECK(r);
2114  return MatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(p) + OFFSET(r),
2115  mbr, mcr,
2116  b, c );
2117 }
2118 
2119 // I-III-
2120 MatrixView Tensor6View::operator()
2121  ( Index v, const Range& s, Index b,
2122  Index p, Index r, const Range& c)
2123 {
2124  CHECK(v);
2125  CHECK(b);
2126  CHECK(p);
2127  CHECK(r);
2128  return MatrixView(mdata + OFFSET(v) + OFFSET(b) + OFFSET(p) + OFFSET(r),
2129  msr, mcr,
2130  s, c );
2131 }
2132 
2133 // -IIII-
2134 MatrixView Tensor6View::operator()
2135  ( const Range& v, Index s, Index b,
2136  Index p, Index r, const Range& c)
2137 {
2138  CHECK(s);
2139  CHECK(b);
2140  CHECK(p);
2141  CHECK(r);
2142  return MatrixView(mdata + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(r),
2143  mvr, mcr,
2144  v, c );
2145 }
2146 
2147 // III--I
2148 MatrixView Tensor6View::operator()
2149  ( Index v, Index s, Index b,
2150  const Range& p, const Range& r, Index c)
2151 {
2152  CHECK(v);
2153  CHECK(s);
2154  CHECK(b);
2155  CHECK(c);
2156  return MatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(c),
2157  mpr, mrr,
2158  p, r );
2159 }
2160 
2161 // II-I-I
2162 MatrixView Tensor6View::operator()
2163  ( Index v, Index s, const Range& b,
2164  Index p, const Range& r, Index c)
2165 {
2166  CHECK(v);
2167  CHECK(s);
2168  CHECK(p);
2169  CHECK(c);
2170  return MatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(p) + OFFSET(c),
2171  mbr, mrr,
2172  b, r );
2173 }
2174 
2175 // I-II-I
2176 MatrixView Tensor6View::operator()
2177  ( Index v, const Range& s, Index b,
2178  Index p, const Range& r, Index c)
2179 {
2180  CHECK(v);
2181  CHECK(b);
2182  CHECK(p);
2183  CHECK(c);
2184  return MatrixView(mdata + OFFSET(v) + OFFSET(b) + OFFSET(p) + OFFSET(c),
2185  msr, mrr,
2186  s, r );
2187 }
2188 
2189 // -III-I
2190 MatrixView Tensor6View::operator()
2191  ( const Range& v, Index s, Index b,
2192  Index p, const Range& r, Index c)
2193 {
2194  CHECK(s);
2195  CHECK(b);
2196  CHECK(p);
2197  CHECK(c);
2198  return MatrixView(mdata + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(c),
2199  mvr, mrr,
2200  v, r );
2201 }
2202 
2203 // II--II
2204 MatrixView Tensor6View::operator()
2205  ( Index v, Index s, const Range& b,
2206  const Range& p, Index r, Index c)
2207 {
2208  CHECK(v);
2209  CHECK(s);
2210  CHECK(r);
2211  CHECK(c);
2212  return MatrixView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(r) + OFFSET(c),
2213  mbr, mpr,
2214  b, p );
2215 }
2216 
2217 // I-I-II
2218 MatrixView Tensor6View::operator()
2219  ( Index v, const Range& s, Index b,
2220  const Range& p, Index r, Index c)
2221 {
2222  CHECK(v);
2223  CHECK(b);
2224  CHECK(r);
2225  CHECK(c);
2226  return MatrixView(mdata + OFFSET(v) + OFFSET(b) + OFFSET(r) + OFFSET(c),
2227  msr, mpr,
2228  s, p );
2229 }
2230 
2231 // -II-II
2232 MatrixView Tensor6View::operator()
2233  ( const Range& v, Index s, Index b,
2234  const Range& p, Index r, Index c)
2235 {
2236  CHECK(s);
2237  CHECK(b);
2238  CHECK(r);
2239  CHECK(c);
2240  return MatrixView(mdata + OFFSET(s) + OFFSET(b) + OFFSET(r) + OFFSET(c),
2241  mvr, mpr,
2242  v, p );
2243 }
2244 
2245 // I--III
2246 MatrixView Tensor6View::operator()
2247  ( Index v, const Range& s, const Range& b,
2248  Index p, Index r, Index c)
2249 {
2250  CHECK(v);
2251  CHECK(p);
2252  CHECK(r);
2253  CHECK(c);
2254  return MatrixView(mdata + OFFSET(v) + OFFSET(p) + OFFSET(r) + OFFSET(c),
2255  msr, mbr,
2256  s, b );
2257 }
2258 
2259 // -I-III
2260 MatrixView Tensor6View::operator()
2261  ( const Range& v, Index s, const Range& b,
2262  Index p, Index r, Index c)
2263 {
2264  CHECK(s);
2265  CHECK(p);
2266  CHECK(r);
2267  CHECK(c);
2268  return MatrixView(mdata + OFFSET(s) + OFFSET(p) + OFFSET(r) + OFFSET(c),
2269  mvr, mbr,
2270  v, b );
2271 }
2272 
2273 // --IIII
2274 MatrixView Tensor6View::operator()
2275  ( const Range& v, const Range& s, Index b,
2276  Index p, Index r, Index c)
2277 {
2278  CHECK(b);
2279  CHECK(p);
2280  CHECK(r);
2281  CHECK(c);
2282  return MatrixView(mdata + OFFSET(b) + OFFSET(p) + OFFSET(r) + OFFSET(c),
2283  mvr, msr,
2284  v, s );
2285 }
2286 
2287 
2288 // Result 1D (6 combinations)
2289 // IIIII-
2290 VectorView Tensor6View::operator()
2291  ( Index v, Index s, Index b,
2292  Index p, Index r, const Range& c)
2293 {
2294  CHECK(v);
2295  CHECK(s);
2296  CHECK(b);
2297  CHECK(p);
2298  CHECK(r);
2299  return VectorView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(r),
2300  mcr,
2301  c );
2302 }
2303 
2304 // IIII-I
2305 VectorView Tensor6View::operator()
2306  ( Index v, Index s, Index b,
2307  Index p, const Range& r, Index c)
2308 {
2309  CHECK(v);
2310  CHECK(s);
2311  CHECK(b);
2312  CHECK(p);
2313  CHECK(c);
2314  return VectorView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(c),
2315  mrr,
2316  r );
2317 }
2318 
2319 // III-II
2320 VectorView Tensor6View::operator()
2321  ( Index v, Index s, Index b,
2322  const Range& p, Index r, Index c)
2323 {
2324  CHECK(v);
2325  CHECK(s);
2326  CHECK(b);
2327  CHECK(r);
2328  CHECK(c);
2329  return VectorView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(b) + OFFSET(r) + OFFSET(c),
2330  mpr,
2331  p );
2332 }
2333 
2334 // II-III
2335 VectorView Tensor6View::operator()
2336  ( Index v, Index s, const Range& b,
2337  Index p, Index r, Index c)
2338 {
2339  CHECK(v);
2340  CHECK(s);
2341  CHECK(p);
2342  CHECK(r);
2343  CHECK(c);
2344  return VectorView(mdata + OFFSET(v) + OFFSET(s) + OFFSET(p) + OFFSET(r) + OFFSET(c),
2345  mbr,
2346  b );
2347 }
2348 
2349 // I-IIII
2350 VectorView Tensor6View::operator()
2351  ( Index v, const Range& s, Index b,
2352  Index p, Index r, Index c)
2353 {
2354  CHECK(v);
2355  CHECK(b);
2356  CHECK(p);
2357  CHECK(r);
2358  CHECK(c);
2359  return VectorView(mdata + OFFSET(v) + OFFSET(b) + OFFSET(p) + OFFSET(r) + OFFSET(c),
2360  msr,
2361  s );
2362 }
2363 
2364 // -IIIII
2365 VectorView Tensor6View::operator()
2366  ( const Range& v, Index s, Index b,
2367  Index p, Index r, Index c)
2368 {
2369  CHECK(s);
2370  CHECK(b);
2371  CHECK(p);
2372  CHECK(r);
2373  CHECK(c);
2374  return VectorView(mdata + OFFSET(s) + OFFSET(b) + OFFSET(p) + OFFSET(r) + OFFSET(c),
2375  mvr,
2376  v );
2377 }
2378 
2379 
2380 
2381 
2384 ConstIterator6D Tensor6View::begin() const
2385 {
2386  return ConstTensor6View::begin();
2387 }
2388 
2390 ConstIterator6D Tensor6View::end() const
2391 {
2392  return ConstTensor6View::end();
2393 }
2394 
2396 Iterator6D Tensor6View::begin()
2397 {
2398  return Iterator6D( Tensor5View(mdata+mvr.mstart,
2399  msr,
2400  mbr,
2401  mpr,
2402  mrr,
2403  mcr),
2404  mvr.mstride);
2405 }
2406 
2408 Iterator6D Tensor6View::end()
2409 {
2410  return Iterator6D( Tensor5View(mdata + mvr.mstart +
2411  (mvr.mextent)*mvr.mstride,
2412  msr,
2413  mbr,
2414  mpr,
2415  mrr,
2416  mcr),
2417  mvr.mstride );
2418 }
2419 
2424 Tensor6View& Tensor6View::operator=(const ConstTensor6View& m)
2425 {
2426  // Check that sizes are compatible:
2427  assert(mvr.mextent==m.mvr.mextent);
2428  assert(msr.mextent==m.msr.mextent);
2429  assert(mbr.mextent==m.mbr.mextent);
2430  assert(mpr.mextent==m.mpr.mextent);
2431  assert(mrr.mextent==m.mrr.mextent);
2432  assert(mcr.mextent==m.mcr.mextent);
2433 
2434  copy( m.begin(), m.end(), begin() );
2435  return *this;
2436 }
2437 
2443 Tensor6View& Tensor6View::operator=(const Tensor6View& m)
2444 {
2445  // Check that sizes are compatible:
2446  assert(mvr.mextent==m.mvr.mextent);
2447  assert(msr.mextent==m.msr.mextent);
2448  assert(mbr.mextent==m.mbr.mextent);
2449  assert(mpr.mextent==m.mpr.mextent);
2450  assert(mrr.mextent==m.mrr.mextent);
2451  assert(mcr.mextent==m.mcr.mextent);
2452 
2453  copy( m.begin(), m.end(), begin() );
2454  return *this;
2455 }
2456 
2460 Tensor6View& Tensor6View::operator=(const Tensor6& m)
2461 {
2462  // Check that sizes are compatible:
2463  assert(mvr.mextent==m.mvr.mextent);
2464  assert(msr.mextent==m.msr.mextent);
2465  assert(mbr.mextent==m.mbr.mextent);
2466  assert(mpr.mextent==m.mpr.mextent);
2467  assert(mrr.mextent==m.mrr.mextent);
2468  assert(mcr.mextent==m.mcr.mextent);
2469 
2470  copy( m.begin(), m.end(), begin() );
2471  return *this;
2472 }
2473 
2476 Tensor6View& Tensor6View::operator=(Numeric x)
2477 {
2478  copy( x, begin(), end() );
2479  return *this;
2480 }
2481 
2482 // Some little helper functions:
2483 //------------------------------
2484 
2486 Tensor6View& Tensor6View::operator*=(Numeric x)
2487 {
2488  const Iterator6D ep=end();
2489  for ( Iterator6D p=begin(); p!=ep ; ++p )
2490  {
2491  *p *= x;
2492  }
2493  return *this;
2494 }
2495 
2497 Tensor6View& Tensor6View::operator/=(Numeric x)
2498 {
2499  const Iterator6D ep=end();
2500  for ( Iterator6D p=begin(); p!=ep ; ++p )
2501  {
2502  *p /= x;
2503  }
2504  return *this;
2505 }
2506 
2508 Tensor6View& Tensor6View::operator+=(Numeric x)
2509 {
2510  const Iterator6D ep=end();
2511  for ( Iterator6D p=begin(); p!=ep ; ++p )
2512  {
2513  *p += x;
2514  }
2515  return *this;
2516 }
2517 
2519 Tensor6View& Tensor6View::operator-=(Numeric x)
2520 {
2521  const Iterator6D ep=end();
2522  for ( Iterator6D p=begin(); p!=ep ; ++p )
2523  {
2524  *p -= x;
2525  }
2526  return *this;
2527 }
2528 
2530 Tensor6View& Tensor6View::operator*=(const ConstTensor6View& x)
2531 {
2532  assert( nvitrines() == x.nvitrines() );
2533  assert( nshelves() == x.nshelves() );
2534  assert( nbooks() == x.nbooks() );
2535  assert( npages() == x.npages() );
2536  assert( nrows() == x.nrows() );
2537  assert( ncols() == x.ncols() );
2538  ConstIterator6D xp = x.begin();
2539  Iterator6D p = begin();
2540  const Iterator6D ep = end();
2541  for ( ; p!=ep ; ++p,++xp )
2542  {
2543  *p *= *xp;
2544  }
2545  return *this;
2546 }
2547 
2549 Tensor6View& Tensor6View::operator/=(const ConstTensor6View& x)
2550 {
2551  assert( nvitrines() == x.nvitrines() );
2552  assert( nshelves() == x.nshelves() );
2553  assert( nbooks() == x.nbooks() );
2554  assert( npages() == x.npages() );
2555  assert( nrows() == x.nrows() );
2556  assert( ncols() == x.ncols() );
2557  ConstIterator6D xp = x.begin();
2558  Iterator6D p = begin();
2559  const Iterator6D ep = end();
2560  for ( ; p!=ep ; ++p,++xp )
2561  {
2562  *p /= *xp;
2563  }
2564  return *this;
2565 }
2566 
2568 Tensor6View& Tensor6View::operator+=(const ConstTensor6View& x)
2569 {
2570  assert( nvitrines() == x.nvitrines() );
2571  assert( nshelves() == x.nshelves() );
2572  assert( nbooks() == x.nbooks() );
2573  assert( npages() == x.npages() );
2574  assert( nrows() == x.nrows() );
2575  assert( ncols() == x.ncols() );
2576  ConstIterator6D xp = x.begin();
2577  Iterator6D p = begin();
2578  const Iterator6D ep = end();
2579  for ( ; p!=ep ; ++p,++xp )
2580  {
2581  *p += *xp;
2582  }
2583  return *this;
2584 }
2585 
2587 Tensor6View& Tensor6View::operator-=(const ConstTensor6View& x)
2588 {
2589  assert( nvitrines() == x.nvitrines() );
2590  assert( nshelves() == x.nshelves() );
2591  assert( nbooks() == x.nbooks() );
2592  assert( npages() == x.npages() );
2593  assert( nrows() == x.nrows() );
2594  assert( ncols() == x.ncols() );
2595  ConstIterator6D xp = x.begin();
2596  Iterator6D p = begin();
2597  const Iterator6D ep = end();
2598  for ( ; p!=ep ; ++p,++xp )
2599  {
2600  *p -= *xp;
2601  }
2602  return *this;
2603 }
2604 
2606 Tensor6View::Tensor6View(const Tensor5View& a) :
2607  ConstTensor6View( a.mdata,
2608  Range(0,1,
2609  a.msr.mextent*
2610  a.mbr.mextent*
2611  a.mpr.mextent*
2612  a.mrr.mextent*
2613  a.mcr.mextent),
2614  a.msr,
2615  a.mbr,
2616  a.mpr,
2617  a.mrr,
2618  a.mcr )
2619 {
2620  // Nothing to do here.
2621 }
2622 
2625 Tensor6View::Tensor6View() :
2626  ConstTensor6View()
2627 {
2628  // Nothing to do here.
2629 }
2630 
2634 Tensor6View::Tensor6View(Numeric *data,
2635  const Range& v,
2636  const Range& s,
2637  const Range& b,
2638  const Range& p,
2639  const Range& r,
2640  const Range& c) :
2641  ConstTensor6View(data, v, s, b, p, r, c)
2642 {
2643  // Nothing to do here.
2644 }
2645 
2668 Tensor6View::Tensor6View(Numeric *data,
2669  const Range& pv,
2670  const Range& ps,
2671  const Range& pb,
2672  const Range& pp,
2673  const Range& pr,
2674  const Range& pc,
2675  const Range& nv,
2676  const Range& ns,
2677  const Range& nb,
2678  const Range& np,
2679  const Range& nr,
2680  const Range& nc) :
2681  ConstTensor6View(data,pv,ps,pb,pp,pr,pc,nv,ns,nb,np,nr,nc)
2682 {
2683  // Nothing to do here.
2684 }
2685 
2690 void copy(ConstIterator6D origin,
2691  const ConstIterator6D& end,
2692  Iterator6D target)
2693 {
2694  for ( ; origin!=end ; ++origin,++target )
2695  {
2696  // We use the copy function for the next smaller rank of tensor
2697  // recursively:
2698  copy(origin->begin(),
2699  origin->end(),
2700  target->begin());
2701  }
2702 }
2703 
2705 void copy(Numeric x,
2706  Iterator6D target,
2707  const Iterator6D& end)
2708 {
2709  for ( ; target!=end ; ++target )
2710  {
2711  // We use the copy function for the next smaller rank of tensor
2712  // recursively:
2713  copy(x,target->begin(),target->end());
2714  }
2715 }
2716 
2717 
2718 // Functions for Tensor6:
2719 // ---------------------
2720 
2722 Tensor6::Tensor6() :
2723  Tensor6View::Tensor6View()
2724 {
2725  // Nothing to do here. However, note that the default constructor
2726  // for Tensor6View has been called in the initializer list. That is
2727  // crucial, otherwise internal range objects will not be properly
2728  // initialized.
2729 }
2730 
2733 Tensor6::Tensor6(Index v, Index s, Index b,
2734  Index p, Index r, Index c) :
2735  Tensor6View( new Numeric[v*s*b*p*r*c],
2736  Range(0,v,s*b*p*r*c),
2737  Range(0,s,b*p*r*c),
2738  Range(0,b,p*r*c),
2739  Range(0,p,r*c),
2740  Range(0,r,c),
2741  Range(0,c))
2742 {
2743  // Nothing to do here.
2744 }
2745 
2747 Tensor6::Tensor6(Index v, Index s, Index b,
2748  Index p, Index r, Index c, Numeric fill) :
2749  Tensor6View( new Numeric[v*s*b*p*r*c],
2750  Range(0,v,s*b*p*r*c),
2751  Range(0,s,b*p*r*c),
2752  Range(0,b,p*r*c),
2753  Range(0,p,r*c),
2754  Range(0,r,c),
2755  Range(0,c))
2756 {
2757  // Here we can access the raw memory directly, for slightly
2758  // increased efficiency:
2759  const Numeric *stop = mdata+v*s*b*p*r*c;
2760  for ( Numeric *x=mdata; x<stop; ++x )
2761  *x = fill;
2762 }
2763 
2766 Tensor6::Tensor6(const ConstTensor6View& m) :
2767  Tensor6View( new Numeric[m.nvitrines()*m.nshelves()*m.nbooks()
2768  *m.npages()*m.nrows()*m.ncols()],
2769  Range( 0, m.nvitrines(), m.nshelves()*m.nbooks()*m.npages()*m.nrows()*m.ncols() ),
2770  Range( 0, m.nshelves(), m.nbooks()*m.npages()*m.nrows()*m.ncols() ),
2771  Range( 0, m.nbooks(), m.npages()*m.nrows()*m.ncols() ),
2772  Range( 0, m.npages(), m.nrows()*m.ncols() ),
2773  Range( 0, m.nrows(), m.ncols() ),
2774  Range( 0, m.ncols() ) )
2775 {
2776  copy(m.begin(),m.end(),begin());
2777 }
2778 
2781 Tensor6::Tensor6(const Tensor6& m) :
2782  Tensor6View( new Numeric[m.nvitrines()*m.nshelves()*m.nbooks()
2783  *m.npages()*m.nrows()*m.ncols()],
2784  Range( 0, m.nvitrines(), m.nshelves()*m.nbooks()*m.npages()*m.nrows()*m.ncols() ),
2785  Range( 0, m.nshelves(), m.nbooks()*m.npages()*m.nrows()*m.ncols() ),
2786  Range( 0, m.nbooks(), m.npages()*m.nrows()*m.ncols() ),
2787  Range( 0, m.npages(), m.nrows()*m.ncols() ),
2788  Range( 0, m.nrows(), m.ncols() ),
2789  Range( 0, m.ncols() ) )
2790 {
2791  // There is a catch here: If m is an empty tensor, then it will have
2792  // dimensions of size 0. But these are used to initialize the stride
2793  // for higher dimensions! Thus, this method has to be consistent
2794  // with the behaviour of Range::Range. For now, Range::Range allows
2795  // also stride 0.
2796  copy(m.begin(),m.end(),begin());
2797 }
2798 
2800 
2823 Tensor6& Tensor6::operator=(const Tensor6& m)
2824 {
2825  // cout << "Tensor6 copy: m = " << m.nrows() << " " << m.ncols() << "\n";
2826  // cout << " n = " << nrows() << " " << ncols() << "\n";
2827 
2828  resize( m.mvr.mextent, m.msr.mextent, m.mbr.mextent,
2829  m.mpr.mextent, m.mrr.mextent, m.mcr.mextent );
2830  copy( m.begin(), m.end(), begin() );
2831  return *this;
2832 }
2833 
2836 Tensor6& Tensor6::operator=(Numeric x)
2837 {
2838  copy( x, begin(), end() );
2839  return *this;
2840 }
2841 
2845 void Tensor6::resize(Index v, Index s, Index b,
2846  Index p, Index r, Index c)
2847 {
2848  assert( 0<=v );
2849  assert( 0<=s );
2850  assert( 0<=b );
2851  assert( 0<=p );
2852  assert( 0<=r );
2853  assert( 0<=c );
2854 
2855  if ( mvr.mextent!=v ||
2856  msr.mextent!=s ||
2857  mbr.mextent!=b ||
2858  mpr.mextent!=p ||
2859  mrr.mextent!=r ||
2860  mcr.mextent!=c )
2861  {
2862  delete[] mdata;
2863  mdata = new Numeric[v*s*b*p*r*c];
2864 
2865  mvr.mstart = 0;
2866  mvr.mextent = v;
2867  mvr.mstride = s*b*p*r*c;
2868 
2869  msr.mstart = 0;
2870  msr.mextent = s;
2871  msr.mstride = b*p*r*c;
2872 
2873  mbr.mstart = 0;
2874  mbr.mextent = b;
2875  mbr.mstride = p*r*c;
2876 
2877  mpr.mstart = 0;
2878  mpr.mextent = p;
2879  mpr.mstride = r*c;
2880 
2881  mrr.mstart = 0;
2882  mrr.mextent = r;
2883  mrr.mstride = c;
2884 
2885  mcr.mstart = 0;
2886  mcr.mextent = c;
2887  mcr.mstride = 1;
2888  }
2889 }
2890 
2893 Tensor6::~Tensor6()
2894 {
2895 // cout << "Destroying a Tensor6:\n"
2896 // << *this << "\n........................................\n";
2897  delete[] mdata;
2898 }
2899 
2900 
2916 void transform( Tensor6View y,
2917  double (&my_func)(double),
2918  ConstTensor6View x )
2919 {
2920  // Check dimensions:
2921  assert( y.nvitrines() == x.nvitrines() );
2922  assert( y.nshelves() == x.nshelves() );
2923  assert( y.nbooks() == x.nbooks() );
2924  assert( y.npages() == x.npages() );
2925  assert( y.nrows() == x.nrows() );
2926  assert( y.ncols() == x.ncols() );
2927 
2928  const ConstIterator6D xe = x.end();
2929  ConstIterator6D xi = x.begin();
2930  Iterator6D yi = y.begin();
2931  for ( ; xi!=xe; ++xi, ++yi )
2932  {
2933  // Use the transform function of lower dimensional tensors
2934  // recursively:
2935  transform(*yi,my_func,*xi);
2936  }
2937 }
2938 
2940 Numeric max(const ConstTensor6View& x)
2941 {
2942  const ConstIterator6D xe = x.end();
2943  ConstIterator6D xi = x.begin();
2944 
2945  // Initial value for max:
2946  Numeric themax = max(*xi);
2947  ++xi;
2948 
2949  for ( ; xi!=xe ; ++xi )
2950  {
2951  // Use the max function of lower dimensional tensors
2952  // recursively:
2953  Numeric maxi = max(*xi);
2954  if ( maxi > themax )
2955  themax = maxi;
2956  }
2957 
2958  return themax;
2959 }
2960 
2962 Numeric min(const ConstTensor6View& x)
2963 {
2964  const ConstIterator6D xe = x.end();
2965  ConstIterator6D xi = x.begin();
2966 
2967  // Initial value for min:
2968  Numeric themin = min(*xi);
2969  ++xi;
2970 
2971  for ( ; xi!=xe ; ++xi )
2972  {
2973  // Use the min function of lower dimensional tensors
2974  // recursively:
2975  Numeric mini = min(*xi);
2976  if ( mini < themin )
2977  themin = mini;
2978  }
2979 
2980  return themin;
2981 }
2982 
2983 
2985 // Helper function for debugging
2986 #ifndef NDEBUG
2987 
3005 Numeric debug_tensor6view_get_elem (Tensor6View& tv, Index v, Index s, Index b,
3006  Index p, Index r, Index c)
3007 {
3008  return tv(v, s, b, p, r, c);
3009 }
3010 
3011 #endif
3012 
ConstTensor6View::begin
ConstIterator6D begin() const
Return const iterator to first sub-tensor.
Definition: matpackVI.cc:898
ConstTensor6View::nshelves
Index nshelves() const
Returns the number of shelves.
Definition: matpackVI.cc:37
MatrixView
The MatrixView class.
Definition: matpackI.h:668
Tensor6::resize
void resize(Index v, Index s, Index b, Index p, Index r, Index c)
Resize function.
Definition: matpackVI.cc:2845
ConstTensor6View::mvr
Range mvr
The vitrine range of mdata that is actually used.
Definition: matpackVI.h:426
ConstTensor6View::mbr
Range mbr
The book range of mdata that is actually used.
Definition: matpackVI.h:430
ConstTensor6View::npages
Index npages() const
Returns the number of pages.
Definition: matpackVI.cc:49
OFFSET
#define OFFSET(x)
Definition: matpackVI.h:34
Tensor6::operator=
Tensor6 & operator=(const Tensor6 &x)
Assignment operator from another tensor.
Definition: matpackVI.cc:2823
ConstTensor6View::nrows
Index nrows() const
Returns the number of rows.
Definition: matpackVI.cc:55
Tensor6View::operator/=
Tensor6View & operator/=(Numeric x)
Division by scalar.
Definition: matpackVI.cc:2497
Range::mstart
Index mstart
The start index.
Definition: matpackI.h:204
CHECK
#define CHECK(x)
Implementation of Tensors of Rank 6.
Definition: matpackVI.h:33
ConstTensor6View::mrr
Range mrr
The row range of mdata that is actually used.
Definition: matpackVI.h:434
Tensor6View::operator+=
Tensor6View & operator+=(Numeric x)
Addition of scalar.
Definition: matpackVI.cc:2508
ConstTensor5View::begin
ConstIterator5D begin() const
Return const iterator to first shelf.
Definition: matpackV.cc:789
ConstTensor4View
A constant view of a Tensor4.
Definition: matpackIV.h:149
Tensor3View
The Tensor3View class.
Definition: matpackIII.h:234
Tensor6View::operator*=
Tensor6View & operator*=(Numeric x)
Multiplication by scalar.
Definition: matpackVI.cc:2486
Tensor6View::operator-=
Tensor6View & operator-=(Numeric x)
Subtraction of scalar.
Definition: matpackVI.cc:2519
ConstTensor6View::nvitrines
Index nvitrines() const
Returns the number of vitrines.
Definition: matpackVI.cc:31
ConstTensor6View::mdata
Numeric * mdata
Pointer to the plain C array that holds the data.
Definition: matpackVI.h:438
ConstTensor6View::mpr
Range mpr
The page range of mdata that is actually used.
Definition: matpackVI.h:432
ConstIterator6D
Const version of Iterator6D.
Definition: matpackVI.h:94
ConstTensor6View::end
ConstIterator6D end() const
Return const iterator behind last sub-tensor.
Definition: matpackVI.cc:910
Tensor6View::Tensor6View
Tensor6View()
Default constructor.
Definition: matpackVI.cc:2625
debug_tensor6view_get_elem
Numeric debug_tensor6view_get_elem(Tensor6View &tv, Index v, Index s, Index b, Index p, Index r, Index c)
Helper function to access tensor elements.
Definition: matpackVI.cc:3005
Tensor6View::end
ConstIterator6D end() const
Return const iterator behind last sub-tensor.
Definition: matpackVI.cc:2390
VectorView
The VectorView class.
Definition: matpackI.h:373
ConstTensor6View::msr
Range msr
The shelf range of mdata that is actually used.
Definition: matpackVI.h:428
Tensor5View::begin
ConstIterator5D begin() const
Return const iterator to first shelf.
Definition: matpackV.cc:2003
ns
#define ns
Definition: continua.cc:14564
ConstTensor6View
A constant view of a Tensor6.
Definition: matpackVI.h:167
Numeric
NUMERIC Numeric
The type to use for all floating point numbers.
Definition: matpack.h:33
Tensor5View
The Tensor5View class.
Definition: matpackV.h:278
Tensor5View::end
ConstIterator5D end() const
Return const iterator behind last shelf.
Definition: matpackV.cc:2009
transform
void transform(Tensor6View y, double(&my_func)(double), ConstTensor6View x)
A generic transform function for tensors, which can be used to implement mathematical functions opera...
Definition: matpackVI.cc:2916
ConstTensor6View::operator()
ConstTensor6View operator()(const Range &v, const Range &s, const Range &b, const Range &p, const Range &r, const Range &c) const
Definition: matpackVI.cc:71
copy
void copy(ConstIterator6D origin, const ConstIterator6D &end, Iterator6D target)
Copy data between begin and end to target.
Definition: matpackVI.cc:2690
min
Numeric min(const ConstTensor6View &x)
Min function, tensor version.
Definition: matpackVI.cc:2962
Tensor6View::operator=
Tensor6View & operator=(const ConstTensor6View &v)
Assignment operator.
Definition: matpackVI.cc:2424
Iterator6D
The outermost iterator class for rank 6 tensors.
Definition: matpackVI.h:38
ConstTensor6View::nbooks
Index nbooks() const
Returns the number of books.
Definition: matpackVI.cc:43
ConstMatrixView
A constant view of a Matrix.
Definition: matpackI.h:591
max
Numeric max(const ConstTensor6View &x)
Max function, tensor version.
Definition: matpackVI.cc:2940
Range
The range class.
Definition: matpackI.h:148
Range::mextent
Index mextent
The number of elements.
Definition: matpackI.h:207
ConstTensor6View::ConstTensor6View
ConstTensor6View()
Default constructor.
Definition: matpackVI.cc:942
ConstTensor6View::mcr
Range mcr
The column range of mdata that is actually used.
Definition: matpackVI.h:436
ConstTensor3View
A constant view of a Tensor3.
Definition: matpackIII.h:147
Tensor4View
The Tensor4View class.
Definition: matpackIV.h:245
operator<<
ostream & operator<<(ostream &os, const ConstTensor6View &v)
Output operator.
Definition: matpackVI.cc:1006
Index
INDEX Index
The type to use for all integer numbers and indices.
Definition: matpack.h:39
Tensor6View::begin
ConstIterator6D begin() const
Return const iterator to sub-tensor.
Definition: matpackVI.cc:2384
Tensor6
The Tensor6 class.
Definition: matpackVI.h:937
Tensor6::~Tensor6
virtual ~Tensor6()
Destructor for Tensor6.
Definition: matpackVI.cc:2893
Range::mstride
Index mstride
The stride.
Definition: matpackI.h:209
ConstVectorView
A constant view of a Vector.
Definition: matpackI.h:300
ConstTensor5View::end
ConstIterator5D end() const
Return const iterator behind last shelf.
Definition: matpackV.cc:797
ConstTensor6View::ncols
Index ncols() const
Returns the number of columns.
Definition: matpackVI.cc:61
Tensor6::Tensor6
Tensor6()
Default constructor.
Definition: matpackVI.cc:2722
matpackVI.h
ConstTensor5View
A constant view of a Tensor5.
Definition: matpackV.h:160
Tensor6View
The Tensor6View class.
Definition: matpackVI.h:450