Changeset 1156 in Sophya for trunk/SophyaLib/TArray/tarray.cc


Ignore:
Timestamp:
Aug 29, 2000, 6:10:32 PM (25 years ago)
Author:
ansari
Message:

Introduction du type sa_size_t (taille des tableaux), operateur - (TArray::operator - et NegateElt()) - Reza 29/8/2000

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/TArray/tarray.cc

    r1113 r1156  
    3939 */
    4040template <class T>
    41 TArray<T>::TArray(uint_4 ndim, const uint_4 * siz, uint_4 step)
     41TArray<T>::TArray(int_4 ndim, const sa_size_t * siz, sa_size_t step)
    4242  : BaseArray() , mNDBlock(ComputeTotalSize(ndim, siz, step, 1))
    4343{
    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)";
    4545  if (!UpdateSizes(ndim, siz, step, 0, exmsg))  throw( ParmError(exmsg) );
    4646}
    … …  
    5151 */
    5252template <class T>
    53 TArray<T>::TArray(uint_4 nx, uint_4 ny, uint_4 nz, uint_4 nt, uint_4 nu)
     53TArray<T>::TArray(sa_size_t nx, sa_size_t ny, sa_size_t nz, sa_size_t nt, sa_size_t nu)
    5454  : BaseArray() , mNDBlock(nx*((ny>0)?ny:1)*((nz>0)?nz:1)*((nt>0)?nt:1)*((nu>0)?nu:1))
    5555{
    56   uint_4 size[BASEARRAY_MAXNDIMS];
     56  sa_size_t size[BASEARRAY_MAXNDIMS];
    5757  size[0] = nx;   size[1] = ny;   size[2] = nz;
    5858  size[3] = nt;   size[4] = nu;
    59   int ndim = 1;
     59  int_4 ndim = 1;
    6060  if ((size[1] > 0) && (size[2] > 0) && (size[3] > 0) && (size[4] > 0) ) ndim = 5;
    6161  else if ((size[1] > 0) && (size[2] > 0) && (size[3] > 0) ) ndim = 4;
    … …  
    6363  else if (size[1] > 0)  ndim = 2;
    6464  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)";
    6666  if (!UpdateSizes(ndim, size, 1, 0, exmsg))  throw( ParmError(exmsg) );
    6767}
    … …  
    7777 */
    7878template <class T>
    79 TArray<T>::TArray(uint_4 ndim, const uint_4 * siz, NDataBlock<T> & db, bool share, uint_4 step, uint_8 offset)
     79TArray<T>::TArray(int_4 ndim, const sa_size_t * siz, NDataBlock<T> & db, bool share, sa_size_t step, sa_size_t offset)
    8080  : BaseArray() , mNDBlock(db, share)
    8181{
    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> & ... )";
    8383  if (!UpdateSizes(ndim, siz, step, offset, exmsg))  throw( ParmError(exmsg) );
    8484 
    … …  
    9797 */
    9898template <class T>
    99 TArray<T>::TArray(uint_4 ndim, const uint_4 * siz, T* values, uint_4 step, uint_8 offset, Bridge* br)
     99TArray<T>::TArray(int_4 ndim, const sa_size_t * siz, T* values, sa_size_t step, sa_size_t offset, Bridge* br)
    100100  : BaseArray() , mNDBlock(ComputeTotalSize(ndim, siz, step, 1), values, br)
    101101{
    102   string exmsg = "TArray<T>::TArray(uint_4, uint_4 *, T* ... )";
     102  string exmsg = "TArray<T>::TArray(int_4, sa_size_t *, T* ... )";
    103103  if (!UpdateSizes(ndim, siz, step, offset, exmsg))  throw( ParmError(exmsg) );
    104104}
    … …  
    225225 */
    226226template <class T>
    227 void TArray<T>::ReSize(uint_4 ndim, uint_4 * siz, uint_4 step)
     227void TArray<T>::ReSize(int_4 ndim, sa_size_t * siz, sa_size_t step)
    228228{
    229229  if (arrtype_ != 0) {
    … …  
    247247 */
    248248template <class T>
    249 void TArray<T>::Realloc(uint_4 ndim, uint_4 * siz, uint_4 step, bool force)
     249void TArray<T>::Realloc(int_4 ndim, sa_size_t * siz, sa_size_t step, bool force)
    250250{
    251251  if (arrtype_ != 0) {
    … …  
    279279//! Give value (in \b double) for element at position \b ip..
    280280template <class T>
    281 MuTyV & TArray<T>::ValueAtPosition(uint_8 ip) const
     281MuTyV & TArray<T>::ValueAtPosition(sa_size_t ip) const
    282282{
    283283#ifdef SO_BOUNDCHECKING
    284   if (ip >= totsize_)  throw( ParmError("TArray<T>::ValueAtPosition(uint_8 ip) Out-of-bound Error") );
     284  if (ip >= totsize_)  throw( ParmError("TArray<T>::ValueAtPosition(sa_size_t ip) Out-of-bound Error") );
    285285#endif
    286286  my_mtv = *(mNDBlock.Begin()+Offset(ip));
    … …  
    326326  if (NbDimensions() < 1)
    327327    throw RangeCheckError("TArray<T>::operator () (Range, ...) - Not Allocated Array ! ");
    328   uint_4 ndim = 0;
    329   uint_4 size[BASEARRAY_MAXNDIMS];
    330   uint_4 step[BASEARRAY_MAXNDIMS];
    331   uint_4 pos[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];
    332332  size[0] = rx.Size();
    333333  size[1] = ry.Size();
    … …  
    373373 
    374374  T * pe;
    375   uint_8 j,k;
    376   int ka;
     375  sa_size_t j,k;
     376  int_4 ka;
    377377  if (arrtype_ == 0)  ka = 0;
    378378  else ka = macoli_;
    379   uint_8 step = Step(ka);
    380   uint_8 gpas = Size(ka);
    381   uint_8 naxa = 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);
    382382  for(j=0; j<naxa; j++)  {
    383383    pe = mNDBlock.Begin()+Offset(ka,j);
    … …  
    401401    throw RangeCheckError("TArray<T>::SetT(T )  - Not Allocated Array ! ");
    402402  T * pe;
    403   uint_8 j,k;
     403  sa_size_t j,k;
    404404  if (AvgStep() > 0)   {  // regularly spaced elements
    405     uint_8 step = AvgStep();
    406     uint_8 maxx = totsize_*step;
     405    sa_size_t step = AvgStep();
     406    sa_size_t maxx = totsize_*step;
    407407    pe = Data();
    408408    for(k=0; k<maxx; k+=step )  pe[k] = x;
    409409  }
    410410  else {    // Non regular data spacing ...
    411     uint_4 ka = MaxSizeKA();
    412     uint_8 step = Step(ka);
    413     uint_8 gpas = Size(ka)*step;
    414     uint_8 naxa = 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);
    415415    for(j=0; j<naxa; j++)  {
    416416      pe = mNDBlock.Begin()+Offset(ka,j);
    … …  
    428428    throw RangeCheckError("TArray<T>::Add(T )  - Not Allocated Array ! ");
    429429  T * pe;
    430   uint_8 j,k;
     430  sa_size_t j,k;
    431431  if (AvgStep() > 0)   {  // regularly spaced elements
    432     uint_8 step = AvgStep();
    433     uint_8 maxx = totsize_*step;
     432    sa_size_t step = AvgStep();
     433    sa_size_t maxx = totsize_*step;
    434434    pe = Data();
    435435    for(k=0; k<maxx; k+=step )  pe[k] += x;
    436436  }
    437437  else {    // Non regular data spacing ...
    438     uint_4 ka = MaxSizeKA();
    439     uint_8 step = Step(ka);
    440     uint_8 gpas = Size(ka)*step;
    441     uint_8 naxa = 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);
    442442    for(j=0; j<naxa; j++)  {
    443443      pe = mNDBlock.Begin()+Offset(ka,j);
    … …  
    459459    throw RangeCheckError("TArray<T>::Sub(T )  - Not Allocated Array ! ");
    460460  T * pe;
    461   uint_8 j,k;
     461  sa_size_t j,k;
    462462  if (AvgStep() > 0)   {  // regularly spaced elements
    463     uint_8 step = AvgStep();
    464     uint_8 maxx = totsize_*step;
     463    sa_size_t step = AvgStep();
     464    sa_size_t maxx = totsize_*step;
    465465    pe = Data();
    466466    if (fginv)
    … …  
    470470  }
    471471  else {    // Non regular data spacing ...
    472     uint_4 ka = MaxSizeKA();
    473     uint_8 step = Step(ka);
    474     uint_8 gpas = Size(ka)*step;
    475     uint_8 naxa = 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);
    476476    for(j=0; j<naxa; j++)  {
    477477      pe = mNDBlock.Begin()+Offset(ka,j);
    … …  
    492492    throw RangeCheckError("TArray<T>::Mul(T )  - Not Allocated Array ! ");
    493493  T * pe;
    494   uint_8 j,k;
     494  sa_size_t j,k;
    495495  if (AvgStep() > 0)   {  // regularly spaced elements
    496     uint_8 step = AvgStep();
    497     uint_8 maxx = totsize_*step;
     496    sa_size_t step = AvgStep();
     497    sa_size_t maxx = totsize_*step;
    498498    pe = Data();
    499499    for(k=0; k<maxx; k+=step )  pe[k] *= x;
    500500  }
    501501  else {    // Non regular data spacing ...
    502     uint_4 ka = MaxSizeKA();
    503     uint_8 step = Step(ka);
    504     uint_8 gpas = Size(ka)*step;
    505     uint_8 naxa = 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);
    506506    for(j=0; j<naxa; j++)  {
    507507      pe = mNDBlock.Begin()+Offset(ka,j);
    … …  
    525525    throw MathExc("TArray<T>::Div(T )  - Divide by zero ! ");
    526526  T * pe;
    527   uint_8 j,k;
     527  sa_size_t j,k;
    528528  if (AvgStep() > 0)   {  // regularly spaced elements
    529     uint_8 step = AvgStep();
    530     uint_8 maxx = totsize_*step;
     529    sa_size_t step = AvgStep();
     530    sa_size_t maxx = totsize_*step;
    531531    pe = Data();
    532532    if (fginv)
    … …  
    536536  }
    537537  else {    // Non regular data spacing ...
    538     uint_4 ka = MaxSizeKA();
    539     uint_8 step = Step(ka);
    540     uint_8 gpas = Size(ka)*step;
    541     uint_8 naxa = 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);
    542542    for(j=0; j<naxa; j++)  {
    543543      pe = mNDBlock.Begin()+Offset(ka,j);
    … …  
    552552
    553553
    554 
     554//! Replace array elements values by their opposite ( a(i) -> -a(i) )
     555template <class T>
     556TArray<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}
    555580
    556581//  >>>> Operations avec 2nd membre de type tableau
    … …  
    567592  T * pe;
    568593  const T * pea;
    569   uint_8 j,k,ka;
     594  sa_size_t j,k,ka;
    570595  if (smo && (AvgStep() > 0) && (a.AvgStep() > 0))   {  // regularly spaced elements
    571     uint_8 step = AvgStep();
    572     uint_8 stepa = a.AvgStep();
    573     uint_8 maxx = totsize_*step;
     596    sa_size_t step = AvgStep();
     597    sa_size_t stepa = a.AvgStep();
     598    sa_size_t maxx = totsize_*step;
    574599    pe = Data();
    575600    pea = a.Data();
    … …  
    577602  }
    578603  else {    // Non regular data spacing ...
    579     int ax,axa;
    580     uint_8 step, stepa;
    581     uint_8 gpas, naxa;
     604    int_4 ax,axa;
     605    sa_size_t step, stepa;
     606    sa_size_t gpas, naxa;
    582607    GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa);
    583608    for(j=0; j<naxa; j++)  {
    … …  
    606631  T * pe;
    607632  const T * pea;
    608   uint_8 j,k,ka;
     633  sa_size_t j,k,ka;
    609634  if (smo && (AvgStep() > 0) && (a.AvgStep() > 0) )   {  // regularly spaced elements
    610     uint_8 step = AvgStep();
    611     uint_8 stepa = a.AvgStep();
    612     uint_8 maxx = totsize_*step;
     635    sa_size_t step = AvgStep();
     636    sa_size_t stepa = a.AvgStep();
     637    sa_size_t maxx = totsize_*step;
    613638    pe = Data();
    614639    pea = a.Data();
    … …  
    619644  }
    620645  else {    // Non regular data spacing ...
    621     int ax,axa;
    622     uint_8 step, stepa;
    623     uint_8 gpas, naxa;
     646    int_4 ax,axa;
     647    sa_size_t step, stepa;
     648    sa_size_t gpas, naxa;
    624649    GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa);
    625650    for(j=0; j<naxa; j++)  {
    … …  
    648673  T * pe;
    649674  const T * pea;
    650   uint_8 j,k,ka;
     675  sa_size_t j,k,ka;
    651676  if (smo && (AvgStep() > 0) && (a.AvgStep() > 0) )   {  // regularly spaced elements
    652     uint_8 step = AvgStep();
    653     uint_8 stepa = a.AvgStep();
    654     uint_8 maxx = totsize_*step;
     677    sa_size_t step = AvgStep();
     678    sa_size_t stepa = a.AvgStep();
     679    sa_size_t maxx = totsize_*step;
    655680    pe = Data();
    656681    pea = a.Data();
    … …  
    658683  }
    659684  else {    // Non regular data spacing ...
    660     int ax,axa;
    661     uint_8 step, stepa;
    662     uint_8 gpas, naxa;
     685    int_4 ax,axa;
     686    sa_size_t step, stepa;
     687    sa_size_t gpas, naxa;
    663688    GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa);
    664689    for(j=0; j<naxa; j++)  {
    … …  
    689714  T * pe;
    690715  const T * pea;
    691   uint_8 j,k,ka;
     716  sa_size_t j,k,ka;
    692717  if (smo && (AvgStep() > 0) && (a.AvgStep() > 0) )   {  // regularly spaced elements
    693     uint_8 step = AvgStep();
    694     uint_8 stepa = a.AvgStep();
    695     uint_8 maxx = totsize_*step;
     718    sa_size_t step = AvgStep();
     719    sa_size_t stepa = a.AvgStep();
     720    sa_size_t maxx = totsize_*step;
    696721    pe = Data();
    697722    pea = a.Data();
    … …  
    711736  }
    712737  else {    // Non regular data spacing ...
    713     int ax,axa;
    714     uint_8 step, stepa;
    715     uint_8 gpas, naxa;
     738    int_4 ax,axa;
     739    sa_size_t step, stepa;
     740    sa_size_t gpas, naxa;
    716741    GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa);
    717742    for(j=0; j<naxa; j++)  {
    … …  
    748773  T * pe;
    749774  const T * pea;
    750   uint_8 j,k,ka;
     775  sa_size_t j,k,ka;
    751776  if (smo && (AvgStep() > 0) && (a.AvgStep() > 0) )   {  // regularly spaced elements
    752     uint_8 step = AvgStep();
    753     uint_8 stepa = a.AvgStep();
    754     uint_8 maxx = totsize_*step;
     777    sa_size_t step = AvgStep();
     778    sa_size_t stepa = a.AvgStep();
     779    sa_size_t maxx = totsize_*step;
    755780    pe = Data();
    756781    pea = a.Data();
    … …  
    758783  }
    759784  else {    // Non regular data spacing ...
    760     int ax,axa;
    761     uint_8 step, stepa;
    762     uint_8 gpas, naxa;
     785    int_4 ax,axa;
     786    sa_size_t step, stepa;
     787    sa_size_t gpas, naxa;
    763788    GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa);
    764789    for(j=0; j<naxa; j++)  {
    … …  
    782807
    783808  T * pe;
    784   uint_8 j,k,ka;
    785   uint_8 offa;
     809  sa_size_t j,k,ka;
     810  sa_size_t offa;
    786811  // Non regular data spacing ...
    787   int ax,axa;
    788   uint_8 step, stepa;
    789   uint_8 gpas, naxa;
     812  int_4 ax,axa;
     813  sa_size_t step, stepa;
     814  sa_size_t gpas, naxa;
    790815  GetOpeParams(a, smo, ax, axa, step, stepa, gpas, naxa);
    791816  for(j=0; j<naxa; j++)  {
    … …  
    812837  T ret=0;
    813838  const T * pe;
    814   uint_8 j,k;
     839  sa_size_t j,k;
    815840  if (AvgStep() > 0)   {  // regularly spaced elements
    816     uint_8 step = AvgStep();
    817     uint_8 maxx = totsize_*step;
     841    sa_size_t step = AvgStep();
     842    sa_size_t maxx = totsize_*step;
    818843    pe = Data();
    819844    for(k=0; k<maxx; k+=step )  ret += pe[k];
    820845  }
    821846  else {    // Non regular data spacing ...
    822     uint_4 ka = MaxSizeKA();
    823     uint_8 step = Step(ka);
    824     uint_8 gpas = Size(ka)*step;
    825     uint_8 naxa = 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);
    826851    for(j=0; j<naxa; j++)  {
    827852      pe = mNDBlock.Begin()+Offset(ka,j);
    … …  
    840865  T ret=(T)1;
    841866  const T * pe;
    842   uint_8 j,k;
     867  sa_size_t j,k;
    843868  if (AvgStep() > 0)   {  // regularly spaced elements
    844     uint_8 step = AvgStep();
    845     uint_8 maxx = totsize_*step;
     869    sa_size_t step = AvgStep();
     870    sa_size_t maxx = totsize_*step;
    846871    pe = Data();
    847872    for(k=0; k<maxx; k+=step )  ret *= pe[k];
    848873  }
    849874  else {    // Non regular data spacing ...
    850     uint_4 ka = MaxSizeKA();
    851     uint_8 step = Step(ka);
    852     uint_8 gpas = Size(ka)*step;
    853     uint_8 naxa = 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);
    854879    for(j=0; j<naxa; j++)  {
    855880      pe = mNDBlock.Begin()+Offset(ka,j);
    … …  
    868893  T ret=0;
    869894  const T * pe;
    870   uint_8 j,k;
     895  sa_size_t j,k;
    871896  if (AvgStep() > 0)   {  // regularly spaced elements
    872     uint_8 step = AvgStep();
    873     uint_8 maxx = totsize_*step;
     897    sa_size_t step = AvgStep();
     898    sa_size_t maxx = totsize_*step;
    874899    pe = Data();
    875900    for(k=0; k<maxx; k+=step )  ret += pe[k]*pe[k];
    876901  }
    877902  else {    // Non regular data spacing ...
    878     uint_4 ka = MaxSizeKA();
    879     uint_8 step = Step(ka);
    880     uint_8 gpas = Size(ka)*step;
    881     uint_8 naxa = 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);
    882907    for(j=0; j<naxa; j++)  {
    883908      pe = mNDBlock.Begin()+Offset(ka,j);
    … …  
    896921{
    897922  const T * pe;
    898   uint_8 j,k;
    899   uint_4 ka = MaxSizeKA();
    900   uint_8 step = Step(ka);
    901   uint_8 gpas = Size(ka)*step;
    902   uint_8 naxa = 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);
    903928  min = (*this)[0];
    904929  max = (*this)[0];
    … …  
    948973{
    949974  if (maxprt < 0)  maxprt = max_nprt_;
    950   uint_4 npr = 0;
     975  sa_size_t npr = 0;
    951976  Show(os, si);
    952977  if (ndim_ < 1) return;
    953   uint_4 k0,k1,k2,k3,k4;
     978  sa_size_t k0,k1,k2,k3,k4;
    954979  for(k4=0; k4<size_[4]; k4++) {
    955980    if (size_[4] > 1) cout << "\n ----- Dimension 5 (U) K4= " << k4 << endl;
    … …  
    963988            if(k0 > 0) os << ", "; 
    964989            os << Elem(k0, k1, k2, k3, k4);     npr++;
    965             if (npr >= (uint_4) maxprt) {
     990            if (npr >= (sa_size_t) maxprt) {
    966991              if (npr < totsize_)  os << "\n     .... " << endl; return;
    967992            }
Note: See TracChangeset for help on using the changeset viewer.