Changeset 1156 in Sophya for trunk/SophyaLib/TArray/tarray.cc
- Timestamp:
- Aug 29, 2000, 6:10:32 PM (25 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/SophyaLib/TArray/tarray.cc
r1113 r1156 39 39 */ 40 40 template <class T> 41 TArray<T>::TArray( uint_4 ndim, const uint_4 * siz, uint_4step)41 TArray<T>::TArray(int_4 ndim, const sa_size_t * siz, sa_size_t step) 42 42 : BaseArray() , mNDBlock(ComputeTotalSize(ndim, siz, step, 1)) 43 43 { 44 string exmsg = "TArray<T>::TArray( uint_4, uint_4 *, uint_4)";44 string exmsg = "TArray<T>::TArray(int_4, sa_size_t *, sa_size_t)"; 45 45 if (!UpdateSizes(ndim, siz, step, 0, exmsg)) throw( ParmError(exmsg) ); 46 46 } … … 51 51 */ 52 52 template <class T> 53 TArray<T>::TArray( uint_4 nx, uint_4 ny, uint_4 nz, uint_4 nt, uint_4nu)53 TArray<T>::TArray(sa_size_t nx, sa_size_t ny, sa_size_t nz, sa_size_t nt, sa_size_t nu) 54 54 : BaseArray() , mNDBlock(nx*((ny>0)?ny:1)*((nz>0)?nz:1)*((nt>0)?nt:1)*((nu>0)?nu:1)) 55 55 { 56 uint_4size[BASEARRAY_MAXNDIMS];56 sa_size_t size[BASEARRAY_MAXNDIMS]; 57 57 size[0] = nx; size[1] = ny; size[2] = nz; 58 58 size[3] = nt; size[4] = nu; 59 int ndim = 1;59 int_4 ndim = 1; 60 60 if ((size[1] > 0) && (size[2] > 0) && (size[3] > 0) && (size[4] > 0) ) ndim = 5; 61 61 else if ((size[1] > 0) && (size[2] > 0) && (size[3] > 0) ) ndim = 4; … … 63 63 else if (size[1] > 0) ndim = 2; 64 64 else ndim = 1; 65 string exmsg = "TArray<T>::TArray( uint_4, uint_4, uint_4)";65 string exmsg = "TArray<T>::TArray(sa_size_t, sa_size_t, sa_size_t, sa_size_t, sa_size_t)"; 66 66 if (!UpdateSizes(ndim, size, 1, 0, exmsg)) throw( ParmError(exmsg) ); 67 67 } … … 77 77 */ 78 78 template <class T> 79 TArray<T>::TArray( uint_4 ndim, const uint_4 * siz, NDataBlock<T> & db, bool share, uint_4 step, uint_8offset)79 TArray<T>::TArray(int_4 ndim, const sa_size_t * siz, NDataBlock<T> & db, bool share, sa_size_t step, sa_size_t offset) 80 80 : BaseArray() , mNDBlock(db, share) 81 81 { 82 string exmsg = "TArray<T>::TArray( uint_4, uint_4*, NDataBlock<T> & ... )";82 string exmsg = "TArray<T>::TArray(int_4, sa_size_t *, NDataBlock<T> & ... )"; 83 83 if (!UpdateSizes(ndim, siz, step, offset, exmsg)) throw( ParmError(exmsg) ); 84 84 … … 97 97 */ 98 98 template <class T> 99 TArray<T>::TArray( uint_4 ndim, const uint_4 * siz, T* values, uint_4 step, uint_8offset, Bridge* br)99 TArray<T>::TArray(int_4 ndim, const sa_size_t * siz, T* values, sa_size_t step, sa_size_t offset, Bridge* br) 100 100 : BaseArray() , mNDBlock(ComputeTotalSize(ndim, siz, step, 1), values, br) 101 101 { 102 string exmsg = "TArray<T>::TArray( uint_4, uint_4*, T* ... )";102 string exmsg = "TArray<T>::TArray(int_4, sa_size_t *, T* ... )"; 103 103 if (!UpdateSizes(ndim, siz, step, offset, exmsg)) throw( ParmError(exmsg) ); 104 104 } … … 225 225 */ 226 226 template <class T> 227 void TArray<T>::ReSize( uint_4 ndim, uint_4 * siz, uint_4step)227 void TArray<T>::ReSize(int_4 ndim, sa_size_t * siz, sa_size_t step) 228 228 { 229 229 if (arrtype_ != 0) { … … 247 247 */ 248 248 template <class T> 249 void TArray<T>::Realloc( uint_4 ndim, uint_4 * siz, uint_4step, bool force)249 void TArray<T>::Realloc(int_4 ndim, sa_size_t * siz, sa_size_t step, bool force) 250 250 { 251 251 if (arrtype_ != 0) { … … 279 279 //! Give value (in \b double) for element at position \b ip.. 280 280 template <class T> 281 MuTyV & TArray<T>::ValueAtPosition( uint_8ip) const281 MuTyV & TArray<T>::ValueAtPosition(sa_size_t ip) const 282 282 { 283 283 #ifdef SO_BOUNDCHECKING 284 if (ip >= totsize_) throw( ParmError("TArray<T>::ValueAtPosition( uint_8ip) Out-of-bound Error") );284 if (ip >= totsize_) throw( ParmError("TArray<T>::ValueAtPosition(sa_size_t ip) Out-of-bound Error") ); 285 285 #endif 286 286 my_mtv = *(mNDBlock.Begin()+Offset(ip)); … … 326 326 if (NbDimensions() < 1) 327 327 throw RangeCheckError("TArray<T>::operator () (Range, ...) - Not Allocated Array ! "); 328 uint_4 ndim = 0;329 uint_4size[BASEARRAY_MAXNDIMS];330 uint_4step[BASEARRAY_MAXNDIMS];331 uint_4pos[BASEARRAY_MAXNDIMS];328 int_4 ndim = 0; 329 sa_size_t size[BASEARRAY_MAXNDIMS]; 330 sa_size_t step[BASEARRAY_MAXNDIMS]; 331 sa_size_t pos[BASEARRAY_MAXNDIMS]; 332 332 size[0] = rx.Size(); 333 333 size[1] = ry.Size(); … … 373 373 374 374 T * pe; 375 uint_8j,k;376 int ka;375 sa_size_t j,k; 376 int_4 ka; 377 377 if (arrtype_ == 0) ka = 0; 378 378 else ka = macoli_; 379 uint_8step = Step(ka);380 uint_8gpas = Size(ka);381 uint_8naxa = Size()/Size(ka);379 sa_size_t step = Step(ka); 380 sa_size_t gpas = Size(ka); 381 sa_size_t naxa = Size()/Size(ka); 382 382 for(j=0; j<naxa; j++) { 383 383 pe = mNDBlock.Begin()+Offset(ka,j); … … 401 401 throw RangeCheckError("TArray<T>::SetT(T ) - Not Allocated Array ! "); 402 402 T * pe; 403 uint_8j,k;403 sa_size_t j,k; 404 404 if (AvgStep() > 0) { // regularly spaced elements 405 uint_8step = AvgStep();406 uint_8maxx = totsize_*step;405 sa_size_t step = AvgStep(); 406 sa_size_t maxx = totsize_*step; 407 407 pe = Data(); 408 408 for(k=0; k<maxx; k+=step ) pe[k] = x; 409 409 } 410 410 else { // Non regular data spacing ... 411 uint_4 ka = MaxSizeKA();412 uint_8step = Step(ka);413 uint_8gpas = Size(ka)*step;414 uint_8naxa = Size()/Size(ka);411 int_4 ka = MaxSizeKA(); 412 sa_size_t step = Step(ka); 413 sa_size_t gpas = Size(ka)*step; 414 sa_size_t naxa = Size()/Size(ka); 415 415 for(j=0; j<naxa; j++) { 416 416 pe = mNDBlock.Begin()+Offset(ka,j); … … 428 428 throw RangeCheckError("TArray<T>::Add(T ) - Not Allocated Array ! "); 429 429 T * pe; 430 uint_8j,k;430 sa_size_t j,k; 431 431 if (AvgStep() > 0) { // regularly spaced elements 432 uint_8step = AvgStep();433 uint_8maxx = totsize_*step;432 sa_size_t step = AvgStep(); 433 sa_size_t maxx = totsize_*step; 434 434 pe = Data(); 435 435 for(k=0; k<maxx; k+=step ) pe[k] += x; 436 436 } 437 437 else { // Non regular data spacing ... 438 uint_4 ka = MaxSizeKA();439 uint_8step = Step(ka);440 uint_8gpas = Size(ka)*step;441 uint_8naxa = Size()/Size(ka);438 int_4 ka = MaxSizeKA(); 439 sa_size_t step = Step(ka); 440 sa_size_t gpas = Size(ka)*step; 441 sa_size_t naxa = Size()/Size(ka); 442 442 for(j=0; j<naxa; j++) { 443 443 pe = mNDBlock.Begin()+Offset(ka,j); … … 459 459 throw RangeCheckError("TArray<T>::Sub(T ) - Not Allocated Array ! "); 460 460 T * pe; 461 uint_8j,k;461 sa_size_t j,k; 462 462 if (AvgStep() > 0) { // regularly spaced elements 463 uint_8step = AvgStep();464 uint_8maxx = totsize_*step;463 sa_size_t step = AvgStep(); 464 sa_size_t maxx = totsize_*step; 465 465 pe = Data(); 466 466 if (fginv) … … 470 470 } 471 471 else { // Non regular data spacing ... 472 uint_4 ka = MaxSizeKA();473 uint_8step = Step(ka);474 uint_8gpas = Size(ka)*step;475 uint_8naxa = Size()/Size(ka);472 int_4 ka = MaxSizeKA(); 473 sa_size_t step = Step(ka); 474 sa_size_t gpas = Size(ka)*step; 475 sa_size_t naxa = Size()/Size(ka); 476 476 for(j=0; j<naxa; j++) { 477 477 pe = mNDBlock.Begin()+Offset(ka,j); … … 492 492 throw RangeCheckError("TArray<T>::Mul(T ) - Not Allocated Array ! "); 493 493 T * pe; 494 uint_8j,k;494 sa_size_t j,k; 495 495 if (AvgStep() > 0) { // regularly spaced elements 496 uint_8step = AvgStep();497 uint_8maxx = totsize_*step;496 sa_size_t step = AvgStep(); 497 sa_size_t maxx = totsize_*step; 498 498 pe = Data(); 499 499 for(k=0; k<maxx; k+=step ) pe[k] *= x; 500 500 } 501 501 else { // Non regular data spacing ... 502 uint_4 ka = MaxSizeKA();503 uint_8step = Step(ka);504 uint_8gpas = Size(ka)*step;505 uint_8naxa = Size()/Size(ka);502 int_4 ka = MaxSizeKA(); 503 sa_size_t step = Step(ka); 504 sa_size_t gpas = Size(ka)*step; 505 sa_size_t naxa = Size()/Size(ka); 506 506 for(j=0; j<naxa; j++) { 507 507 pe = mNDBlock.Begin()+Offset(ka,j); … … 525 525 throw MathExc("TArray<T>::Div(T ) - Divide by zero ! "); 526 526 T * pe; 527 uint_8j,k;527 sa_size_t j,k; 528 528 if (AvgStep() > 0) { // regularly spaced elements 529 uint_8step = AvgStep();530 uint_8maxx = totsize_*step;529 sa_size_t step = AvgStep(); 530 sa_size_t maxx = totsize_*step; 531 531 pe = Data(); 532 532 if (fginv) … … 536 536 } 537 537 else { // Non regular data spacing ... 538 uint_4 ka = MaxSizeKA();539 uint_8step = Step(ka);540 uint_8gpas = Size(ka)*step;541 uint_8naxa = Size()/Size(ka);538 int_4 ka = MaxSizeKA(); 539 sa_size_t step = Step(ka); 540 sa_size_t gpas = Size(ka)*step; 541 sa_size_t naxa = Size()/Size(ka); 542 542 for(j=0; j<naxa; j++) { 543 543 pe = mNDBlock.Begin()+Offset(ka,j); … … 552 552 553 553 554 554 //! Replace array elements values by their opposite ( a(i) -> -a(i) ) 555 template <class T> 556 TArray<T>& TArray<T>::NegateElt() 557 { 558 if (NbDimensions() < 1) 559 throw RangeCheckError("TArray<T>::NegateElt() - Not Allocated Array ! "); 560 T * pe; 561 sa_size_t j,k; 562 if (AvgStep() > 0) { // regularly spaced elements 563 sa_size_t step = AvgStep(); 564 sa_size_t maxx = totsize_*step; 565 pe = Data(); 566 for(k=0; k<maxx; k+=step ) pe[k] = -pe[k]; 567 } 568 else { // Non regular data spacing ... 569 int_4 ka = MaxSizeKA(); 570 sa_size_t step = Step(ka); 571 sa_size_t gpas = Size(ka)*step; 572 sa_size_t naxa = Size()/Size(ka); 573 for(j=0; j<naxa; j++) { 574 pe = mNDBlock.Begin()+Offset(ka,j); 575 for(k=0; k<gpas; k+=step) pe[k] = -pe[k]; 576 } 577 } 578 return(*this); 579 } 555 580 556 581 // >>>> Operations avec 2nd membre de type tableau … … 567 592 T * pe; 568 593 const T * pea; 569 uint_8j,k,ka;594 sa_size_t j,k,ka; 570 595 if (smo && (AvgStep() > 0) && (a.AvgStep() > 0)) { // regularly spaced elements 571 uint_8step = AvgStep();572 uint_8stepa = a.AvgStep();573 uint_8maxx = totsize_*step;596 sa_size_t step = AvgStep(); 597 sa_size_t stepa = a.AvgStep(); 598 sa_size_t maxx = totsize_*step; 574 599 pe = Data(); 575 600 pea = a.Data(); … … 577 602 } 578 603 else { // Non regular data spacing ... 579 int ax,axa;580 uint_8step, stepa;581 uint_8gpas, naxa;604 int_4 ax,axa; 605 sa_size_t step, stepa; 606 sa_size_t gpas, naxa; 582 607 GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa); 583 608 for(j=0; j<naxa; j++) { … … 606 631 T * pe; 607 632 const T * pea; 608 uint_8j,k,ka;633 sa_size_t j,k,ka; 609 634 if (smo && (AvgStep() > 0) && (a.AvgStep() > 0) ) { // regularly spaced elements 610 uint_8step = AvgStep();611 uint_8stepa = a.AvgStep();612 uint_8maxx = totsize_*step;635 sa_size_t step = AvgStep(); 636 sa_size_t stepa = a.AvgStep(); 637 sa_size_t maxx = totsize_*step; 613 638 pe = Data(); 614 639 pea = a.Data(); … … 619 644 } 620 645 else { // Non regular data spacing ... 621 int ax,axa;622 uint_8step, stepa;623 uint_8gpas, naxa;646 int_4 ax,axa; 647 sa_size_t step, stepa; 648 sa_size_t gpas, naxa; 624 649 GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa); 625 650 for(j=0; j<naxa; j++) { … … 648 673 T * pe; 649 674 const T * pea; 650 uint_8j,k,ka;675 sa_size_t j,k,ka; 651 676 if (smo && (AvgStep() > 0) && (a.AvgStep() > 0) ) { // regularly spaced elements 652 uint_8step = AvgStep();653 uint_8stepa = a.AvgStep();654 uint_8maxx = totsize_*step;677 sa_size_t step = AvgStep(); 678 sa_size_t stepa = a.AvgStep(); 679 sa_size_t maxx = totsize_*step; 655 680 pe = Data(); 656 681 pea = a.Data(); … … 658 683 } 659 684 else { // Non regular data spacing ... 660 int ax,axa;661 uint_8step, stepa;662 uint_8gpas, naxa;685 int_4 ax,axa; 686 sa_size_t step, stepa; 687 sa_size_t gpas, naxa; 663 688 GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa); 664 689 for(j=0; j<naxa; j++) { … … 689 714 T * pe; 690 715 const T * pea; 691 uint_8j,k,ka;716 sa_size_t j,k,ka; 692 717 if (smo && (AvgStep() > 0) && (a.AvgStep() > 0) ) { // regularly spaced elements 693 uint_8step = AvgStep();694 uint_8stepa = a.AvgStep();695 uint_8maxx = totsize_*step;718 sa_size_t step = AvgStep(); 719 sa_size_t stepa = a.AvgStep(); 720 sa_size_t maxx = totsize_*step; 696 721 pe = Data(); 697 722 pea = a.Data(); … … 711 736 } 712 737 else { // Non regular data spacing ... 713 int ax,axa;714 uint_8step, stepa;715 uint_8gpas, naxa;738 int_4 ax,axa; 739 sa_size_t step, stepa; 740 sa_size_t gpas, naxa; 716 741 GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa); 717 742 for(j=0; j<naxa; j++) { … … 748 773 T * pe; 749 774 const T * pea; 750 uint_8j,k,ka;775 sa_size_t j,k,ka; 751 776 if (smo && (AvgStep() > 0) && (a.AvgStep() > 0) ) { // regularly spaced elements 752 uint_8step = AvgStep();753 uint_8stepa = a.AvgStep();754 uint_8maxx = totsize_*step;777 sa_size_t step = AvgStep(); 778 sa_size_t stepa = a.AvgStep(); 779 sa_size_t maxx = totsize_*step; 755 780 pe = Data(); 756 781 pea = a.Data(); … … 758 783 } 759 784 else { // Non regular data spacing ... 760 int ax,axa;761 uint_8step, stepa;762 uint_8gpas, naxa;785 int_4 ax,axa; 786 sa_size_t step, stepa; 787 sa_size_t gpas, naxa; 763 788 GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa); 764 789 for(j=0; j<naxa; j++) { … … 782 807 783 808 T * pe; 784 uint_8j,k,ka;785 uint_8offa;809 sa_size_t j,k,ka; 810 sa_size_t offa; 786 811 // Non regular data spacing ... 787 int ax,axa;788 uint_8step, stepa;789 uint_8gpas, naxa;812 int_4 ax,axa; 813 sa_size_t step, stepa; 814 sa_size_t gpas, naxa; 790 815 GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa); 791 816 for(j=0; j<naxa; j++) { … … 812 837 T ret=0; 813 838 const T * pe; 814 uint_8j,k;839 sa_size_t j,k; 815 840 if (AvgStep() > 0) { // regularly spaced elements 816 uint_8step = AvgStep();817 uint_8maxx = totsize_*step;841 sa_size_t step = AvgStep(); 842 sa_size_t maxx = totsize_*step; 818 843 pe = Data(); 819 844 for(k=0; k<maxx; k+=step ) ret += pe[k]; 820 845 } 821 846 else { // Non regular data spacing ... 822 uint_4 ka = MaxSizeKA();823 uint_8step = Step(ka);824 uint_8gpas = Size(ka)*step;825 uint_8naxa = Size()/Size(ka);847 int_4 ka = MaxSizeKA(); 848 sa_size_t step = Step(ka); 849 sa_size_t gpas = Size(ka)*step; 850 sa_size_t naxa = Size()/Size(ka); 826 851 for(j=0; j<naxa; j++) { 827 852 pe = mNDBlock.Begin()+Offset(ka,j); … … 840 865 T ret=(T)1; 841 866 const T * pe; 842 uint_8j,k;867 sa_size_t j,k; 843 868 if (AvgStep() > 0) { // regularly spaced elements 844 uint_8step = AvgStep();845 uint_8maxx = totsize_*step;869 sa_size_t step = AvgStep(); 870 sa_size_t maxx = totsize_*step; 846 871 pe = Data(); 847 872 for(k=0; k<maxx; k+=step ) ret *= pe[k]; 848 873 } 849 874 else { // Non regular data spacing ... 850 uint_4 ka = MaxSizeKA();851 uint_8step = Step(ka);852 uint_8gpas = Size(ka)*step;853 uint_8naxa = Size()/Size(ka);875 int_4 ka = MaxSizeKA(); 876 sa_size_t step = Step(ka); 877 sa_size_t gpas = Size(ka)*step; 878 sa_size_t naxa = Size()/Size(ka); 854 879 for(j=0; j<naxa; j++) { 855 880 pe = mNDBlock.Begin()+Offset(ka,j); … … 868 893 T ret=0; 869 894 const T * pe; 870 uint_8j,k;895 sa_size_t j,k; 871 896 if (AvgStep() > 0) { // regularly spaced elements 872 uint_8step = AvgStep();873 uint_8maxx = totsize_*step;897 sa_size_t step = AvgStep(); 898 sa_size_t maxx = totsize_*step; 874 899 pe = Data(); 875 900 for(k=0; k<maxx; k+=step ) ret += pe[k]*pe[k]; 876 901 } 877 902 else { // Non regular data spacing ... 878 uint_4 ka = MaxSizeKA();879 uint_8step = Step(ka);880 uint_8gpas = Size(ka)*step;881 uint_8naxa = Size()/Size(ka);903 int_4 ka = MaxSizeKA(); 904 sa_size_t step = Step(ka); 905 sa_size_t gpas = Size(ka)*step; 906 sa_size_t naxa = Size()/Size(ka); 882 907 for(j=0; j<naxa; j++) { 883 908 pe = mNDBlock.Begin()+Offset(ka,j); … … 896 921 { 897 922 const T * pe; 898 uint_8j,k;899 uint_4 ka = MaxSizeKA();900 uint_8step = Step(ka);901 uint_8gpas = Size(ka)*step;902 uint_8naxa = Size()/Size(ka);923 sa_size_t j,k; 924 int_4 ka = MaxSizeKA(); 925 sa_size_t step = Step(ka); 926 sa_size_t gpas = Size(ka)*step; 927 sa_size_t naxa = Size()/Size(ka); 903 928 min = (*this)[0]; 904 929 max = (*this)[0]; … … 948 973 { 949 974 if (maxprt < 0) maxprt = max_nprt_; 950 uint_4npr = 0;975 sa_size_t npr = 0; 951 976 Show(os, si); 952 977 if (ndim_ < 1) return; 953 uint_4k0,k1,k2,k3,k4;978 sa_size_t k0,k1,k2,k3,k4; 954 979 for(k4=0; k4<size_[4]; k4++) { 955 980 if (size_[4] > 1) cout << "\n ----- Dimension 5 (U) K4= " << k4 << endl; … … 963 988 if(k0 > 0) os << ", "; 964 989 os << Elem(k0, k1, k2, k3, k4); npr++; 965 if (npr >= ( uint_4) maxprt) {990 if (npr >= (sa_size_t) maxprt) { 966 991 if (npr < totsize_) os << "\n .... " << endl; return; 967 992 }
Note:
See TracChangeset
for help on using the changeset viewer.