| 1 | // This may look like C code, but it is really -*- C++ -*-
|
|---|
| 2 | // template array class for numerical types
|
|---|
| 3 | // R. Ansari, C.Magneville 03/2000
|
|---|
| 4 |
|
|---|
| 5 | #ifndef TArray_SEEN
|
|---|
| 6 | #define TArray_SEEN
|
|---|
| 7 |
|
|---|
| 8 | #include "machdefs.h"
|
|---|
| 9 | #include <math.h>
|
|---|
| 10 | #include <iostream.h>
|
|---|
| 11 | #include "ndatablock.h"
|
|---|
| 12 | #include <complex>
|
|---|
| 13 | #include "anydataobj.h"
|
|---|
| 14 | #include "ndatablock.h"
|
|---|
| 15 | #include "dvlist.h"
|
|---|
| 16 |
|
|---|
| 17 |
|
|---|
| 18 | // Maximum number of dimensions for array
|
|---|
| 19 | #define TARRAY_MAXNDIMS 5
|
|---|
| 20 |
|
|---|
| 21 | namespace SOPHYA {
|
|---|
| 22 |
|
|---|
| 23 | /* Quelques utilitaires */
|
|---|
| 24 | typedef double (* Arr_DoubleFunctionOfX) (double x);
|
|---|
| 25 | typedef float (* Arr_FloatFunctionOfX) (float x);
|
|---|
| 26 |
|
|---|
| 27 | class Sequence {
|
|---|
| 28 | public:
|
|---|
| 29 | Sequence (double start=0., double step=1.);
|
|---|
| 30 | inline double & Start() { return start_; }
|
|---|
| 31 | inline double & Step() { return step_; }
|
|---|
| 32 | inline double operator () (uint_4 k) { return(start_+(double)k*step_); }
|
|---|
| 33 | protected:
|
|---|
| 34 | double start_, step_;
|
|---|
| 35 | };
|
|---|
| 36 |
|
|---|
| 37 | // Forward declaration
|
|---|
| 38 | template <class T> class FIO_TArray;
|
|---|
| 39 |
|
|---|
| 40 | // ------------ classe template Array -----------
|
|---|
| 41 | template <class T>
|
|---|
| 42 | class TArray : public AnyDataObj {
|
|---|
| 43 | public:
|
|---|
| 44 | // Creation / destruction
|
|---|
| 45 | TArray();
|
|---|
| 46 | TArray(uint_4 ndim, uint_4 * siz, uint_4 step =1);
|
|---|
| 47 | TArray(uint_4 nx, uint_4 ny=0, uint_4 nz=0);
|
|---|
| 48 | TArray(uint_4 ndim, uint_4 * siz, NDataBlock<T> & db, bool share=false, uint_4 step=1, uint_8 offset=0);
|
|---|
| 49 | TArray(uint_4 ndim, uint_4 * siz, T* values, uint_4 step=1, uint_8 offset=0, Bridge* br=NULL);
|
|---|
| 50 | TArray(const TArray<T>& a);
|
|---|
| 51 | TArray(const TArray<T>& a, bool share);
|
|---|
| 52 |
|
|---|
| 53 | virtual ~TArray();
|
|---|
| 54 |
|
|---|
| 55 | // A = B : partage les donnees si "a" est temporaire, clone sinon.
|
|---|
| 56 | virtual TArray<T>& operator = (const TArray<T>& a);
|
|---|
| 57 |
|
|---|
| 58 | // Extraction de sous-tableau
|
|---|
| 59 | virtual TArray<T> SubArray(uint_4 ndim, uint_4 * siz, uint_4 * pos);
|
|---|
| 60 |
|
|---|
| 61 | // Gestion taille/Remplissage
|
|---|
| 62 | virtual void Clone(const TArray<T>& a);
|
|---|
| 63 | virtual void ReSize(uint_4 ndim, uint_4 * siz, uint_4 step=1);
|
|---|
| 64 | virtual void Realloc(uint_4 ndim, uint_4 * siz, uint_4 step=1, bool force=false);
|
|---|
| 65 | // Returns true if ndim and sizes are equal
|
|---|
| 66 | virtual bool CompareSizes(const TArray<T>& a);
|
|---|
| 67 |
|
|---|
| 68 | // Array dimensions
|
|---|
| 69 | inline uint_4 NbDimensions() const { return( ndim_ ); }
|
|---|
| 70 |
|
|---|
| 71 | inline uint_8 Size() const { return(totsize_); }
|
|---|
| 72 | inline uint_4 SizeX() const { return(size_[0]); }
|
|---|
| 73 | inline uint_4 SizeY() const { return(size_[1]); }
|
|---|
| 74 | inline uint_4 SizeZ() const { return(size_[2]); }
|
|---|
| 75 | inline uint_4 Size(int ka) const { return(size_[CheckDI(ka,1)]); }
|
|---|
| 76 |
|
|---|
| 77 | // memory organisation - packing information
|
|---|
| 78 | inline bool IsPacked() const { return(minstep_ == 1); }
|
|---|
| 79 | inline bool IsPackedX() const { return(step_[0] == 1); }
|
|---|
| 80 | inline bool IsPackedY() const { return(step_[1] == 1); }
|
|---|
| 81 | inline bool IsPackedZ() const { return(step_[2] == 1); }
|
|---|
| 82 | inline bool IsPacked(int ka) const { return(step_[CheckDI(ka,2)] == 1); }
|
|---|
| 83 |
|
|---|
| 84 | inline uint_4 Step() const { return(minstep_); }
|
|---|
| 85 | inline uint_4 StepX() const { return(step_[0]); }
|
|---|
| 86 | inline uint_4 StepZ() const { return(step_[1]); }
|
|---|
| 87 | inline uint_4 StepY() const { return(step_[2]); }
|
|---|
| 88 | inline uint_4 Step(int ka) const { return(step_[CheckDI(ka,3)]); }
|
|---|
| 89 |
|
|---|
| 90 | inline uint_8 Offset() const { return(offset_); }
|
|---|
| 91 |
|
|---|
| 92 |
|
|---|
| 93 | // Temporaire?
|
|---|
| 94 | inline bool IsTemp(void) const {return mNDBlock.IsTemp();}
|
|---|
| 95 | inline void SetTemp(bool temp=false) const {mNDBlock.SetTemp(temp);}
|
|---|
| 96 |
|
|---|
| 97 | // Acces to data
|
|---|
| 98 | inline T const& operator()(uint_4 ix, uint_4 iy, uint_4 iz) const ;
|
|---|
| 99 | inline T& operator()(uint_4 ix, uint_4 iy, uint_4 iz);
|
|---|
| 100 | inline T const& operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu=0) const ;
|
|---|
| 101 | inline T& operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu=0);
|
|---|
| 102 | inline T const& operator[](uint_4 ip) const ;
|
|---|
| 103 | inline T& operator[](uint_4 ip);
|
|---|
| 104 |
|
|---|
| 105 | inline T const& Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0) const ;
|
|---|
| 106 | inline T& Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0);
|
|---|
| 107 | inline T const& ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0) const ;
|
|---|
| 108 | inline T& ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0);
|
|---|
| 109 |
|
|---|
| 110 | inline T* Data() {return mNDBlock.Begin()+offset_;}
|
|---|
| 111 | inline const T* Data() const {return mNDBlock.Begin()+offset_;}
|
|---|
| 112 | inline NDataBlock<T>& DataBlock() {return mNDBlock;}
|
|---|
| 113 | inline const NDataBlock<T>& DataBlock() const {return mNDBlock;}
|
|---|
| 114 |
|
|---|
| 115 | // Operations diverses = , +=, ...
|
|---|
| 116 | // Conversion en type T, if Size() == 1
|
|---|
| 117 | inline operator T();
|
|---|
| 118 | // Met les elements a une suite de valeurs
|
|---|
| 119 | virtual TArray<T>& operator = (Sequence & seq);
|
|---|
| 120 | // A = x (tous les elements a x)
|
|---|
| 121 | virtual TArray<T>& operator = (T x);
|
|---|
| 122 | // A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
|
|---|
| 123 | virtual TArray<T>& operator += (T x);
|
|---|
| 124 | virtual TArray<T>& operator -= (T x);
|
|---|
| 125 | virtual TArray<T>& operator *= (T x);
|
|---|
| 126 | virtual TArray<T>& operator /= (T x);
|
|---|
| 127 | // A += -= (ajoute, soustrait element par element les deux tableaux )
|
|---|
| 128 | virtual TArray<T>& operator += (const TArray<T>& a);
|
|---|
| 129 | virtual TArray<T>& operator -= (const TArray<T>& a);
|
|---|
| 130 | // Multilication, division element par element les deux tableaux
|
|---|
| 131 | virtual TArray<T>& MultElt(const TArray<T>& a);
|
|---|
| 132 | virtual TArray<T>& DivElt(const TArray<T>& a);
|
|---|
| 133 |
|
|---|
| 134 | // Application d'une fonction
|
|---|
| 135 | virtual TArray<T>& ApplyFunction(Arr_DoubleFunctionOfX f);
|
|---|
| 136 | virtual TArray<T>& ApplyFunction(Arr_FloatFunctionOfX f);
|
|---|
| 137 |
|
|---|
| 138 | // Impression, I/O, ...
|
|---|
| 139 | static void SetMaxPrint(uint_4 nprt=50);
|
|---|
| 140 | void Show(ostream& os, bool si=false) const;
|
|---|
| 141 | inline void Show() const { Show(cout); }
|
|---|
| 142 | void Print(ostream& os, int_4 maxprt=-1, bool si=false) const ;
|
|---|
| 143 |
|
|---|
| 144 | // Objet DVList info
|
|---|
| 145 | DVList& Info();
|
|---|
| 146 |
|
|---|
| 147 | // Pour la gestion de persistance
|
|---|
| 148 | friend class FIO_TArray<T>;
|
|---|
| 149 |
|
|---|
| 150 | protected:
|
|---|
| 151 | // Verifie la compatibilite de l'index de dimension
|
|---|
| 152 | inline int CheckDI(int ka, int msg) const ;
|
|---|
| 153 | // Verifie la compatibilite des bornes d'index
|
|---|
| 154 | inline void CheckBound(int ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu, int msg) const ;
|
|---|
| 155 | // Changing Sizes/NDim ... return true if OK
|
|---|
| 156 | bool UpdateSizes(uint_4 ndim, const uint_4 * siz, uint_4 step, uint_8 offset, string & exmsg);
|
|---|
| 157 | bool UpdateSizes(uint_4 ndim, const uint_4 * siz, const uint_4 * step, uint_8 offset, string & exmsg);
|
|---|
| 158 | bool UpdateSizes(const TArray<T>& a, string & exmsg);
|
|---|
| 159 | static uint_8 ComputeTotalSize(uint_4 ndim, uint_4 * siz, uint_4 step, uint_8 offset) ;
|
|---|
| 160 | // partage les donnees si "a" temporaire, clone sinon.
|
|---|
| 161 | void CloneOrShare(const TArray<T>& a);
|
|---|
| 162 | // Share: partage les donnees de "a"
|
|---|
| 163 | void Share(const TArray<T>& a);
|
|---|
| 164 |
|
|---|
| 165 | uint_4 ndim_; // nb of dimensions
|
|---|
| 166 | uint_4 size_[TARRAY_MAXNDIMS]; // array size in each dimension
|
|---|
| 167 | uint_8 totsize_; // Total number of elements
|
|---|
| 168 | uint_4 step_[TARRAY_MAXNDIMS]; // two consecutive elements distance in a given dimension
|
|---|
| 169 | uint_4 minstep_; // minimal step (in any axes)
|
|---|
| 170 | uint_8 offset_; // global offset -> position of elem[0] in DataBlock
|
|---|
| 171 | NDataBlock<T> mNDBlock; // Le bloc des donnees
|
|---|
| 172 | uint_4 marowi_, macoli_; // For matrices, Row index and column index in dimensions
|
|---|
| 173 |
|
|---|
| 174 | DVList* mInfo; // Infos (variables) attachees au tableau
|
|---|
| 175 |
|
|---|
| 176 | static char * ck_op_msg_[6]; // Operation messages for CheckDI() CheckBound()
|
|---|
| 177 | static uint_4 max_nprt_; // Nb maxi d'elements imprimes
|
|---|
| 178 | };
|
|---|
| 179 |
|
|---|
| 180 | ////////////////////////////////////////////////////////////////
|
|---|
| 181 | // Surcharge d'operateur <<
|
|---|
| 182 | template <class T>
|
|---|
| 183 | inline ostream& operator << (ostream& os, const TArray<T>& a)
|
|---|
| 184 | { a.Print(os); return(os); }
|
|---|
| 185 |
|
|---|
| 186 | ////////////////////////////////////////////////////////////////
|
|---|
| 187 | // Surcharge d'operateurs A (+,-,*,/) (T) x
|
|---|
| 188 |
|
|---|
| 189 | template <class T> inline TArray<T> operator + (const TArray<T>& a, T b)
|
|---|
| 190 | {TArray<T> result(a); result.SetTemp(true); result += b; return result;}
|
|---|
| 191 |
|
|---|
| 192 | template <class T> inline TArray<T> operator + (T b,const TArray<T>& a)
|
|---|
| 193 | {TArray<T> result(a); result.SetTemp(true); result += b; return result;}
|
|---|
| 194 |
|
|---|
| 195 | template <class T> inline TArray<T> operator - (const TArray<T>& a, T b)
|
|---|
| 196 | {TArray<T> result(a); result.SetTemp(true); result -= b; return result;}
|
|---|
| 197 |
|
|---|
| 198 | template <class T> inline TArray<T> operator - (T b,const TArray<T>& a)
|
|---|
| 199 | {TArray<T> result(a); result.SetTemp(true);
|
|---|
| 200 | result.DataBlock() = b-result.DataBlock(); return result;}
|
|---|
| 201 |
|
|---|
| 202 | template <class T> inline TArray<T> operator * (const TArray<T>& a, T b)
|
|---|
| 203 | {TArray<T> result(a); result.SetTemp(true); result *= b; return result;}
|
|---|
| 204 |
|
|---|
| 205 | template <class T> inline TArray<T> operator * (T b,const TArray<T>& a)
|
|---|
| 206 | {TArray<T> result(a); result.SetTemp(true); result *= b; return result;}
|
|---|
| 207 |
|
|---|
| 208 | template <class T> inline TArray<T> operator / (const TArray<T>& a, T b)
|
|---|
| 209 | {TArray<T> result(a); result.SetTemp(true); result /= b; return result;}
|
|---|
| 210 |
|
|---|
| 211 | ////////////////////////////////////////////////////////////////
|
|---|
| 212 | // Surcharge d'operateurs C = A (+,-) B
|
|---|
| 213 |
|
|---|
| 214 | template <class T>
|
|---|
| 215 | inline TArray<T> operator + (const TArray<T>& a,const TArray<T>& b)
|
|---|
| 216 | {TArray<T> result(a); result.SetTemp(true); result += b; return result;}
|
|---|
| 217 |
|
|---|
| 218 | template <class T>
|
|---|
| 219 | inline TArray<T> operator - (const TArray<T>& a,const TArray<T>& b)
|
|---|
| 220 | {TArray<T> result(a); result.SetTemp(true); result += b; return result;}
|
|---|
| 221 |
|
|---|
| 222 | ////////////////////////////////////////////////
|
|---|
| 223 | // Calcul de fonction
|
|---|
| 224 | template <class T>
|
|---|
| 225 | inline TArray<T> sin(const TArray<T>& a)
|
|---|
| 226 | {TArray<T> result(a); result.SetTemp(true); result.ApplyFunction(sin); return result;}
|
|---|
| 227 |
|
|---|
| 228 | template <class T>
|
|---|
| 229 | inline TArray<T> cos(const TArray<T>& a)
|
|---|
| 230 | {TArray<T> result(a); result.SetTemp(true); result.ApplyFunction(cos); return result;}
|
|---|
| 231 |
|
|---|
| 232 | // --------------------------------------------------
|
|---|
| 233 | // Methodes inline de verification
|
|---|
| 234 | // --------------------------------------------------
|
|---|
| 235 | template <class T>
|
|---|
| 236 | inline int TArray<T>::CheckDI(int ka, int msg) const
|
|---|
| 237 | {
|
|---|
| 238 | if ( (ka < 0) || (ka >= ndim_) ) {
|
|---|
| 239 | string txt = "TArray<T>::CheckDimensionIndex/Error "; txt += ck_op_msg_[msg];
|
|---|
| 240 | throw(ParmError(txt));
|
|---|
| 241 | }
|
|---|
| 242 | return(ka);
|
|---|
| 243 | }
|
|---|
| 244 |
|
|---|
| 245 | template <class T>
|
|---|
| 246 | inline void TArray<T>::CheckBound(int ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu, int msg) const
|
|---|
| 247 | {
|
|---|
| 248 | if ( (ix >= size_[0]) || (iy >= size_[1]) || (iz > size_[2]) ||
|
|---|
| 249 | (it >= size_[3]) || (iu >= size_[4]) ) {
|
|---|
| 250 | string txt = "TArray<T>::CheckArrayBound/Error "; txt += ck_op_msg_[msg];
|
|---|
| 251 | throw(ParmError(txt));
|
|---|
| 252 | }
|
|---|
| 253 | return;
|
|---|
| 254 | }
|
|---|
| 255 |
|
|---|
| 256 | // --------------------------------------------------
|
|---|
| 257 | // inline element acces methods
|
|---|
| 258 | // --------------------------------------------------
|
|---|
| 259 | template <class T>
|
|---|
| 260 | inline T const& TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
|
|---|
| 261 | {
|
|---|
| 262 | return ( *( mNDBlock.Begin()+ offset_+
|
|---|
| 263 | ix*step_[0] + iy*step_[1] + iz*step_[2] +
|
|---|
| 264 | it*step_[3] + iu*step_[4]) );
|
|---|
| 265 | }
|
|---|
| 266 |
|
|---|
| 267 | template <class T>
|
|---|
| 268 | inline T & TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
|
|---|
| 269 | {
|
|---|
| 270 | return ( *( mNDBlock.Begin()+ offset_+
|
|---|
| 271 | ix*step_[0] + iy*step_[1] + iz*step_[2] +
|
|---|
| 272 | it*step_[3] + iu*step_[4]) );
|
|---|
| 273 | }
|
|---|
| 274 |
|
|---|
| 275 | template <class T>
|
|---|
| 276 | inline T const& TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
|
|---|
| 277 | {
|
|---|
| 278 | CheckBound(ix, iy, iz, it, iu, 4);
|
|---|
| 279 | Elem(ix, iy, iz, it, iu);
|
|---|
| 280 | }
|
|---|
| 281 |
|
|---|
| 282 | template <class T>
|
|---|
| 283 | inline T & TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
|
|---|
| 284 | {
|
|---|
| 285 | CheckBound(ix, iy, iz, it, iu, 4);
|
|---|
| 286 | Elem(ix, iy, iz, it, iu);
|
|---|
| 287 | }
|
|---|
| 288 |
|
|---|
| 289 | template <class T>
|
|---|
| 290 | inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz) const
|
|---|
| 291 | {
|
|---|
| 292 | #ifdef SO_BOUNDCHECKING
|
|---|
| 293 | CheckBound(ix, iy, iz, 0, 0, 4);
|
|---|
| 294 | #endif
|
|---|
| 295 | return ( *( mNDBlock.Begin()+ offset_+
|
|---|
| 296 | ix*step_[0] + iy*step_[1] + iz*step_[2]) );
|
|---|
| 297 | }
|
|---|
| 298 |
|
|---|
| 299 | template <class T>
|
|---|
| 300 | inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz)
|
|---|
| 301 | {
|
|---|
| 302 | #ifdef SO_BOUNDCHECKING
|
|---|
| 303 | CheckBound(ix, iy, iz, 0, 0, 4);
|
|---|
| 304 | #endif
|
|---|
| 305 | return ( *( mNDBlock.Begin()+ offset_+
|
|---|
| 306 | ix*step_[0] + iy*step_[1] + iz*step_[2]) );
|
|---|
| 307 | }
|
|---|
| 308 |
|
|---|
| 309 | template <class T>
|
|---|
| 310 | inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
|
|---|
| 311 | {
|
|---|
| 312 | #ifdef SO_BOUNDCHECKING
|
|---|
| 313 | CheckBound(ix, iy, iz, it, iu, 4);
|
|---|
| 314 | #endif
|
|---|
| 315 | return ( *( mNDBlock.Begin()+ offset_+
|
|---|
| 316 | ix*step_[0] + iy*step_[1] + iz*step_[2] +
|
|---|
| 317 | it*step_[3] + iu*step_[4]) );
|
|---|
| 318 | }
|
|---|
| 319 |
|
|---|
| 320 | template <class T>
|
|---|
| 321 | inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
|
|---|
| 322 | {
|
|---|
| 323 | #ifdef SO_BOUNDCHECKING
|
|---|
| 324 | CheckBound(ix, iy, iz, it, iu, 4);
|
|---|
| 325 | #endif
|
|---|
| 326 | return ( *( mNDBlock.Begin()+ offset_+
|
|---|
| 327 | ix*step_[0] + iy*step_[1] + iz*step_[2] +
|
|---|
| 328 | it*step_[3] + iu*step_[4]) );
|
|---|
| 329 | }
|
|---|
| 330 |
|
|---|
| 331 | template <class T>
|
|---|
| 332 | inline T const& TArray<T>::operator[](uint_4 ip) const
|
|---|
| 333 | {
|
|---|
| 334 | #ifdef SO_BOUNDCHECKING
|
|---|
| 335 | if (ip >= totsize_) throw( ParmError("TArray<T>::operator[] Out-of-bound Error") );
|
|---|
| 336 | #endif
|
|---|
| 337 | return *(mNDBlock.Begin()+offset_+ip*minstep_);
|
|---|
| 338 | }
|
|---|
| 339 |
|
|---|
| 340 | template <class T>
|
|---|
| 341 | inline T & TArray<T>::operator[](uint_4 ip)
|
|---|
| 342 | {
|
|---|
| 343 | #ifdef SO_BOUNDCHECKING
|
|---|
| 344 | if (ip >= totsize_) throw( ParmError("TArray<T>::operator[] Out-of-bound Error") );
|
|---|
| 345 | #endif
|
|---|
| 346 | return *(mNDBlock.Begin()+offset_+ip*minstep_);
|
|---|
| 347 | }
|
|---|
| 348 |
|
|---|
| 349 | template <class T>
|
|---|
| 350 | inline TArray<T>::operator T()
|
|---|
| 351 | {
|
|---|
| 352 | if (Size() != 1) throw(SzMismatchError("TArray<T>::operator T() Size() != 1")) ;
|
|---|
| 353 | return ( (*this)[0] );
|
|---|
| 354 | }
|
|---|
| 355 |
|
|---|
| 356 | } // Fin du namespace
|
|---|
| 357 |
|
|---|
| 358 | #endif
|
|---|
![(please configure the [header_logo] section in trac.ini)](/PI/chrome/site/your_project_logo.png){kind=logo}
