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