Index: /trunk/SophyaLib/TArray/sopemtx.cc
===================================================================
--- /trunk/SophyaLib/TArray/sopemtx.cc	(revision 3331)
+++ /trunk/SophyaLib/TArray/sopemtx.cc	(revision 3332)
@@ -36,35 +36,28 @@
   };
   TMatrixRC();
-  TMatrixRC(TMatrix<T>& m, TRCKind kind, uint_4 index=0);
+  TMatrixRC(TMatrix<T>& m, TRCKind kind, sa_size_t index=0);
   virtual ~TMatrixRC() {}
 
   // Acces aux rangees et colonnes de matrices
-  static TMatrixRC<T> Row(TMatrix<T> & m, uint_4 r);
-  static TMatrixRC<T> Col(TMatrix<T> & m, uint_4 c);
+  static TMatrixRC<T> Row(TMatrix<T> & m, sa_size_t r);
+  static TMatrixRC<T> Col(TMatrix<T> & m, sa_size_t c);
   static TMatrixRC<T> Diag(TMatrix<T> & m);
 
-  // ---- A virer   $CHECK$ Reza 03/2000
-  //  int_4 Next();
-  //  int_4 Prev();
   int_4 SetCol(int_4 c);
   int_4 SetRow(int_4 r);
   int_4 SetDiag();
 
-  static uint_4 Step(const TMatrix<T>& m, TRCKind rckind);
-  static T* Org(const TMatrix<T>&, TRCKind rckind, uint_4 ind=0);
+  static sa_size_t Step(const TMatrix<T>& m, TRCKind rckind);
+  static T* Org(const TMatrix<T>&, TRCKind rckind, sa_size_t ind=0);
 
   //! Return the kind of TMatrix (line,column,diagonal)
   TRCKind Kind() const { return kind; }
-  uint_4 NElts() const;
-  T& operator()(uint_4 i);
-  T  operator()(uint_4 i) const;
+  sa_size_t NElts() const;
+  T& operator()(sa_size_t i);
+  T  operator()(sa_size_t i) const;
 
 
    TMatrixRC<T>& operator = (const TMatrixRC<T>& rc);
 
-// ---- A virer   $CHECK$ Reza 03/2000
-//   TVector<T> GetVect() const;
-//   TMatrixRC<T>& operator += (const TMatrixRC<T>& rc);
-//   TMatrixRC<T>& operator -= (const TMatrixRC<T>& rc);
 
   TMatrixRC<T>& operator *= (T x);
@@ -75,8 +68,8 @@
   
 
-  TMatrixRC<T>& LinComb(T a, T b, const TMatrixRC& rc, uint_4 first=0);
-  TMatrixRC<T>& LinComb(T b, const TMatrixRC<T>& rc, uint_4 first=0);
-
-  uint_4 IMaxAbs(uint_4 first=0);
+  TMatrixRC<T>& LinComb(T a, T b, const TMatrixRC& rc, sa_size_t first=0);
+  TMatrixRC<T>& LinComb(T b, const TMatrixRC<T>& rc, sa_size_t first=0);
+
+  sa_size_t IMaxAbs(sa_size_t first=0);
   void Print(ostream & os) const ;
 
@@ -93,5 +86,5 @@
   //! Define Absolute value for int_8
   inline static double Abs_Value(int_8 v)  {return (v>0)? (double) v: (double) -v;}
-  //! Define Absolute value for uint_4
+  //! Define Absolute value for sa_size_t
   inline static double Abs_Value(uint_4 v) {return (double) v;}
   //! Define Absolute value for uint_8
@@ -112,5 +105,5 @@
   T*          data;    //!< pointer to the beginnig of interesting datas
   int_4       index;   //!< index of the line/column
-  uint_4      step;    //!< step of the line/column
+  sa_size_t      step;    //!< step of the line/column
   TRCKind     kind;    //!< type: line, column or diagonal
 };
@@ -128,5 +121,5 @@
     throw(SzMismatchError("TMatrixRC::operator * type mismatch\n"));
   T sum = 0;
-  for(uint_4 i=0; i<a.NElts(); i++) sum += a(i)*b(i);
+  for(sa_size_t i=0; i<a.NElts(); i++) sum += a(i)*b(i);
   return sum;
   }
@@ -138,5 +131,5 @@
  */
 template <class T>
-inline uint_4 TMatrixRC<T>::Step(const TMatrix<T>& m, TRCKind rckind)
+inline sa_size_t TMatrixRC<T>::Step(const TMatrix<T>& m, TRCKind rckind)
   { switch (rckind) { case TmatrixRow  : return m.Step(m.ColsKA());
                       case TmatrixCol  : return m.Step(m.RowsKA());
@@ -153,5 +146,5 @@
  */
 template <class T>
-inline T* TMatrixRC<T>::Org(const TMatrix<T>& m, TRCKind rckind, uint_4 index)
+inline T* TMatrixRC<T>::Org(const TMatrix<T>& m, TRCKind rckind, sa_size_t index)
   { switch (rckind) { case TmatrixRow  : return const_cast<T *>(&(m(index,0)));
                       case TmatrixCol  : return const_cast<T *>(&(m(0,index)));
@@ -160,5 +153,5 @@
 
 //! return number of elements for a TMatrixRC
-template <class T> inline uint_4 TMatrixRC<T>::NElts() const
+template <class T> inline sa_size_t TMatrixRC<T>::NElts() const
   { if (!matrix) return 0;
     switch (kind) { case TmatrixRow  : return matrix->NCols();
@@ -169,8 +162,8 @@
 //! access of element \b i
 template <class T>
-inline T& TMatrixRC<T>::operator()(uint_4 i) {return data[i*step];}
+inline T& TMatrixRC<T>::operator()(sa_size_t i) {return data[i*step];}
 //! access of element \b i
 template <class T>
-inline T  TMatrixRC<T>::operator()(uint_4 i) const {return data[i*step];}
+inline T  TMatrixRC<T>::operator()(sa_size_t i) const {return data[i*step];}
 
 ////////////////////////////////////////////////////////////////
@@ -190,5 +183,5 @@
   \param ind : number of the line or column
 */
-template <class T> TMatrixRC<T>::TMatrixRC(TMatrix<T>& m,TRCKind rckind,uint_4 ind)
+template <class T> TMatrixRC<T>::TMatrixRC(TMatrix<T>& m,TRCKind rckind,sa_size_t ind)
 : matrix(&m), data(Org(m,rckind,ind)),
   index(ind), step(Step(m,rckind)), kind(rckind)
@@ -203,5 +196,5 @@
 //! Return TMatrixRC for line \b r of matrix \b m
 template <class T> 
-TMatrixRC<T> TMatrixRC<T>::Row(TMatrix<T> & m, uint_4 r) 
+TMatrixRC<T> TMatrixRC<T>::Row(TMatrix<T> & m, sa_size_t r) 
 {
 TMatrixRC<T> rc(m, TmatrixRow, r);
@@ -211,5 +204,5 @@
 //! Return TMatrixRC for column \b r of matrix \b m
 template <class T> 
-TMatrixRC<T> TMatrixRC<T>::Col(TMatrix<T> & m, uint_4 c) 
+TMatrixRC<T> TMatrixRC<T>::Col(TMatrix<T> & m, sa_size_t c) 
 {
 TMatrixRC<T> rc(m, TmatrixCol, c);
@@ -226,28 +219,4 @@
 
 
-// ---- A virer   $CHECK$ Reza 03/2000
-// template <class T> int_4 TMatrixRC<T>::Next()
-// {
-// if (!matrix || kind==TmatrixDiag) return -1;
-// index++;
-// if(kind == TmatrixRow) {
-//   if(index > (int_4)matrix->NRows()) {index = (int_4)matrix->NRows(); return -1;}
-//   data += matrix->NCols();
-// } else {
-//   if (index > (int_4)matrix->NCols()) {index = (int_4)matrix->NCols(); return -1;}
-//   data++;
-// }
-// return index;
-// }
-
-// template <class T> int_4 TMatrixRC<T>::Prev()
-// {
-// if (!matrix || kind == TmatrixDiag) return -1;
-// index--;
-// if(index < 0) {index = 0; return -1;}
-// if(kind == TmatrixRow) data -= matrix->NCols();
-// else data--;
-// return index;
-// }
 
 //! Set column \b c for this TMatrixRC
@@ -299,36 +268,9 @@
 }
 
-// ---- A virer   $CHECK$ Reza 03/2000
-// template <class T> TVector<T> TMatrixRC<T>::GetVect() const
-// {
-// TVector<T> v(NElts());
-// for (uint_4 i=0; i<NElts(); i++) v(i) = (*this)(i);
-// return v;
-// }
-
-// template <class T> TMatrixRC<T>& TMatrixRC<T>::operator += (const TMatrixRC<T>& rc)
-// {
-// if ( NElts() != rc.NElts() )
-//   throw(SzMismatchError("TMatrixRC::operator+= size mismatch\n"));
-// if ( kind != rc.kind )
-//   throw(SzMismatchError("TMatrixRC::operator+= type mismatch\n"));
-// for (uint_4 i=0; i<NElts(); i++) (*this)(i) += rc(i);
-// return *this;
-// }
-
-// template <class T> TMatrixRC<T>& TMatrixRC<T>::operator -= (const TMatrixRC<T>& rc)
-// {
-// if( NElts() != rc.NElts() )
-//   throw(SzMismatchError("TMatrixRC::operator-= size mismatch\n"));
-// if( kind != rc.kind )
-//   throw(SzMismatchError("TMatrixRC::operator-= type mismatch\n"));
-// for(uint_4 i=0; i<NElts(); i++) (*this)(i) -= rc(i);
-// return *this;
-// }
 
 //! Operator to multiply by constant \b x
 template <class T> TMatrixRC<T>& TMatrixRC<T>::operator *= (T x)
 {
-for(uint_4 i=0; i<NElts(); i++) (*this)(i) *= x;
+for(sa_size_t i=0; i<NElts(); i++) (*this)(i) *= x;
 return *this;
 }
@@ -337,21 +279,9 @@
 template <class T> TMatrixRC<T>& TMatrixRC<T>::operator /= (T x)
 {
-for(uint_4 i=0; i<NElts(); i++) (*this)(i) /= x;
+for(sa_size_t i=0; i<NElts(); i++) (*this)(i) /= x;
 return *this;
 }
 
 
-// ---- A virer   $CHECK$ Reza 03/2000
-// template <class T> TMatrixRC<T>& TMatrixRC<T>::operator -= (T x)
-// {
-// for(uint_4 i=0; i<NElts(); i++) (*this)(i) -= x;
-// return *this;
-// }
-
-// template <class T> TMatrixRC<T>& TMatrixRC<T>::operator += (T x)
-// {
-// for(uint_4 i=0; i<NElts(); i++) (*this)(i) += x;
-// return *this;
-// }
 
 //! Linear combination
@@ -361,5 +291,5 @@
  */
 template <class T>
-TMatrixRC<T>& TMatrixRC<T>::LinComb(T a, T b, const TMatrixRC<T>& rc, uint_4 first)
+TMatrixRC<T>& TMatrixRC<T>::LinComb(T a, T b, const TMatrixRC<T>& rc, sa_size_t first)
 {
 if ( NElts() != rc.NElts() )
@@ -367,5 +297,5 @@
 if ( kind != rc.kind )
   throw(SzMismatchError("TMatrixRC::LinComb type mismatch\n"));
-for(uint_4 i=first; i<NElts(); i++) (*this)(i) = (*this)(i)*a + rc(i)*b;
+for(sa_size_t i=first; i<NElts(); i++) (*this)(i) = (*this)(i)*a + rc(i)*b;
 return *this;
 }
@@ -376,5 +306,5 @@
  */
 template <class T>
-TMatrixRC<T>& TMatrixRC<T>::LinComb(T b, const TMatrixRC<T>& rc, uint_4 first)
+TMatrixRC<T>& TMatrixRC<T>::LinComb(T b, const TMatrixRC<T>& rc, sa_size_t first)
 {
 if ( NElts() != rc.NElts() )
@@ -382,16 +312,16 @@
 if ( kind != rc.kind )
   throw(SzMismatchError("TMatrixRC::LinComb type mismatch\n"));
-for(uint_4 i=first; i<NElts(); i++) (*this)(i) += rc(i)*b;
+for(sa_size_t i=first; i<NElts(); i++) (*this)(i) += rc(i)*b;
 return *this;
 }
 
 //! Find maximum absolute value in TMatrixRC, search begin at \b first
-template <class T> uint_4 TMatrixRC<T>::IMaxAbs(uint_4 first)
+template <class T> sa_size_t TMatrixRC<T>::IMaxAbs(sa_size_t first)
 {
 if (first>NElts())
   throw(SzMismatchError("TMatrixRC::IMaxAbs size mismatch\n"));
-uint_4 imax = first;
+sa_size_t imax = first;
 double vmax = Abs_Value((*this)(first));
-for(uint_4 i=first+1; i<NElts(); i++) {
+for(sa_size_t i=first+1; i<NElts(); i++) {
   double v = Abs_Value((*this)(i));
   if(v > vmax) {vmax = v; imax = i;}
@@ -406,5 +336,5 @@
   os << " TMatrixRC<T>::Print(ostream & os) " << NElts() << " Kind=" 
      << kind << " Index=" << index << " Step= " << step << endl;
-  for(uint_4 i=0; i<NElts(); i++) {
+  for(sa_size_t i=0; i<NElts(); i++) {
     os << (*this)(i);
     if (kind == TmatrixCol)  os << endl;
@@ -423,5 +353,5 @@
   throw(SzMismatchError("TMatrixRC::Swap type mismatch\n"));
 if(rc1.data == rc2.data) return;
-for(uint_4 i=0; i<rc1.NElts(); i++)
+for(sa_size_t i=0; i<rc1.NElts(); i++)
   {T tmp = rc1(i); rc1(i) = rc2(i); rc2(i) = tmp;}
 }
@@ -468,5 +398,5 @@
 // {TMatrix A(a); TMatrix B(b); return (T) TMatrix::GausPiv(A,B);}
 {
-uint_4 n = a.NRows();
+sa_size_t n = a.NRows();
 if(n!=b.NRows())
   throw(SzMismatchError("TMatrix::GausPiv size mismatch\n"));
@@ -484,6 +414,6 @@
 } else if(GausPivScaling==PIV_ROW_SCALE) {
   double nrm = 0.;
-  for(uint_4 iii=0; iii<a.NRows(); iii++) {
-    uint_4 jjj; double vmax = -1.;
+  for(sa_size_t iii=0; iii<a.NRows(); iii++) {
+    sa_size_t jjj; double vmax = -1.;
     for(jjj=0; jjj<a.NCols(); jjj++) {
       double v = TMatrixRC<T>::Abs_Value(a(iii,jjj));
@@ -505,6 +435,6 @@
 } else {
   double vmin=MAXDOUBLE, vmax=0;
-  for(uint_4 iii=0; iii<a.NRows(); iii++)
-    for(uint_4 jjj=0; jjj<a.NCols(); jjj++) {
+  for(sa_size_t iii=0; iii<a.NRows(); iii++)
+    for(sa_size_t jjj=0; jjj<a.NCols(); jjj++) {
       double v = TMatrixRC<T>::Abs_Value(a(iii,jjj));
       if(v>vmax) vmax = v;
@@ -529,6 +459,6 @@
 TMatrixRC<T> pivRowb(b,TMatrixRC<T>::TmatrixRow);
 
-for(uint_4 k=0; k<n-1; k++) {
-  uint_4 iPiv = TMatrixRC<T>::Col(a, k).IMaxAbs(k);
+for(sa_size_t k=0; k<n-1; k++) {
+  sa_size_t iPiv = TMatrixRC<T>::Col(a, k).IMaxAbs(k);
   if(iPiv != k) {
     TMatrixRC<T> aIPiv(TMatrixRC<T>::Row(a,iPiv));
@@ -544,5 +474,5 @@
   pivRowa.SetRow(k); // to avoid constructors
   pivRowb.SetRow(k);
-  for (uint_4 i=k+1; i<n; i++) {
+  for (sa_size_t i=k+1; i<n; i++) {
     T r = -a(i,k)/pivot;
     TMatrixRC<T>::Row(a, i).LinComb(r, pivRowa); // + rapide que -= r * pivRowa
@@ -553,10 +483,10 @@
 
 // on remonte
-for(uint_4 kk=n-1; kk>0; kk--) {
+for(sa_size_t kk=n-1; kk>0; kk--) {
   T pivot = a(kk,kk);
   if( TMatrixRC<T>::Abs_Value(pivot) <= 1.e-50 ) return (T) 0;
   pivRowa.SetRow(kk); // to avoid constructors
   pivRowb.SetRow(kk);
-  for(uint_4 jj=0; jj<kk; jj++) {
+  for(sa_size_t jj=0; jj<kk; jj++) {
     T r = -a(jj,kk)/pivot;
     TMatrixRC<T>::Row(a, jj).LinComb(r, pivRowa);
@@ -565,5 +495,5 @@
 }
 
-for(uint_4 l=0; l<n; l++) {
+for(sa_size_t l=0; l<n; l++) {
   if( TMatrixRC<T>::Abs_Value(a(l,l)) <= 1.e-50 ) return (T) 0;
   TMatrixRC<T>::Row(b, l) /= a(l,l);
@@ -616,7 +546,7 @@
 template <class T>
 r_8 LinFitter<T>::LinFit(const TVector<T>& x, const TVector<T>& y,
-                       uint_4 nf, T (*f)(uint_4,T), TVector<T>& c)
-{
-uint_4 n = x.NElts();
+                       sa_size_t nf, T (*f)(sa_size_t,T), TVector<T>& c)
+{
+sa_size_t n = x.NElts();
 if (n != y.NElts()) 
   throw SzMismatchError("LinFitter<T>::LinFit(x,y,nf,f,c)/Error x.NElts() <> y.Nelts() ");
@@ -624,6 +554,6 @@
 TMatrix<T> fx(nf,n);
 
-for(uint_4 i=0; i<nf; i++)
-  for(uint_4 j=0; j<n; j++) fx(i,j) = f(i,x(j));
+for(sa_size_t i=0; i<nf; i++)
+  for(sa_size_t j=0; j<n; j++) fx(i,j) = f(i,x(j));
 
 return LinFit(fx,y,c);
@@ -643,14 +573,14 @@
 r_8 LinFitter<T>::LinFit(const TMatrix<T>& fx, const TVector<T>& y, TVector<T>& c)
 {
-uint_4 n = y.NElts();
+sa_size_t n = y.NElts();
 if (n != fx.NCol()) 
   throw SzMismatchError("LinFitter<T>::LinFit(fx, y, c)/Error y.NElts() <> fx.Nelts() ");
 
-uint_4 nf = fx.NRows();
+sa_size_t nf = fx.NRows();
 
 TMatrix<T> a(nf,nf);
 
-for(uint_4 j=0; j<nf; j++)
-  for(uint_4 k=j; k<nf; k++)
+for(sa_size_t j=0; j<nf; j++)
+  for(sa_size_t k=j; k<nf; k++)
      a(j,k) = a(k,j) = TMatrixRC<T>::Row(const_cast<TMatrix<T> &>(fx), j) 
 	             * TMatrixRC<T>::Row(const_cast<TMatrix<T> &>(fx), k);
@@ -663,7 +593,7 @@
 r_8 xi2 = 0., ax;
 T x;
-for(uint_4 k=0; k<n; k++) {
+for(sa_size_t k=0; k<n; k++) {
   x = (T) 0;
-  for(uint_4 i=0; i<nf; i++) x += c(i) * fx(i,k);
+  for(sa_size_t i=0; i<nf; i++) x += c(i) * fx(i,k);
   x -= y(k);
   ax = TMatrixRC<T>::Abs_Value(x);
@@ -690,14 +620,14 @@
 template <class T>
 r_8 LinFitter<T>::LinFit(const TVector<T>& x, const TVector<T>& y,
-             const TVector<T>& errY2, uint_4 nf, T (*f)(uint_4,T),
+             const TVector<T>& errY2, sa_size_t nf, T (*f)(sa_size_t,T),
                                   TVector<T>& c, TVector<T>& errC)
 {
-uint_4 n = x.NElts();
+sa_size_t n = x.NElts();
 if (n != y.NElts()) 
   throw SzMismatchError("LinFitter<T>::LinFit(x,y,errY2,nf,f,c,errC)/Error x.NElts() <> y.Nelts() ");
 
 TMatrix<T> fx(nf, n);
-for(uint_4 i=0; i<nf; i++)
-  for(uint_4 j=0; j<n; j++)
+for(sa_size_t i=0; i<nf; i++)
+  for(sa_size_t j=0; j<n; j++)
     fx(i,j) = f(i,x(j));
 
@@ -723,10 +653,10 @@
            const TVector<T>& errY2,TVector<T>& c, TVector<T>& errC)
 {
-uint_4 n = y.NElts();
+sa_size_t n = y.NElts();
 if( n != errY2.NElts()) 
   throw SzMismatchError("LinFitter<T>::LinFit(fx,y,errY2,c,errC)/Error y.NElts() <> errY2.Nelts() ");
 if( n != fx.NCol()) 
   throw SzMismatchError("LinFitter<T>::LinFit(fx,y,errY2,c,errC)/Error y.NElts() <> fx.NCols() ");
-uint_4 nf = fx.NRows();
+sa_size_t nf = fx.NRows();
 
 TMatrix<T> a(nf,nf);
@@ -735,20 +665,20 @@
 errC.Realloc(nf);
 
-for(uint_4 j=0; j<nf; j++)
-  for(uint_4 k=j; k<nf; k++) {
+for(sa_size_t j=0; j<nf; j++)
+  for(sa_size_t k=j; k<nf; k++) {
     T x=0;
     // Matrice a inverser
-    for(uint_4 l=0; l<n; l++) x += fx(j,l)*fx(k,l)/errY2(l);
+    for(sa_size_t l=0; l<n; l++) x += fx(j,l)*fx(k,l)/errY2(l);
     a(j,k) = a(k,j) = x;
   }
  
 TMatrix<T> d(nf,nf+1);
-for(uint_4 k=0; k<nf; k++) {
+for(sa_size_t k=0; k<nf; k++) {
   T x = (T) 0;
   // Second membre 1ere colonne
-  for(uint_4 l=0; l<n; l++) x += fx(k,l)*y(l)/errY2(l);             
+  for(sa_size_t l=0; l<n; l++) x += fx(k,l)*y(l)/errY2(l);             
   d(k,0) = x;
   // Reste second membre = Id.
-  for(uint_4 m=1; m<=nf; m++) d(k,m) = (k==m)?1:0;
+  for(sa_size_t m=1; m<=nf; m++) d(k,m) = (k==m)?1:0;
 }
 
@@ -757,5 +687,5 @@
 
 
-for(uint_4 l=0; l<nf; l++) {
+for(sa_size_t l=0; l<nf; l++) {
   c(l) = d(l,0);        // Parametres = 1ere colonne
   errC(l) = d(l,l+1);   // Erreurs = diag inverse.
@@ -764,7 +694,7 @@
 r_8 xi2 = 0., ax;
 T x;
-for(uint_4 jj=0; jj<n; jj++) {
+for(sa_size_t jj=0; jj<n; jj++) {
   x = (T) 0;
-  for(uint_4 ii=0; ii<nf; ii++) x += c(ii) * fx(ii,jj);
+  for(sa_size_t ii=0; ii<nf; ii++) x += c(ii) * fx(ii,jj);
     x -= y(jj);
     ax = TMatrixRC<T>::Abs_Value(x);
Index: /trunk/SophyaLib/TArray/sopemtx.h
===================================================================
--- /trunk/SophyaLib/TArray/sopemtx.h	(revision 3331)
+++ /trunk/SophyaLib/TArray/sopemtx.h	(revision 3332)
@@ -167,5 +167,5 @@
 //! Linear fitting
 r_8 LinFit(const TVector<T>& x, const TVector<T>& y,
-	   uint_4 nf, T (*f)(uint_4,T), TVector<T>& c);
+	   sa_size_t nf, T (*f)(sa_size_t,T), TVector<T>& c);
 
 //! Linear fitting
@@ -174,5 +174,5 @@
 //! Linear fitting with errors
 r_8 LinFit(const TVector<T>& x, const TVector<T>& y, const TVector<T>& errY2,
-           uint_4 nf,T (*f)(uint_4,T), TVector<T>& c, TVector<T>& errC);
+           sa_size_t nf,T (*f)(sa_size_t,T), TVector<T>& c, TVector<T>& errC);
 
 //! Linear fitting with errors
Index: /trunk/SophyaLib/TArray/tarray.cc
===================================================================
--- /trunk/SophyaLib/TArray/tarray.cc	(revision 3331)
+++ /trunk/SophyaLib/TArray/tarray.cc	(revision 3332)
@@ -160,5 +160,5 @@
   string exmsg = "TArray<T>::TArray(int_4, sa_size_t *,  NDataBlock<T> & ... )";
   if (!UpdateSizes(ndim, siz, step, offset, exmsg))  throw( ParmError(exmsg) );
-  if (mNDBlock.Size() < ComputeTotalSize(ndim, siz, step, offset)) {
+  if (mNDBlock.Size() < (size_t)ComputeTotalSize(ndim, siz, step, offset)) {
     exmsg += " DataBlock.Size() < ComputeTotalSize(...) " ;
     throw( ParmError(exmsg) );
@@ -1395,8 +1395,8 @@
 //! Returns the sum of all array elements squared (Sum_k((*this)(k)*(*this)(k)).
 template <class T>
-T TArray<T>::SumX2() const
-{
-  if (NbDimensions() < 1) 
-    throw RangeCheckError("TArray<T>::SumX2()  - Not Allocated Array ! ");
+T TArray<T>::SumSq() const
+{
+  if (NbDimensions() < 1) 
+    throw RangeCheckError("TArray<T>::SumSq()  - Not Allocated Array ! ");
   T ret=0;
   const T * pe;
@@ -1420,4 +1420,59 @@
   return ret;
 }
+
+/*!
+\brief Returns the array norm squared, defined as  Sum_k [ el(k)* el(k) ] 
+  For arrays with integer or real data, this method calls SumSq(), which computes
+  the sum of array elements squared. For complex arrays, it computes and returns 
+  the sum of array elements module squared (= Sum_k [el(k)*conj(el(k))]
+*/
+template <class T>
+T TArray<T>::Norm2() const
+{
+  return SumSq();
+}
+
+
+// Fonction auxiliaire pour specialisation de la methode Norm2() pour tableaux complexes
+template <class T> 
+complex<T>  _ComputeComplexNorm_Private_(TArray< complex<T> > const & ca) 
+{
+  if (ca.NbDimensions() < 1) 
+    throw RangeCheckError("TArray< complex<T> >::Norm2()  - Not Allocated Array ! ");
+  complex<T> ret= complex<T>(0., 0.);
+  const complex<T> * pe;
+  sa_size_t j,k;
+  if (ca.AvgStep() > 0)   {  // regularly spaced elements
+    sa_size_t step = ca.AvgStep();
+    sa_size_t maxx = ca.Size()*step;
+    pe = ca.Data();
+    for(k=0; k<maxx; k+=step )  ret += pe[k]*conj(pe[k]);
+  }
+  else {    // Non regular data spacing ...
+    int_4 ka = ca.MaxSizeKA();
+    sa_size_t step = ca.Step(ka);
+    sa_size_t gpas = ca.Size(ka)*step;
+    sa_size_t naxa = ca.Size()/ca.Size(ka);
+    for(j=0; j<naxa; j++)  {
+      pe = ca.DataBlock().Begin()+ca.Offset(ka,j);
+      for(k=0; k<gpas; k+=step)  ret += pe[k]*conj(pe[k]) ;
+    }
+  }
+  return ret;
+
+}
+
+// --- Specialisation de la methode Norm2() pour tableaux complexes ---
+DECL_TEMP_SPEC  /* equivalent a template <> , pour SGI-CC en particulier */
+complex<r_4> TArray< complex<r_4> >::Norm2() const
+{
+  return  _ComputeComplexNorm_Private_(*this);
+}
+DECL_TEMP_SPEC  /* equivalent a template <> , pour SGI-CC en particulier */
+complex<r_8> TArray< complex<r_8> >::Norm2() const
+{
+  return  _ComputeComplexNorm_Private_(*this);
+}
+//-------------------
 
 //! Return the minimum and the maximum values of the array elements 
Index: /trunk/SophyaLib/TArray/tarray.h
===================================================================
--- /trunk/SophyaLib/TArray/tarray.h	(revision 3331)
+++ /trunk/SophyaLib/TArray/tarray.h	(revision 3332)
@@ -193,7 +193,4 @@
 // Calcul du produit scalaire ( Somme_i (*this)(i)*a(i) )
   virtual T ScalarProduct(const TArray<T>& a) const ;
-// Norme(^2) 
-  //! Returns the squarred of the array norm, defined as  Sum_k (*this)(k)*(*this)(k)
-  inline T Norm2() const { return ScalarProduct(*this); }
 
 // Somme et produit des elements
@@ -201,6 +198,8 @@
   virtual T Product() const ;
 // Somme du carre des elements
-  virtual T SumX2() const;
-// Valeur min et max des elements
+  virtual T SumSq() const;
+//  Norme^2 , identique a SumSq pour tableaux reels/integer , sum[el * conj(el)] pour complexe
+  virtual T Norm2() const; 
+// Valeur min et max des elements (sauf tableaux complexes -> exception)
   virtual void MinMax(T& min, T& max) const ;
 
