1 /***************************************************************************
2                           allix.hpp  -  indexer
3                              -------------------
4     begin                : July 22 2002
5     copyright            : (C) 2011 by Marc Schellens
6     email                : m_schellens@users.sf.net
7 ***************************************************************************/
8 
9 /***************************************************************************
10  *                                                                         *
11  *   This program is free software; you can redistribute it and/or modify  *
12  *   it under the terms of the GNU General Public License as published by  *
13  *   the Free Software Foundation; either version 2 of the License, or     *
14  *   (at your option) any later version.                                   *
15  *                                                                         *
16  ***************************************************************************/
17 
18 #ifndef ALLIX_HPP_
19 #define ALLIX_HPP_
20 
21 #include "typedefs.hpp"
22 
23 class AllIxBaseT
24 {
25 public:
26   virtual ~AllIxBaseT(); // code in arrayindex.cpp
27 
28   virtual AllIxBaseT* Clone() = 0;
29 
30   virtual SizeT operator[]( SizeT i) const = 0;
31   virtual SizeT size() const = 0;
32   // 	virtual SizeT max() const = 0;
33 
34   virtual SizeT InitSeqAccess() = 0;
35   virtual SizeT SeqAccess() =0;
36 
37 };
38 class AllIxT: public AllIxBaseT
39 {
40 protected:
41   SizeT ix;
42 
43 public:
AllIxT()44   AllIxT() {}
45 
AllIxT(SizeT i)46   AllIxT( SizeT i): ix( i)
47   {
48   }
49 
~AllIxT()50   ~AllIxT() {}
51 
Clone()52   AllIxT* Clone()
53   {
54     return new AllIxT( ix);
55   }
56 
operator [](SizeT i) const57   SizeT operator[]( SizeT i) const
58   {
59     assert( i == 0);
60     return ix;
61   }
62 
size() const63   SizeT size() const { return 1;}
64 
InitSeqAccess()65   SizeT InitSeqAccess() { return ix;}
SeqAccess()66   SizeT SeqAccess() { assert(false); return 0;}
67 
68 //   SizeT max() const { return ix;}
69 
Set(SizeT i)70   void Set( SizeT i) { ix = i;}
71 };
72 // class AllIxMultiT: public AllIxBaseT
73 // {
74 // private:
75 //   SizeT* ixArr;
76 //   SizeT  sz;
77 //
78 // public:
79 //   AllIxMultiT( SizeT s): sz( s)
80 //   {
81 //     assert( s > 0);
82 //     ixArr = new SizeT[ s];
83 //   }
84 //   ~AllIxMultiT() { delete[] ixArr;}
85 //
86 //   AllIxMultiT* Clone()
87 //   {
88 //     AllIxMultiT* clone = new AllIxMultiT( sz);
89 //     for( SizeT i=0; i<sz; ++i)
90 //       clone[ i] = ixArr[ i];
91 //     return clone;
92 //   }
93 //
94 //   SizeT operator[]( SizeT i) const
95 //   {
96 //     assert( i < sz);
97 //     return ixArr[ i];
98 //   }
99 //
100 //   SizeT size() const { return sz;}
101 //   SizeT max() const
102 //   {
103 //     SizeT m = ixArr[0];
104 //     for( SizeT i=1; i<sz; ++i)
105 //       if( ixArr[ i] > m)
106 // 	m = ixArr[ i] ;
107 //     return m;
108 //   }
109 //
110 //   SizeT GetIx( SizeT i) const
111 //   {
112 //     assert( i < sz);
113 //     return ixArr[ i];
114 //   }
115 //   void SetIx( SizeT i, SizeT value)
116 //   {
117 //     assert( i < sz);
118 //     ixArr[ i] = value;
119 //   }
120 //   void SetIxTo0( SizeT i)
121 //   {
122 //     assert( i < sz);
123 //     ixArr[ i] = 0;
124 //   }
125 //   void AddToIx( SizeT i, SizeT value)
126 //   {
127 //     assert( i < sz);
128 //     ixArr[ i] += value;
129 //   }
130 // };
131 
132 class AllIxRange0T: public AllIxBaseT
133 {
134 private:
135   SizeT  sz;
136   SizeT seqIx;
137 
138 public:
AllIxRange0T(SizeT sz_)139   AllIxRange0T( SizeT sz_): sz( sz_)
140   {
141   }
~AllIxRange0T()142   ~AllIxRange0T() {}
143 
Clone()144   AllIxRange0T* Clone()
145   {
146     AllIxRange0T* clone = new AllIxRange0T( sz);
147     return clone;
148   }
149 
operator [](SizeT i) const150   SizeT operator[]( SizeT i) const
151   {
152     assert( i < sz);
153     return i;
154   }
155 
InitSeqAccess()156   SizeT InitSeqAccess() { seqIx = 0; return 0;}
SeqAccess()157   SizeT SeqAccess() { assert( (seqIx+1) < sz); return ++seqIx;}
158 
size() const159   SizeT size() const { return sz;}
max() const160   SizeT max() const
161   {
162     return sz - 1;
163   }
164 };
165 class AllIxRangeT: public AllIxBaseT
166 {
167 private:
168   SizeT  sz;
169   SizeT  st;
170   SizeT seqIx;
171 
172 public:
AllIxRangeT(SizeT sz_,SizeT st_)173   AllIxRangeT( SizeT sz_, SizeT st_): sz( sz_), st( st_)
174   {
175   }
~AllIxRangeT()176   ~AllIxRangeT() {}
177 
Clone()178   AllIxRangeT* Clone()
179   {
180     AllIxRangeT* clone = new AllIxRangeT( sz, st);
181     return clone;
182   }
183 
operator [](SizeT i) const184   SizeT operator[]( SizeT i) const
185   {
186     assert( i < sz);
187     return i + st;
188   }
InitSeqAccess()189   SizeT InitSeqAccess() { seqIx = st; return st;}
SeqAccess()190   SizeT SeqAccess() { assert( (seqIx-st+1) < sz); return ++seqIx;}
191 
size() const192   SizeT size() const { return sz;}
max() const193   SizeT max() const
194   {
195     return sz - 1 + st;
196   }
197 };
198 class AllIxRangeStrideT: public AllIxBaseT
199 {
200 private:
201   SizeT  sz;
202   SizeT  st;
203   SizeT  stride;
204   SizeT seqIx;
205 
206 public:
AllIxRangeStrideT(SizeT sz_,SizeT st_,SizeT stride_)207   AllIxRangeStrideT( SizeT sz_, SizeT st_, SizeT stride_): sz( sz_), st( st_), stride( stride_)
208   {
209   }
~AllIxRangeStrideT()210   ~AllIxRangeStrideT() {}
211 
Clone()212   AllIxRangeStrideT* Clone()
213   {
214     AllIxRangeStrideT* clone = new AllIxRangeStrideT( sz, st, stride);
215     return clone;
216   }
217 
operator [](SizeT i) const218   SizeT operator[]( SizeT i) const
219   {
220     assert( i < sz);
221     return i * stride + st;
222   }
InitSeqAccess()223   SizeT InitSeqAccess() { seqIx = st; return st;}
SeqAccess()224   SizeT SeqAccess() { assert( ((seqIx+stride-st)/stride) < sz); seqIx += stride; return seqIx;}
225 
size() const226   SizeT size() const { return sz;}
max() const227   SizeT max() const
228   {
229     return (sz - 1) * stride + st;
230   }
231 };
232 class AllIxRange0StrideT: public AllIxBaseT
233 {
234 private:
235   SizeT  sz;
236   SizeT  stride;
237   SizeT seqIx;
238 
239 public:
AllIxRange0StrideT(SizeT sz_,SizeT stride_)240   AllIxRange0StrideT( SizeT sz_, SizeT stride_): sz( sz_), stride( stride_)
241   {
242   }
~AllIxRange0StrideT()243   ~AllIxRange0StrideT() {}
244 
Clone()245   AllIxRange0StrideT* Clone()
246   {
247     AllIxRange0StrideT* clone = new AllIxRange0StrideT( sz, stride);
248     return clone;
249   }
250 
operator [](SizeT i) const251   SizeT operator[]( SizeT i) const
252   {
253     assert( i < sz);
254     return i * stride;
255   }
InitSeqAccess()256   SizeT InitSeqAccess() { seqIx = 0; return 0;}
SeqAccess()257   SizeT SeqAccess() { assert( ((seqIx+stride)/stride) < sz); seqIx += stride; return seqIx;}
258 
size() const259   SizeT size() const { return sz;}
max() const260   SizeT max() const
261   {
262     return (sz - 1) * stride;
263   }
264 };
265 class BaseGDL;
266 class AllIxIndicesT: public AllIxBaseT
267 {
268 protected:
269   BaseGDL* ref;
270   SizeT         upper;
271   SizeT         seqIx;
272 #ifndef NDEBUG
273   bool upperSet;
274 #endif
275 
276 public:
AllIxIndicesT(BaseGDL * r)277   AllIxIndicesT( BaseGDL* r): ref( r), upper( 0)
278   {
279 #ifndef NDEBUG
280   upperSet = false;
281 #endif
282   }
~AllIxIndicesT()283   ~AllIxIndicesT() {}
284 
Clone()285   AllIxIndicesT* Clone()
286   {
287     AllIxIndicesT* clone = new AllIxIndicesT( ref);
288     return clone;
289   }
CloneAt(char * buf)290   virtual AllIxIndicesT* CloneAt( char* buf)
291   {
292     AllIxIndicesT* clone = new (buf) AllIxIndicesT( ref);
293     return clone;
294   }
295 
296   SizeT operator[]( SizeT i) const; // code in arrayindex.cpp
297 
298   SizeT InitSeqAccess();
299   SizeT SeqAccess(); // code in arrayindex.cpp
300 
301   SizeT size() const;
SetUpper(SizeT u)302   void SetUpper( SizeT u)
303   {
304   upper = u;
305 #ifndef NDEBUG
306   upperSet = true;
307 #endif
308   }
309 };
310 class AllIxIndicesStrictT: public AllIxIndicesT
311 {
312 public:
AllIxIndicesStrictT(BaseGDL * r)313   AllIxIndicesStrictT( BaseGDL* r): AllIxIndicesT( r)
314   {
315   }
316 
Clone()317   AllIxIndicesStrictT* Clone()
318   {
319     AllIxIndicesStrictT* clone = new AllIxIndicesStrictT( ref);
320     return clone;
321   }
CloneAt(char * buf)322   AllIxIndicesStrictT* CloneAt( char* buf)
323   {
324     AllIxIndicesStrictT* clone = new (buf) AllIxIndicesStrictT( ref);
325     return clone;
326   }
327 
328   SizeT operator[]( SizeT i) const; // code in arrayindex.cpp
329   SizeT InitSeqAccess();
330   SizeT SeqAccess(); // code in arrayindex.cpp
331 };
332 
333 
334 
335 class AllIxAllIndexedT: public AllIxBaseT
336 {
337 private:
338   ArrayIndexVectorT* ixList;
339   const SizeT* varStride;
340   SizeT acRank;
341   SizeT nIx;
342   SizeT         seqIx;
343 
344 public:
AllIxAllIndexedT(ArrayIndexVectorT * ixList_,SizeT acRank_,SizeT nIx_,const SizeT * varStride_)345   AllIxAllIndexedT( ArrayIndexVectorT* ixList_, SizeT acRank_, SizeT nIx_, const SizeT* varStride_)
346     : ixList( ixList_)
347     , varStride( varStride_)
348     , acRank( acRank_)
349     , nIx( nIx_)
350   {}
~AllIxAllIndexedT()351   ~AllIxAllIndexedT() {}
352 
Clone()353   AllIxAllIndexedT* Clone()
354   {
355     AllIxAllIndexedT* clone = new AllIxAllIndexedT( ixList, acRank, nIx, varStride);
356     return clone;
357   }
358 
359   SizeT operator[]( SizeT i) const;
360   SizeT InitSeqAccess();
361   SizeT SeqAccess();
362 
size() const363   SizeT size() const { return nIx;}
364 };
365 
366 
367 
368 class AllIxNewMultiT: public AllIxBaseT
369 {
370 private:
371   ArrayIndexVectorT* ixList;
372   SizeT ixListStride[MAXRANK];
373   const SizeT* varStride;
374   SizeT* nIterLimit;
375   SizeT* stride;
376   SizeT acRank;
377   SizeT nIx;
378   SizeT seqIx;
379   SizeT add;
380   SizeT ix2;
381   SizeT seqIter;
382   SizeT seqIter0;
383 
384 public:
AllIxNewMultiT(ArrayIndexVectorT * ixList_,SizeT acRank_,SizeT nIx_,const SizeT * varStride_,SizeT * nIterLimit_,SizeT * stride_)385   AllIxNewMultiT( ArrayIndexVectorT* ixList_, SizeT acRank_, SizeT nIx_, const SizeT* varStride_, SizeT* nIterLimit_, SizeT* stride_)
386     : ixList( ixList_)
387     , varStride( varStride_)
388     , nIterLimit( nIterLimit_)
389     , stride( stride_)
390     , acRank( acRank_)
391     , nIx( nIx_)
392     , add(0)
393   {
394 	assert( varStride[0] == 1);
395 	for( SizeT i=0; i<acRank;++i)
396 		{
397 		if( !(*ixList)[i]->Indexed())
398 			{
399 				ixListStride[i] = (*ixList)[i]->GetStride() * varStride[i];
400 				assert( ixListStride[i] >= 1);
401 				add += (*ixList)[i]->GetS() * varStride[i];
402 			}
403 		}
404   }
~AllIxNewMultiT()405   ~AllIxNewMultiT() {}
406 
Clone()407   AllIxNewMultiT* Clone()
408   {
409     AllIxNewMultiT* clone = new AllIxNewMultiT( *this);
410     return clone;
411   }
412 
413   SizeT operator[]( SizeT i) const;
414   SizeT InitSeqAccess();
415   SizeT SeqAccess();
416 
size() const417   SizeT size() const { return nIx;}
418 };
419 
420 
421 
422 // acRank == 2
423 class AllIxNewMulti2DT: public AllIxBaseT
424 {
425 private:
426   ArrayIndexVectorT* ixList;
427   SizeT ixListStride[2];
428   const SizeT* varStride;
429   SizeT* nIterLimit;
430   SizeT* stride;
431   SizeT nIx;
432   SizeT seqIx;
433 //   SizeT s[MAXRANK];
434   SizeT add;
435   SizeT ix2;
436   SizeT seqIter;
437   SizeT seqIter0;
438 
439 
440 public:
AllIxNewMulti2DT(ArrayIndexVectorT * ixList_,SizeT nIx_,const SizeT * varStride_,SizeT * nIterLimit_,SizeT * stride_)441   AllIxNewMulti2DT( ArrayIndexVectorT* ixList_, SizeT nIx_, const SizeT* varStride_, SizeT* nIterLimit_, SizeT* stride_)
442     : ixList( ixList_)
443     , varStride( varStride_)
444     , nIterLimit( nIterLimit_)
445     , stride( stride_)
446     , nIx( nIx_)
447     , add(0)
448   {
449 	if( !(*ixList)[0]->Indexed())
450 	{
451 		assert( varStride[0] == 1);
452 		ixListStride[0] = (*ixList)[0]->GetStride();
453 		assert( ixListStride[0] >= 1);
454 		add += (*ixList)[0]->GetS();
455 	}
456 	if( !(*ixList)[1]->Indexed())
457 		{
458 			ixListStride[1] = (*ixList)[1]->GetStride() * varStride[1];
459 			assert( ixListStride[1] >= 1);
460 			add += (*ixList)[1]->GetS() * varStride[1];
461 		}
462   }
~AllIxNewMulti2DT()463   ~AllIxNewMulti2DT() {}
464 
Clone()465   AllIxNewMulti2DT* Clone()
466   {
467     AllIxNewMulti2DT* clone = new AllIxNewMulti2DT( *this);
468     return clone;
469   }
470 
471   SizeT operator[]( SizeT i) const;
472   SizeT InitSeqAccess();
473   SizeT SeqAccess();
474 
size() const475   SizeT size() const { return nIx;}
476 };
477 
478 
479 
480 
481 class AllIxNewMultiNoneIndexedT: public AllIxBaseT
482 {
483 private:
484   ArrayIndexVectorT* ixList;
485   SizeT ixListStride[MAXRANK];
486   const SizeT* varStride;
487   SizeT* nIterLimit;
488   SizeT* stride;
489   SizeT acRank;
490   SizeT nIx;
491   SizeT seqIx;
492   SizeT add;
493 //  SizeT seqIter; see cpp file: used in previous, slower, version.
494   SizeT correctionIncrease;
495   SizeT nextCorrection;
496   SizeT sequence[MAXRANK];
497   SizeT xx[MAXRANK];
498   int   factor[MAXRANK];
499 
500 //   SizeT seqIxDebug;
501 
502 public:
AllIxNewMultiNoneIndexedT(ArrayIndexVectorT * ixList_,SizeT acRank_,SizeT nIx_,const SizeT * varStride_,SizeT * nIterLimit_,SizeT * stride_)503   AllIxNewMultiNoneIndexedT( ArrayIndexVectorT* ixList_, SizeT acRank_, SizeT nIx_, const SizeT* varStride_, SizeT* nIterLimit_, SizeT* stride_)
504     : ixList( ixList_)
505     , varStride( varStride_)
506     , nIterLimit( nIterLimit_)
507     , stride( stride_)
508     , acRank( acRank_)
509     , nIx( nIx_)
510   {
511 	assert( varStride[0] == 1);
512     add = 0;
513 	for( SizeT i=0; i<acRank;++i)
514 		{
515 		ixListStride[i] = (*ixList)[i]->GetStride() * varStride[i];
516 		assert( ixListStride[i] >= 1);
517 		add += (*ixList)[i]->GetS() * varStride[i];
518 		}
519   }
~AllIxNewMultiNoneIndexedT()520   ~AllIxNewMultiNoneIndexedT() {}
521 
Clone()522   AllIxNewMultiNoneIndexedT* Clone()
523   {
524     AllIxNewMultiNoneIndexedT* clone = new AllIxNewMultiNoneIndexedT( *this);
525     return clone;
526   }
527 
528   SizeT operator[]( SizeT i) const;
529   SizeT InitSeqAccess();
530   SizeT SeqAccess();
531 
size() const532   SizeT size() const { return nIx;}
533 };
534 
535 
536 // acRank == 2
537 class AllIxNewMultiNoneIndexed2DT: public AllIxBaseT
538 {
539 private:
540   ArrayIndexVectorT* ixList;
541   SizeT ixListStride[2];
542   const SizeT* varStride;
543   SizeT* nIterLimit;
544   SizeT* stride;
545   SizeT nIx;
546   SizeT seqIx;
547   SizeT add;
548   SizeT nextCorrection;
549   SizeT correctionIncrease;
550 
551 public:
AllIxNewMultiNoneIndexed2DT(ArrayIndexVectorT * ixList_,SizeT nIx_,const SizeT * varStride_,SizeT * nIterLimit_,SizeT * stride_)552   AllIxNewMultiNoneIndexed2DT( ArrayIndexVectorT* ixList_, SizeT nIx_, const SizeT* varStride_, SizeT* nIterLimit_, SizeT* stride_)
553     : ixList( ixList_)
554     , varStride( varStride_)
555     , nIterLimit( nIterLimit_)
556     , stride( stride_)
557     , nIx( nIx_)
558   {
559 		assert( varStride[0] == 1);
560 		ixListStride[0] = (*ixList)[0]->GetStride();
561 		ixListStride[1] = (*ixList)[1]->GetStride() * varStride[1];
562 		add = (*ixList)[0]->GetS() + (*ixList)[1]->GetS() * varStride[1];
563   }
~AllIxNewMultiNoneIndexed2DT()564   ~AllIxNewMultiNoneIndexed2DT() {}
565 
Clone()566   AllIxNewMultiNoneIndexed2DT* Clone()
567   {
568     AllIxNewMultiNoneIndexed2DT* clone = new AllIxNewMultiNoneIndexed2DT( *this);
569     return clone;
570   }
571 
572   SizeT operator[]( SizeT i) const;
573   SizeT InitSeqAccess();
574   SizeT SeqAccess();
575 
size() const576   SizeT size() const { return nIx;}
577 };
578 
579 
580 
581 class AllIxNewMultiOneVariableIndexNoIndexT: public AllIxBaseT
582 {
583 private:
584   ArrayIndexVectorT* ixList;
585   SizeT ixListStride;
586   const SizeT* varStride;
587   SizeT* nIterLimit;
588   SizeT* stride;
589   SizeT acRank;
590   SizeT nIx;
591   SizeT seqIx;
592   SizeT add;
593   RankT variableIndex;
594 
595 public:
AllIxNewMultiOneVariableIndexNoIndexT(RankT gt1Rank,SizeT add_,ArrayIndexVectorT * ixList_,SizeT acRank_,SizeT nIx_,const SizeT * varStride_,SizeT * nIterLimit_,SizeT * stride_)596   AllIxNewMultiOneVariableIndexNoIndexT( RankT gt1Rank, SizeT add_,
597 								  ArrayIndexVectorT* ixList_, SizeT acRank_, SizeT nIx_, const SizeT* varStride_, SizeT* nIterLimit_, SizeT* stride_)
598 	: ixList( ixList_)
599     , varStride( varStride_)
600     , nIterLimit( nIterLimit_)
601     , stride( stride_)
602     , acRank( acRank_)
603     , nIx( nIx_)
604 	, add( add_)
605 	, variableIndex( gt1Rank)
606 	{
607 	assert( varStride[0] == 1);
608 	ixListStride = (*ixList)[variableIndex]->GetStride() * varStride[variableIndex];
609 	assert( ixListStride >= 1);
610 	}
~AllIxNewMultiOneVariableIndexNoIndexT()611   ~AllIxNewMultiOneVariableIndexNoIndexT() {}
612 
Clone()613   AllIxNewMultiOneVariableIndexNoIndexT* Clone()
614   {
615     AllIxNewMultiOneVariableIndexNoIndexT* clone = new AllIxNewMultiOneVariableIndexNoIndexT( *this);
616     return clone;
617   }
618 
619   SizeT operator[]( SizeT i) const;
620   SizeT InitSeqAccess();
621   SizeT SeqAccess();
622 
size() const623   SizeT size() const { return nIx;}
624 };
625 
626 
627 
628 class AllIxNewMultiOneVariableIndexIndexedT: public AllIxBaseT
629 {
630 private:
631   ArrayIndexVectorT* ixList;
632   SizeT ixListStride;
633   const SizeT* varStride;
634   SizeT* nIterLimit;
635   SizeT* stride;
636   SizeT acRank;
637   SizeT nIx;
638   SizeT seqIx;
639   SizeT add;
640   RankT variableIndex;
641   ArrayIndexT* arrayIndexIndexed;
642 
643 public:
AllIxNewMultiOneVariableIndexIndexedT(RankT gt1Rank,SizeT add_,ArrayIndexVectorT * ixList_,SizeT acRank_,SizeT nIx_,const SizeT * varStride_,SizeT * nIterLimit_,SizeT * stride_)644   AllIxNewMultiOneVariableIndexIndexedT( RankT gt1Rank, SizeT add_, ArrayIndexVectorT* ixList_,
645 					 SizeT acRank_, SizeT nIx_, const SizeT* varStride_,
646 					 SizeT* nIterLimit_, SizeT* stride_)
647     : ixList( ixList_)
648     , varStride( varStride_)
649     , nIterLimit( nIterLimit_)
650     , stride( stride_)
651     , acRank( acRank_)
652     , nIx( nIx_)
653     , add( add_)
654     , variableIndex( gt1Rank)
655     {
656 	    arrayIndexIndexed = (*ixList)[variableIndex];
657 	    ixListStride = varStride[variableIndex];
658 	    if( ixListStride < 1) // debug
659 	      assert( ixListStride >= 1);
660     }
~AllIxNewMultiOneVariableIndexIndexedT()661   ~AllIxNewMultiOneVariableIndexIndexedT() {}
662 
Clone()663   AllIxNewMultiOneVariableIndexIndexedT* Clone()
664   {
665     AllIxNewMultiOneVariableIndexIndexedT* clone = new AllIxNewMultiOneVariableIndexIndexedT( *this);
666     return clone;
667   }
668 
669   SizeT operator[]( SizeT i) const;
670   SizeT InitSeqAccess();
671   SizeT SeqAccess();
672 
size() const673   SizeT size() const { return nIx;}
674 };
675 
676 
677 
678 namespace AllIxMaxSizeCalculation
679 {
680   static const int a = sizeof( AllIxRangeT);
681   static const int b = sizeof( AllIxRange0T);
682   static const int c = sizeof( AllIxRangeStrideT);
683   static const int d = sizeof( AllIxRange0StrideT);
684   static const int e = sizeof( AllIxT);
685   static const int f = sizeof( AllIxNewMultiOneVariableIndexIndexedT);
686   static const int g = sizeof( AllIxNewMultiOneVariableIndexNoIndexT);
687   static const int h = sizeof( AllIxNewMulti2DT);
688   static const int i = sizeof( AllIxNewMultiT);
689   static const int j = sizeof( AllIxNewMultiNoneIndexedT);
690   static const int k = sizeof( AllIxNewMultiNoneIndexed2DT);
691   static const int ab = a > b ? a : b;
692   static const int abc = ab > c ? ab : c;
693   static const int abcd = abc > d ? abc : d;
694   static const int abcde = abcd > e ? abcd : e;
695   static const int abcdef = abcde > f ? abcde : f;
696   static const int abcdefg = abcdef > g ? abcdef : g;
697   static const int abcdefgh = abcdefg > h ? abcdefg : h;
698   static const int abcdefghi = abcdefgh > i ? abcdefgh : i;
699   static const int abcdefghij = abcdefghi > j ? abcdefghi : j;
700   static const int abcdefghijk = abcdefghij > k ? abcdefghij : k;
701   static const int Max = abcdefghijk;
702 }
703 
704 static const int AllIxMaxSize = AllIxMaxSizeCalculation::Max;
705 
706 #endif
707