source: Sophya/trunk/SophyaLib/TArray/tarray.h@ 1081

Last change on this file since 1081 was 1081, checked in by ansari, 25 years ago

Adaptation modifs MuTyV et services de copie entre tableaux de type different - Reza 24/7/2000
File size: 14.0 KB
Line 
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 "basarr.h"
12#include "ndatablock.h"
13#include <complex>
14#include "utilarr.h"
15
16
17namespace SOPHYA {
18
19// Forward declaration
20template <class T> class FIO_TArray;
21
22// --------------------------- classe template Array -----------------------
23// ( See BaseArray class for data organisation in memory and related methods )
24
25//! Class for template arrays
26template <class T>
27class TArray : public BaseArray {
28public:
29 // Creation / destruction
30 TArray();
31 TArray(uint_4 ndim, const uint_4 * siz, uint_4 step =1);
32 TArray(uint_4 nx, uint_4 ny=0, uint_4 nz=0, uint_4 nt=0, uint_4 nu=0);
33 TArray(uint_4 ndim, const uint_4 * siz, NDataBlock<T> & db, bool share=false, uint_4 step=1, uint_8 offset=0);
34 TArray(uint_4 ndim, const uint_4 * siz, T* values, uint_4 step=1, uint_8 offset=0, Bridge* br=NULL);
35 TArray(const TArray<T>& a);
36 TArray(const TArray<T>& a, bool share);
37 TArray(const BaseArray& a);
38
39 virtual ~TArray();
40
41 // A = B
42 //! = operator between TArray
43 /*! \warning Datas are copied (cloned) from \b a.
44 \sa Set \sa NDataBlock::operator=(const NDataBlock<T>&) */
45 inline TArray<T>& operator = (const TArray<T>& a) { return Set(a); }
46 virtual TArray<T>& Set(const TArray<T>& a);
47
48 //! = operator between TArray 's with different types - Elements are converted.
49 inline TArray<T>& operator = (const BaseArray& a) { return SetBA(a); }
50 virtual TArray<T>& SetBA(const BaseArray& a);
51
52 // Gestion taille/Remplissage
53 virtual void Clone(const TArray<T>& a);
54 // partage les donnees si "a" temporaire, clone sinon.
55 void CloneOrShare(const TArray<T>& a);
56 // Share: partage les donnees de "a"
57
58 void Share(const TArray<T>& a);
59 void ReSize(uint_4 ndim, uint_4 * siz, uint_4 step=1);
60 void Realloc(uint_4 ndim, uint_4 * siz, uint_4 step=1, bool force=false);
61
62 // Compacts size=1 array dimensions
63 virtual TArray<T>& CompactAllDimensions();
64 virtual TArray<T>& CompactTrailingDimensions();
65
66 // Packing array elements in memory
67 virtual TArray<T> PackElements(bool force=false) const ;
68
69 // SubArrays - $CHECK$ Reza 03/2000 je ne sais pas s'il faut declarer ca const ??
70 TArray<T> SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const ;
71#if !defined(__GNUG__)
72 //! () operator for Sub arrays extraction
73 /*! \sa SubArray */
74 inline TArray<T> operator () (Range rx, Range ry, Range rz, Range rt=0, Range ru=0) const
75 { return SubArray(rx, ry, rz, rt, ru); }
76#else
77 // g++ (2.95) se melange les pinceaux avec les arguments par defaut !
78 //! () operator for Sub arrays extraction
79 /*! \sa SubArray */
80 inline TArray<T> operator () (Range rx, Range ry, Range rz) const
81 { return SubArray(rx, ry, rz, Range(0), Range(0)); }
82 inline TArray<T> operator () (Range rx, Range ry, Range rz, Range rt) const
83 { return SubArray(rx, ry, rz, rt, Range(0)); }
84 inline TArray<T> operator () (Range rx, Range ry, Range rz, Range rt, Range ru) const
85 { return SubArray(rx, ry, rz, rt, ru); }
86#endif
87
88 // ---- Access to data
89 // Definition of virtual element acces method inherited from BaseArray class
90 virtual MuTyV & ValueAtPosition(uint_8 ip) const;
91
92 // Data Access: operator overloaded inline acces methods
93 inline T const& operator()(uint_4 ix, uint_4 iy, uint_4 iz) const ;
94 inline T& operator()(uint_4 ix, uint_4 iy, uint_4 iz);
95 inline T const& operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu=0) const ;
96 inline T& operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu=0);
97 inline T const& operator[](uint_8 ip) const ;
98 inline T& operator[](uint_8 ip);
99
100 inline T const& Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0) const ;
101 inline T& Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0);
102 inline T const& ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0) const ;
103 inline T& ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0);
104
105 //! Return pointer to first element adress
106 inline T* Data() {return mNDBlock.Begin()+offset_;}
107 //! Return pointer to first element adress
108 inline const T* Data() const {return mNDBlock.Begin()+offset_;}
109 //! Return reference to datablock NDataBlock
110 inline NDataBlock<T>& DataBlock() {return mNDBlock;}
111 //! Return reference to datablock NDataBlock
112 inline const NDataBlock<T>& DataBlock() const {return mNDBlock;}
113
114 // Temporaire?
115 //! Are the array temporay ?
116 inline bool IsTemp(void) const {return mNDBlock.IsTemp();}
117 //! Set the array as temporay
118 inline void SetTemp(bool temp=false) const {mNDBlock.SetTemp(temp);}
119
120// Operations diverses = , +=, ...
121// Conversion en type T, if Size() == 1
122 inline T toScalar();
123// Met les elements a une suite de valeurs
124 virtual TArray<T>& SetSeq(Sequence seq);
125 //! Fill TArray with Sequence \b seq
126 inline TArray<T>& operator = (Sequence seq) { return SetSeq(seq); }
127// A = x (tous les elements a x)
128 virtual TArray<T>& SetT(T x);
129 //! Fill TArray with all elements equal to \b x
130 inline TArray<T>& operator = (T x) { return SetT(x); }
131// A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
132 virtual TArray<T>& Add(T x);
133 //! Add \b x to all elements
134 inline TArray<T>& operator += (T x) { return Add(x); }
135 virtual TArray<T>& Sub(T x, bool fginv=false);
136 //! Substract \b x to all elements
137 inline TArray<T>& operator -= (T x) { return Sub(x); }
138 virtual TArray<T>& Mul(T x);
139 //! Multiply all elements by \b x
140 inline TArray<T>& operator *= (T x) { return Mul(x); }
141 virtual TArray<T>& Div(T x, bool fginv=false);
142 //! Divide all elements by \b x
143 inline TArray<T>& operator /= (T x) { return Div(x); }
144
145// A += -= (ajoute, soustrait element par element les deux tableaux )
146 virtual TArray<T>& AddElt(const TArray<T>& a);
147 //! Operator TArray += TArray
148 inline TArray<T>& operator += (const TArray<T>& a) { return AddElt(a); }
149 virtual TArray<T>& SubElt(const TArray<T>& a, bool fginv=false);
150 //! Operator TArray -= TArray
151 inline TArray<T>& operator -= (const TArray<T>& a) { return SubElt(a); }
152// Multiplication, division element par element les deux tableaux
153 virtual TArray<T>& MulElt(const TArray<T>& a);
154 virtual TArray<T>& DivElt(const TArray<T>& a, bool fginv=false, bool divzero=false);
155// Recopie des valeurs, element par element
156 virtual TArray<T>& CopyElt(const TArray<T>& a);
157// Recopie des valeurs avec conversion prealable, element par element
158 virtual TArray<T>& ConvertAndCopyElt(const BaseArray& a);
159
160// Somme et produit des elements
161 virtual T Sum() const ;
162 virtual T Product() const ;
163
164// Impression, I/O, ...
165 virtual string InfoString() const;
166 virtual void Print(ostream& os, int_4 maxprt=-1, bool si=false) const ;
167
168// Pour la gestion de persistance
169 friend class FIO_TArray<T>;
170
171protected:
172
173 NDataBlock<T> mNDBlock; //!< Block for datas
174 mutable MuTyV my_mtv; //!< for use by ValueAtPosition()
175};
176
177////////////////////////////////////////////////////////////////
178// Surcharge d'operateur <<
179//! Print TArray \b a on stream \b os
180template <class T>
181inline ostream& operator << (ostream& os, const TArray<T>& a)
182 { a.Print(os); return(os); }
183
184////////////////////////////////////////////////////////////////
185// Surcharge d'operateurs A (+,-,*,/) (T) x
186
187/*! \ingroup TArray \fn operator+(const TArray<T>&,T)
188 \brief Operator TArray = TArray + constant */
189template <class T> inline TArray<T> operator + (const TArray<T>& a, T b)
190 {TArray<T> result; result.CloneOrShare(a); result.SetTemp(true);
191 result.Add(b); return result;}
192
193/*! \ingroup TArray \fn operator+(T,const TArray<T>&)
194 \brief Operator TArray = constant + TArray */
195template <class T> inline TArray<T> operator + (T b,const TArray<T>& a)
196 {TArray<T> result; result.CloneOrShare(a); result.SetTemp(true);
197 result.Add(b); return result;}
198
199/*! \ingroup TArray \fn operator-(const TArray<T>&,T)
200 \brief Operator TArray = TArray - constant */
201template <class T> inline TArray<T> operator - (const TArray<T>& a, T b)
202 {TArray<T> result; result.CloneOrShare(a); result.SetTemp(true);
203 result.Sub(b); return result;}
204
205/*! \ingroup TArray \fn operator-(T,const TArray<T>&)
206 \brief Operator TArray = constant - TArray */
207template <class T> inline TArray<T> operator - (T b,const TArray<T>& a)
208 {TArray<T> result; result.CloneOrShare(a); result.SetTemp(true);
209 result.Sub(b,true); return result;}
210
211/*! \ingroup TArray \fn operator*(const TArray<T>&,T)
212 \brief Operator TArray = TArray * constant */
213template <class T> inline TArray<T> operator * (const TArray<T>& a, T b)
214 {TArray<T> result; result.CloneOrShare(a); result.SetTemp(true);
215 result.Mul(b); return result;}
216
217/*! \ingroup TArray \fn operator*(T,const TArray<T>&)
218 \brief Operator TArray = constant * TArray */
219template <class T> inline TArray<T> operator * (T b,const TArray<T>& a)
220 {TArray<T> result; result.CloneOrShare(a); result.SetTemp(true);
221 result.Mul(b); return result;}
222
223/*! \ingroup TArray \fn operator/(const TArray<T>&,T)
224 \brief Operator TArray = TArray / constant */
225template <class T> inline TArray<T> operator / (const TArray<T>& a, T b)
226 {TArray<T> result; result.CloneOrShare(a); result.SetTemp(true);
227 result.Div(b); return result;}
228
229/*! \ingroup TArray \fn operator/(T,const TArray<T>&)
230 \brief Operator TArray = constant / TArray */
231template <class T> inline TArray<T> operator / (T b, const TArray<T>& a)
232 {TArray<T> result; result.CloneOrShare(a); result.SetTemp(true);
233 result.Div(b, true); return result;}
234
235////////////////////////////////////////////////////////////////
236// Surcharge d'operateurs C = A (+,-) B
237
238/*! \ingroup TArray \fn operator+(const TArray<T>&,const TArray<T>&)
239 \brief Operator TArray = TArray + TArray */
240template <class T>
241inline TArray<T> operator + (const TArray<T>& a,const TArray<T>& b)
242 { TArray<T> result; result.SetTemp(true);
243 if (b.IsTemp()) { result.Share(b); result.AddElt(a); }
244 else { result.CloneOrShare(a); result.AddElt(b); }
245 return result; }
246
247/*! \ingroup TArray \fn operator-(const TArray<T>&,const TArray<T>&)
248 \brief Operator TArray = TArray - TArray */
249template <class T>
250inline TArray<T> operator - (const TArray<T>& a,const TArray<T>& b)
251 { TArray<T> result; result.SetTemp(true);
252 if (b.IsTemp()) { result.Share(b); result.SubElt(a, true); }
253 else { result.CloneOrShare(a); result.SubElt(b); }
254 return result; }
255
256
257// --------------------------------------------------
258// inline element acces methods
259// --------------------------------------------------
260
261//! Return element (ix,iy,iz,it,iu) value
262template <class T>
263inline T const& TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
264{
265 return ( *( mNDBlock.Begin()+ offset_+
266 ix*step_[0] + iy*step_[1] + iz*step_[2] +
267 it*step_[3] + iu*step_[4]) );
268}
269
270//! Return element (ix,iy,iz,it,iu) value
271template <class T>
272inline T & TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
273{
274 return ( *( mNDBlock.Begin()+ offset_+
275 ix*step_[0] + iy*step_[1] + iz*step_[2] +
276 it*step_[3] + iu*step_[4]) );
277}
278
279//! Return element (ix,iy,iz,it,iu) value with Check of indexes bound first
280template <class T>
281inline T const& TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
282{
283 CheckBound(ix, iy, iz, it, iu, 4);
284 return(Elem(ix, iy, iz, it, iu));
285}
286
287//! Return element (ix,iy,iz,it,iu) value with Check of indexes bound first
288template <class T>
289inline T & TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
290{
291 CheckBound(ix, iy, iz, it, iu, 4);
292 return(Elem(ix, iy, iz, it, iu));
293}
294
295//! Return element (ix,iy,iz) value
296template <class T>
297inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz) const
298{
299#ifdef SO_BOUNDCHECKING
300 CheckBound(ix, iy, iz, 0, 0, 4);
301#endif
302 return ( *( mNDBlock.Begin()+ offset_+
303 ix*step_[0] + iy*step_[1] + iz*step_[2]) );
304}
305
306//! Return element (ix,iy,iz) value
307template <class T>
308inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz)
309{
310#ifdef SO_BOUNDCHECKING
311 CheckBound(ix, iy, iz, 0, 0, 4);
312#endif
313 return ( *( mNDBlock.Begin()+ offset_+
314 ix*step_[0] + iy*step_[1] + iz*step_[2]) );
315}
316
317//! Operator () : return element (ix,iy,iz,it,iu) value
318template <class T>
319inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
320{
321#ifdef SO_BOUNDCHECKING
322 CheckBound(ix, iy, iz, it, iu, 4);
323#endif
324 return ( *( mNDBlock.Begin()+ offset_+
325 ix*step_[0] + iy*step_[1] + iz*step_[2] +
326 it*step_[3] + iu*step_[4]) );
327}
328
329//! Operator () : return element (ix,iy,iz,it,iu) value
330template <class T>
331inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
332{
333#ifdef SO_BOUNDCHECKING
334 CheckBound(ix, iy, iz, it, iu, 4);
335#endif
336 return ( *( mNDBlock.Begin()+ offset_+
337 ix*step_[0] + iy*step_[1] + iz*step_[2] +
338 it*step_[3] + iu*step_[4]) );
339}
340
341
342//! Operator [] : return element at positon ip
343template <class T>
344inline T const& TArray<T>::operator[](uint_8 ip) const
345{
346#ifdef SO_BOUNDCHECKING
347 if (ip >= totsize_) throw( ParmError("TArray<T>::operator[] Out-of-bound Error") );
348#endif
349return *(mNDBlock.Begin()+Offset(ip));
350}
351
352//! Operator [] : return element at positon ip
353template <class T>
354inline T & TArray<T>::operator[](uint_8 ip)
355{
356#ifdef SO_BOUNDCHECKING
357 if (ip >= totsize_) throw( ParmError("TArray<T>::operator[] Out-of-bound Error") );
358#endif
359return *(mNDBlock.Begin()+Offset(ip));
360}
361
362
363//! Return the value of first element
364template <class T>
365inline T TArray<T>::toScalar()
366{
367 if (Size() != 1) throw(SzMismatchError("TArray<T>::operator T() Size() != 1")) ;
368 return ( (*this)[0] );
369}
370
371// Typedef pour simplifier
372/*! \ingroup TArray
373 \typedef Array
374 \brief To simplified TArray<r_8> writing
375*/
376typedef TArray<r_8> Array;
377
378} // Fin du namespace
379
380#endif
Note: See TracBrowser for help on using the repository browser.