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


Ignore:
Timestamp:
Apr 3, 2000, 7:36:01 PM (25 years ago)
Author:
ansari
Message:

Amelioation / debugging de la classe TArray<T> - TVector et TMatrix

heritent maintenant de TArray<T> - Classe RCMatrix rendu prive au fichier
sopemtx.cc - linfit.cc integre a sopemtx.cc

Reza 03/04/2000

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/TArray/tarray.cc

    r787 r804  
    1818template <class T>
    1919TArray<T>::TArray()
    20   : mNDBlock() , BaseArray()
     20  : BaseArray() , mNDBlock()
    2121// Default constructor
    2222{
    … …  
    2424
    2525template <class T>
    26 TArray<T>::TArray(uint_4 ndim, uint_4 * siz, uint_4 step)
    27   : mNDBlock(ComputeTotalSize(ndim, siz, step, 1)) , BaseArray()
     26TArray<T>::TArray(uint_4 ndim, const uint_4 * siz, uint_4 step)
     27  : BaseArray() , mNDBlock(ComputeTotalSize(ndim, siz, step, 1))
    2828{
    2929  string exmsg = "TArray<T>::TArray(uint_4, uint_4 *, uint_4)";
    … …  
    3232
    3333template <class T>
    34 TArray<T>::TArray(uint_4 nx, uint_4 ny=1, uint_4 nz=1)
    35   : mNDBlock(nx*((ny>0)?ny:1)*((nz>0)?nz:1)) , BaseArray()
     34TArray<T>::TArray(uint_4 nx, uint_4 ny, uint_4 nz, uint_4 nt, uint_4 nu)
     35  : BaseArray() , mNDBlock(nx*((ny>0)?ny:1)*((nz>0)?nz:1)*((nt>0)?nt:1)*((nu>0)?nu:1))
    3636{
    3737  uint_4 size[BASEARRAY_MAXNDIMS];
    3838  size[0] = nx;   size[1] = ny;   size[2] = nz;
     39  size[3] = nt;   size[4] = nu;
    3940  int ndim = 1;
    40   if ((size[1] > 0) && (size[2] > 0)) ndim = 3;
     41  if ((size[1] > 0) && (size[2] > 0) && (size[3] > 0) && (size[4] > 0) ) ndim = 5;
     42  else if ((size[1] > 0) && (size[2] > 0) && (size[3] > 0) ) ndim = 4;
     43  else if ((size[1] > 0) && (size[2] > 0)) ndim = 3;
    4144  else if (size[1] > 0)  ndim = 2;
    4245  else ndim = 1;
    … …  
    4649
    4750template <class T>
    48 TArray<T>::TArray(uint_4 ndim, uint_4 * siz, NDataBlock<T> & db, bool share, uint_4 step, uint_8 offset)
    49   : mNDBlock(db, share) , BaseArray()
     51TArray<T>::TArray(uint_4 ndim, const uint_4 * siz, NDataBlock<T> & db, bool share, uint_4 step, uint_8 offset)
     52  : BaseArray() , mNDBlock(db, share)
    5053{
    5154  string exmsg = "TArray<T>::TArray(uint_4, uint_4 *,  NDataBlock<T> & ... )";
    … …  
    5558
    5659template <class T>
    57 TArray<T>::TArray(uint_4 ndim, uint_4 * siz, T* values, uint_4 step, uint_8 offset, Bridge* br)
    58   : mNDBlock(ComputeTotalSize(ndim, siz, step, 1), values, br) , BaseArray()
     60TArray<T>::TArray(uint_4 ndim, const uint_4 * siz, T* values, uint_4 step, uint_8 offset, Bridge* br)
     61  : BaseArray() , mNDBlock(ComputeTotalSize(ndim, siz, step, 1), values, br)
    5962{
    6063  string exmsg = "TArray<T>::TArray(uint_4, uint_4 *, T* ... )";
    … …  
    6467template <class T>
    6568TArray<T>::TArray(const TArray<T>& a)
    66   : mNDBlock(a.mNDBlock) , BaseArray()
     69  : BaseArray() , mNDBlock(a.mNDBlock)
    6770{
    6871  string exmsg = "TArray<T>::TArray(const TArray<T>&)";
    … …  
    7376template <class T>
    7477TArray<T>::TArray(const TArray<T>& a, bool share)
    75   : mNDBlock(a.mNDBlock, share) , BaseArray()
     78  : BaseArray() , mNDBlock(a.mNDBlock, share)
    7679{
    7780  string exmsg = "TArray<T>::TArray(const TArray<T>&, bool)";
    … …  
    8790
    8891template <class T>
    89 TArray<T>& TArray<T>::operator = (const TArray<T>& a)
     92TArray<T>& TArray<T>::Set(const TArray<T>& a)
    9093{
    9194  if (this != &a) {
    … …  
    171174
    172175
     176template <class T>
     177TArray<T> TArray<T>::PackElements(bool force) const
     178{
     179  if (NbDimensions() < 1)
     180    throw RangeCheckError("TArray<T>::PackElements() - Not Allocated Array ! ");
     181  if ( !force && (AvgStep() == 1) ) {
     182    TArray<T> ra(*this, true);
     183    ra.SetTemp(true);
     184    return(ra);
     185  }
     186  else {
     187    TArray<T> ra(ndim_, size_, 1);
     188    ra.CopyElt(*this);
     189    ra.SetTemp(true);
     190    return(ra);
     191  }
     192}
     193
    173194// SubArrays
    174 template <class T>
    175 TArray<T> TArray<T>::operator () (Range rx, Range ry, Range rz, Range rt, Range ru)
    176 {
     195// $CHECK$ Reza 03/2000  Doit-on declarer cette methode const ?
     196template <class T>
     197TArray<T> TArray<T>::SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const
     198{
     199  if (NbDimensions() < 1)
     200    throw RangeCheckError("TArray<T>::operator () (Range, ...) - Not Allocated Array ! ");
    177201  uint_4 ndim = 0;
    178202  uint_4 size[BASEARRAY_MAXNDIMS];
    … …  
    199223  ndim = ndim_;
    200224  TArray<T> ra;
    201   SubArray(ra, ndim, size, pos, step);
     225  UpdateSubArraySizes(ra, ndim, size, pos, step);
    202226  ra.DataBlock().Share(this->DataBlock());
    203227  ra.SetTemp(true);
    … …  
    210234//  Possibilite de // , vectorisation
    211235template <class T>
    212 TArray<T>& TArray<T>::operator = (Sequence seq)
    213 {
     236TArray<T>& TArray<T>::Set(Sequence seq)
     237{
     238  if (NbDimensions() < 1)
     239    throw RangeCheckError("TArray<T>::Set(Sequence ) - Not Allocated Array ! ");
    214240  T * pe;
    215241  uint_8 j,k;
    … …  
    234260
    235261template <class T>
    236 TArray<T>& TArray<T>::operator = (T x)
    237 {
     262TArray<T>& TArray<T>::Set(T x)
     263{
     264  if (NbDimensions() < 1)
     265    throw RangeCheckError("TArray<T>::Set(T )  - Not Allocated Array ! ");
    238266  T * pe;
    239267  uint_8 j,k;
    … …  
    257285
    258286template <class T>
    259 TArray<T>& TArray<T>::operator += (T x)
    260 {
     287TArray<T>& TArray<T>::Add(T x)
     288{
     289  if (NbDimensions() < 1)
     290    throw RangeCheckError("TArray<T>::Add(T )  - Not Allocated Array ! ");
    261291  T * pe;
    262292  uint_8 j,k;
    … …  
    280310
    281311template <class T>
    282 TArray<T>& TArray<T>::operator -= (T x)
    283 {
     312TArray<T>& TArray<T>::Sub(T x)
     313{
     314  if (NbDimensions() < 1)
     315    throw RangeCheckError("TArray<T>::Sub(T )  - Not Allocated Array ! ");
    284316  T * pe;
    285317  uint_8 j,k;
    … …  
    303335
    304336template <class T>
    305 TArray<T>& TArray<T>::operator *= (T x)
    306 {
     337TArray<T>& TArray<T>::Mul(T x)
     338{
     339  if (NbDimensions() < 1)
     340    throw RangeCheckError("TArray<T>::Mul(T )  - Not Allocated Array ! ");
    307341  T * pe;
    308342  uint_8 j,k;
    … …  
    326360
    327361template <class T>
    328 TArray<T>& TArray<T>::operator /= (T x)
    329 {
     362TArray<T>& TArray<T>::Div(T x)
     363{
     364  if (NbDimensions() < 1)
     365    throw RangeCheckError("TArray<T>::Div(T )  - Not Allocated Array ! ");
    330366  T * pe;
    331367  uint_8 j,k;
    … …  
    349385
    350386
     387template <class T>
     388TArray<T>& TArray<T>::SubInv(T x)
     389{
     390  if (NbDimensions() < 1)
     391    throw RangeCheckError("TArray<T>::SubInv(T )  - Not Allocated Array ! ");
     392  T * pe;
     393  uint_8 j,k;
     394  if (AvgStep() > 0)   {  // regularly spaced elements
     395    uint_8 step = AvgStep();
     396    uint_8 maxx = totsize_*step;
     397    pe = Data();
     398    for(k=0; k<maxx; k+=step )  pe[k] = x-pe[k];
     399  }
     400  else {    // Non regular data spacing ...
     401    uint_4 ka = MaxSizeKA();
     402    uint_8 step = Step(ka);
     403    uint_8 gpas = Size(ka)*step;
     404    for(j=0; j<totsize_; j += Size(ka))  {
     405      pe = mNDBlock.Begin()+Offset(j);
     406      for(k=0; k<gpas; k+=step)  pe[k] = x-pe[k];
     407    }
     408  }
     409  return(*this);
     410}
     411
     412template <class T>
     413TArray<T>& TArray<T>::DivInv(T x)
     414{
     415  if (NbDimensions() < 1)
     416    throw RangeCheckError("TArray<T>::DivInv(T )  - Not Allocated Array ! ");
     417  T * pe;
     418  uint_8 j,k;
     419  if (AvgStep() > 0)   {  // regularly spaced elements
     420    uint_8 step = AvgStep();
     421    uint_8 maxx = totsize_*step;
     422    pe = Data();
     423    for(k=0; k<maxx; k+=step )  pe[k] = x/pe[k];
     424  }
     425  else {    // Non regular data spacing ...
     426    uint_4 ka = MaxSizeKA();
     427    uint_8 step = Step(ka);
     428    uint_8 gpas = Size(ka)*step;
     429    for(j=0; j<totsize_; j += Size(ka))  {
     430      pe = mNDBlock.Begin()+Offset(j);
     431      for(k=0; k<gpas; k+=step)  pe[k] = x/pe[k];
     432    }
     433  }
     434  return(*this);
     435}
     436
     437
    351438//  >>>> Operations avec 2nd membre de type tableau
    352439template <class T>
    353 TArray<T>& TArray<T>::operator += (const TArray<T>& a)
    354 {
    355   if (!CompareSizes(a)) throw(SzMismatchError("TArray<T>::operator += (const TArray<T>&)")) ;
     440TArray<T>& TArray<T>::AddElt(const TArray<T>& a)
     441{
     442  if (NbDimensions() < 1)
     443    throw RangeCheckError("TArray<T>::AddElt(const TArray<T>& )  - Not Allocated Array ! ");
     444  if (!CompareSizes(a)) throw(SzMismatchError("TArray<T>::AddElt(const TArray<T>&)")) ;
    356445
    357446  T * pe;
    … …  
    381470
    382471template <class T>
    383 TArray<T>& TArray<T>::operator -= (const TArray<T>& a)
    384 {
    385   if (!CompareSizes(a)) throw(SzMismatchError("TArray<T>::operator -= (const TArray<T>&)")) ;
     472TArray<T>& TArray<T>::SubElt(const TArray<T>& a)
     473{
     474  if (NbDimensions() < 1)
     475    throw RangeCheckError("TArray<T>::SubElt(const TArray<T>& )  - Not Allocated Array ! ");
     476  if (!CompareSizes(a)) throw(SzMismatchError("TArray<T>::SubElt(const TArray<T>&)")) ;
    386477
    387478  T * pe;
    … …  
    412503
    413504template <class T>
    414 TArray<T>& TArray<T>::MultElt(const TArray<T>& a)
    415 {
    416   if (!CompareSizes(a)) throw(SzMismatchError("TArray<T>::MultElt(const TArray<T>&)")) ;
     505TArray<T>& TArray<T>::MulElt(const TArray<T>& a)
     506{
     507  if (NbDimensions() < 1)
     508    throw RangeCheckError("TArray<T>::MulElt(const TArray<T>& )  - Not Allocated Array ! ");
     509  if (!CompareSizes(a)) throw(SzMismatchError("TArray<T>::MulElt(const TArray<T>&)")) ;
    417510
    418511  T * pe;
    … …  
    441534}
    442535
     536
    443537template <class T>
    444538TArray<T>& TArray<T>::DivElt(const TArray<T>& a)
    445539{
     540  if (NbDimensions() < 1)
     541    throw RangeCheckError("TArray<T>::DivElt(const TArray<T>& )  - Not Allocated Array ! ");
    446542  if (!CompareSizes(a)) throw(SzMismatchError("TArray<T>::DivElt(const TArray<T>&)")) ;
    447543
    … …  
    471567}
    472568
     569template <class T>
     570TArray<T>& TArray<T>::CopyElt(const TArray<T>& a)
     571{
     572  if (NbDimensions() < 1)
     573    throw RangeCheckError("TArray<T>::CopyElt(const TArray<T>& )  - Not Allocated Array ! ");
     574  if (!CompareSizes(a)) throw(SzMismatchError("TArray<T>::MultElt(const TArray<T>&)")) ;
     575
     576  T * pe;
     577  const T * pea;
     578  uint_8 j,k,ka;
     579  if ((AvgStep() > 0) && (a.AvgStep() > 0) )   {  // regularly spaced elements
     580    uint_8 step = AvgStep();
     581    uint_8 stepa = a.AvgStep();
     582    uint_8 maxx = totsize_*step;
     583    pe = Data();
     584    pea = a.Data();
     585    for(k=0, ka=0;  k<maxx;  k+=step, ka+=stepa )  pe[k] = pea[ka] ;
     586  }
     587  else {    // Non regular data spacing ...
     588    uint_4 ax = MaxSizeKA();
     589    uint_8 step = Step(ax);
     590    uint_8 stepa = a.Step(ax);
     591    uint_8 gpas = Size(ax)*step;
     592    for(j=0; j<totsize_; j += Size(ax))  {
     593      pe = mNDBlock.Begin()+Offset(j);
     594      pea = a.DataBlock().Begin()+a.Offset(j);
     595      for(k=0, ka=0;  k<gpas;  k+=step, ka+=stepa)  pe[k] = pea[ka];
     596    }
     597  }
     598  return(*this);
     599}
     600
     601
     602// Somme et produit des elements
     603template <class T>
     604T TArray<T>::Sum() const
     605{
     606  if (NbDimensions() < 1)
     607    throw RangeCheckError("TArray<T>::Sum()  - Not Allocated Array ! ");
     608  T ret=0;
     609  const T * pe;
     610  uint_8 j,k;
     611  if (AvgStep() > 0)   {  // regularly spaced elements
     612    uint_8 step = AvgStep();
     613    uint_8 maxx = totsize_*step;
     614    pe = Data();
     615    for(k=0; k<maxx; k+=step )  ret += pe[k];
     616  }
     617  else {    // Non regular data spacing ...
     618    uint_4 ka = MaxSizeKA();
     619    uint_8 step = Step(ka);
     620    uint_8 gpas = Size(ka)*step;
     621    for(j=0; j<totsize_; j += Size(ka))  {
     622      pe = mNDBlock.Begin()+Offset(j);
     623      for(k=0; k<gpas; k+=step)  ret += pe[k] ;
     624    }
     625  }
     626  return ret;
     627}
     628
     629template <class T>
     630T TArray<T>::Product() const
     631{
     632  if (NbDimensions() < 1)
     633    throw RangeCheckError("TArray<T>::Product()  - Not Allocated Array ! ");
     634  T ret=0;
     635  const T * pe;
     636  uint_8 j,k;
     637  if (AvgStep() > 0)   {  // regularly spaced elements
     638    uint_8 step = AvgStep();
     639    uint_8 maxx = totsize_*step;
     640    pe = Data();
     641    for(k=0; k<maxx; k+=step )  ret *= pe[k];
     642  }
     643  else {    // Non regular data spacing ...
     644    uint_4 ka = MaxSizeKA();
     645    uint_8 step = Step(ka);
     646    uint_8 gpas = Size(ka)*step;
     647    for(j=0; j<totsize_; j += Size(ka))  {
     648      pe = mNDBlock.Begin()+Offset(j);
     649      for(k=0; k<gpas; k+=step)  ret *= pe[k] ;
     650    }
     651  }
     652  return ret;
     653}
     654
     655
    473656
    474657// ----------------------------------------------------
    … …  
    487670{
    488671  if (maxprt < 0)  maxprt = max_nprt_;
    489   uint_4 npr = 0;
     672  int_4 npr = 0;
    490673  Show(os, si);
    491   int k0,k1,k2,k3,k4;
     674  uint_4 k0,k1,k2,k3,k4;
    492675  for(k4=0; k4<size_[4]; k4++) {
    493676    if (size_[4] > 1) cout << "\n ----- Dimension 5 (U) K4= " << k4 << endl;
    … …  
    535718///////////////////////////////////////////////////////////////
    536719#ifdef __CXX_PRAGMA_TEMPLATES__
     720/*
    537721#pragma define_template TArray<uint_1>
     722#pragma define_template TArray<int_2>
     723#pragma define_template TArray<uint_4>
     724#pragma define_template TArray<uint_8>
     725*/
    538726#pragma define_template TArray<uint_2>
    539 #pragma define_template TArray<int_2>
    540727#pragma define_template TArray<int_4>
    541728#pragma define_template TArray<int_8>
    542 #pragma define_template TArray<uint_4>
    543 #pragma define_template TArray<uint_8>
    544729#pragma define_template TArray<r_4>
    545730#pragma define_template TArray<r_8>
    … …  
    549734
    550735#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
    551 template class TArray<uint_1>;
     736/*
     737template class TArray<uint_1>;
     738template class TArray<int_2>; 
     739template class TArray<uint_4>;
     740template class TArray<uint_8>;
     741*/
    552742template class TArray<uint_2>;
    553 template class TArray<int_2>;
    554743template class TArray<int_4>;
    555744template class TArray<int_8>;
    556 template class TArray<uint_4>;
    557 template class TArray<uint_8>;
    558745template class TArray<r_4>;
    559746template class TArray<r_8>;
Note: See TracChangeset for help on using the changeset viewer.