Index: trunk/SophyaLib/TArray/tarray.h
===================================================================
--- trunk/SophyaLib/TArray/tarray.h	(revision 787)
+++ trunk/SophyaLib/TArray/tarray.h	(revision 804)
@@ -28,8 +28,8 @@
   // Creation / destruction 
   TArray();
-  TArray(uint_4 ndim, uint_4 * siz, uint_4 step =1);
-  TArray(uint_4 nx, uint_4 ny=0, uint_4 nz=0);
-  TArray(uint_4 ndim, uint_4 * siz, NDataBlock<T> & db, bool share=false, uint_4 step=1, uint_8 offset=0);
-  TArray(uint_4 ndim, uint_4 * siz, T* values, uint_4 step=1, uint_8 offset=0, Bridge* br=NULL);
+  TArray(uint_4 ndim, const uint_4 * siz, uint_4 step =1);
+  TArray(uint_4 nx, uint_4 ny=0, uint_4 nz=0, uint_4 nt=0, uint_4 nu=0);
+  TArray(uint_4 ndim, const uint_4 * siz, NDataBlock<T> & db, bool share=false, uint_4 step=1, uint_8 offset=0);
+  TArray(uint_4 ndim, const uint_4 * siz, T* values, uint_4 step=1, uint_8 offset=0, Bridge* br=NULL);
   TArray(const TArray<T>& a);
   TArray(const TArray<T>& a, bool share);
@@ -38,10 +38,11 @@
 
   // A = B : partage les donnees si "a" est temporaire, clone sinon.
-  virtual TArray<T>& operator = (const TArray<T>& a);
+  inline  TArray<T>& operator = (const TArray<T>& a) { return Set(a); }
+  virtual TArray<T>& Set(const TArray<T>& a);
 
   // Gestion taille/Remplissage
   virtual void Clone(const TArray<T>& a); 
-  virtual void ReSize(uint_4 ndim, uint_4 * siz, uint_4 step=1);
-  virtual void Realloc(uint_4 ndim, uint_4 * siz, uint_4 step=1, bool force=false);
+  void ReSize(uint_4 ndim, uint_4 * siz, uint_4 step=1);
+  void Realloc(uint_4 ndim, uint_4 * siz, uint_4 step=1, bool force=false);
 
   // Compacts size=1 array dimensions
@@ -49,7 +50,11 @@
   virtual TArray<T>& CompactTrailingDimensions();
 
-  // SubArrays
-  virtual TArray<T> operator () (Range rx, Range ry, Range rz=0, Range rt=0, Range ru=0); 
-
+  // Packing array elements in memory
+  virtual TArray<T> PackElements(bool force=false) const ;
+
+  // SubArrays - $CHECK$ Reza 03/2000 je ne sais pas s'il faut declarer ca const ??
+  TArray<T> SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const ; 
+  inline TArray<T> operator () (Range rx, Range ry, Range rz, Range rt=0, Range ru=0) const
+                   { return  SubArray(rx, ry, rz, rt, ru); }
 
   // ---- Access to data
@@ -83,18 +88,35 @@
   inline T toScalar();
 // Met les elements a une suite de valeurs
-  virtual TArray<T>&  operator = (Sequence seq);
+  virtual TArray<T>&  Set(Sequence seq);
+  inline  TArray<T>&  operator = (Sequence seq)    { return Set(seq); }
 // A = x (tous les elements a x)
-  virtual TArray<T>&  operator = (T x);
+  virtual TArray<T>&  Set(T x);
+  inline  TArray<T>&  operator = (T x)             { return Set(x); }
 // A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
-  virtual TArray<T>&  operator += (T x);
-  virtual TArray<T>&  operator -= (T x);
-  virtual TArray<T>&  operator *= (T x);
-  virtual TArray<T>&  operator /= (T x);
+  virtual TArray<T>&  Add(T x);
+  inline  TArray<T>&  operator += (T x)            { return Add(x); }
+  virtual TArray<T>&  Sub(T x);
+  inline  TArray<T>&  operator -= (T x)            { return Sub(x); }
+  virtual TArray<T>&  Mul(T x);
+  inline  TArray<T>&  operator *= (T x)            { return Mul(x); }
+  virtual TArray<T>&  Div(T x);
+  inline  TArray<T>&  operator /= (T x)            { return Div(x); }
+  virtual TArray<T>&  SubInv(T x);  //   A ---> x-A
+  virtual TArray<T>&  DivInv(T x);  //   A ---> x/A
+
 // A += -=  (ajoute, soustrait element par element les deux tableaux )
-  virtual TArray<T>&  operator += (const TArray<T>& a);
-  virtual TArray<T>&  operator -= (const TArray<T>& a);
+  virtual TArray<T>&  AddElt(const TArray<T>& a);
+  inline  TArray<T>&  operator += (const TArray<T>& a)  { return AddElt(a); }
+  virtual TArray<T>&  SubElt(const TArray<T>& a);
+  inline  TArray<T>&  operator -= (const TArray<T>& a)  { return SubElt(a); }
 // Multiplication, division element par element les deux tableaux 
-  virtual TArray<T>&  MultElt(const TArray<T>& a);
+  virtual TArray<T>&  MulElt(const TArray<T>& a);
   virtual TArray<T>&  DivElt(const TArray<T>& a);
+// Recopie des valeurs, element par element
+  virtual TArray<T>&  CopyElt(const TArray<T>& a);
+
+// Somme et produit des elements
+  virtual T Sum() const ;
+  virtual T Product() const ;
 
 // Impression, I/O, ...
@@ -124,24 +146,23 @@
 
 template <class T> inline TArray<T> operator + (const TArray<T>& a, T b)
-    {TArray<T> result(a); result.SetTemp(true); result += b; return result;}
+    {TArray<T> result(a); result.SetTemp(true); result.Add(b); return result;}
 
 template <class T> inline TArray<T> operator + (T b,const TArray<T>& a)
-    {TArray<T> result(a); result.SetTemp(true); result += b; return result;}
+    {TArray<T> result(a); result.SetTemp(true); result.Add(b); return result;}
 
 template <class T> inline TArray<T> operator - (const TArray<T>& a, T b)
-    {TArray<T> result(a); result.SetTemp(true); result -= b; return result;}
+    {TArray<T> result(a); result.SetTemp(true); result.Sub(b); return result;}
 
 template <class T> inline TArray<T> operator - (T b,const TArray<T>& a)
-    {TArray<T> result(a); result.SetTemp(true);
-     result.DataBlock() = b-result.DataBlock(); return result;}
+    {TArray<T> result(a); result.SetTemp(true); result.SubInv(b); return result;}
 
 template <class T> inline TArray<T> operator * (const TArray<T>& a, T b)
-    {TArray<T> result(a); result.SetTemp(true); result *= b; return result;}
+    {TArray<T> result(a); result.SetTemp(true); result.Mul(b); return result;}
 
 template <class T> inline TArray<T> operator * (T b,const TArray<T>& a)
-    {TArray<T> result(a); result.SetTemp(true); result *= b; return result;}
+    {TArray<T> result(a); result.SetTemp(true); result.Mul(b); return result;}
 
 template <class T> inline TArray<T> operator / (const TArray<T>& a, T b)
-    {TArray<T> result(a); result.SetTemp(true); result /= b; return result;}
+    {TArray<T> result(a); result.SetTemp(true); result.DivInv(b); return result;}
 
 ////////////////////////////////////////////////////////////////
@@ -150,9 +171,9 @@
 template <class T>
 inline TArray<T> operator + (const TArray<T>& a,const TArray<T>& b)
-    {TArray<T> result(a); result.SetTemp(true); result += b; return result;}
+    {TArray<T> result(a); result.SetTemp(true); result.AddElt(b); return result;}
 
 template <class T>
 inline TArray<T> operator - (const TArray<T>& a,const TArray<T>& b)
-    {TArray<T> result(a); result.SetTemp(true); result += b; return result;}
+    {TArray<T> result(a); result.SetTemp(true); result.SubElt(b); return result;}
 
 
@@ -180,5 +201,5 @@
 {
   CheckBound(ix, iy, iz, it, iu, 4);
-  Elem(ix, iy, iz, it, iu);
+  return(Elem(ix, iy, iz, it, iu));
 }
 
@@ -187,5 +208,5 @@
 {
   CheckBound(ix, iy, iz, it, iu, 4);
-  Elem(ix, iy, iz, it, iu);
+  return(Elem(ix, iy, iz, it, iu));
 }
 
@@ -259,4 +280,7 @@
 }
 
+// Typedef pour simplifier
+typedef TArray<r_8> Array;
+
 } // Fin du namespace
 
