Index: trunk/SophyaLib/NTools/matrix.cc
===================================================================
--- trunk/SophyaLib/NTools/matrix.cc	(revision 490)
+++ trunk/SophyaLib/NTools/matrix.cc	(revision 508)
@@ -1,3 +1,3 @@
-// $Id: matrix.cc,v 1.5 1999-10-21 15:25:49 ansari Exp $
+// $Id: matrix.cc,v 1.6 1999-10-25 10:36:09 ansari Exp $
 
 #include "machdefs.h"
@@ -26,5 +26,5 @@
 
 //++
-// Class	Matrix
+// Class	OMatrix
 // Lib	Outils++
 // include	matrix.h
@@ -38,5 +38,5 @@
 
 //++
-Matrix::Matrix()
+OMatrix::OMatrix()
 //
 //	Construit une matrice 1x1 (pour ppersist).
@@ -50,5 +50,5 @@
 
 //++
-Matrix::Matrix(int r, int c)
+OMatrix::OMatrix(int r, int c)
 //
 //	Construit une matrice de r lignes et c colonnes.
@@ -62,5 +62,5 @@
 
 //++
-Matrix::Matrix(int r, int c, double* values)
+OMatrix::OMatrix(int r, int c, double* values)
 //
 //	Construit une matrice de r lignes et c colonnes. On fournit
@@ -73,5 +73,5 @@
 
 //++
-Matrix::Matrix(const Matrix& a)
+OMatrix::OMatrix(const OMatrix& a)
 //
 //	Constructeur par copie.
@@ -85,5 +85,5 @@
 
 //++
-Matrix::Matrix(const TMatrix<r_8>& a)
+OMatrix::OMatrix(const TMatrix<r_8>& a)
 //
 //	Constructeur par copie a partir d'une TMatrix<r_8>.
@@ -99,5 +99,5 @@
 
 
-Matrix::~Matrix()
+OMatrix::~OMatrix()
 {
   DBASSERT(ndata == nr*nc);
@@ -111,5 +111,5 @@
 
 //++
-void Matrix::Zero()
+void OMatrix::Zero()
 //
 //	Remise à zero de tous les éléments
@@ -121,5 +121,5 @@
 
 //++
-void Matrix::Realloc(int r, int c, bool force)
+void OMatrix::Realloc(int r, int c, bool force)
 //
 //	Change la taille de la matrice. Réallocation physique seulement si
@@ -145,5 +145,5 @@
 
 //++
-Matrix& Matrix::operator = (const Matrix& a)
+OMatrix& OMatrix::operator = (const OMatrix& a)
 //
 //	Opérateur d'affectation.
@@ -158,5 +158,5 @@
 
 //++
-Matrix& Matrix::operator = (double x)
+OMatrix& OMatrix::operator = (double x)
 //
 //	Opérateur d'affectation depuis scalaire : identité * scalaire.
@@ -176,5 +176,5 @@
 
 //++
-ostream& operator << (ostream& s, const Matrix& a)
+ostream& operator << (ostream& s, const OMatrix& a)
 //
 //	Impression
@@ -194,5 +194,5 @@
 
 //++
-Matrix& Matrix::operator *= (double b)
+OMatrix& OMatrix::operator *= (double b)
 //
 //--
@@ -208,5 +208,5 @@
 
 //++
-Matrix& Matrix::operator += (double b)
+OMatrix& OMatrix::operator += (double b)
 //
 //--
@@ -222,5 +222,5 @@
 
 //++
-Matrix& Matrix::operator -= (double b)
+OMatrix& OMatrix::operator -= (double b)
 //
 //--
@@ -236,5 +236,5 @@
 
 //++
-Matrix& Matrix::operator /= (double b)
+OMatrix& OMatrix::operator /= (double b)
 //
 //--
@@ -251,54 +251,54 @@
 
 //++
-Matrix operator * (const Matrix& a, double b)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator * (const OMatrix& a, double b)
+//
+//--
+{
+  OMatrix result(a);
   return (result *= b);
 }
 
 //++
-Matrix operator * (double b, const Matrix& a)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator * (double b, const OMatrix& a)
+//
+//--
+{
+  OMatrix result(a);
   return (result *= b);
 }
 
 //++
-Matrix operator + (const Matrix& a, double b)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator + (const OMatrix& a, double b)
+//
+//--
+{
+  OMatrix result(a);
   return (result += b);
 }
 
 //++
-Matrix operator + (double b, const Matrix& a)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator + (double b, const OMatrix& a)
+//
+//--
+{
+  OMatrix result(a);
   return (result += b);
 }
 
 //++
-Matrix operator - (const Matrix& a, double b)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator - (const OMatrix& a, double b)
+//
+//--
+{
+  OMatrix result(a);
   return (result -= b);
 }
 
 //++
-Matrix operator - (double b, const Matrix& a)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator - (double b, const OMatrix& a)
+//
+//--
+{
+  OMatrix result(a);
   result *= -1;
   return (result += b);
@@ -306,63 +306,63 @@
 
 //++
-Matrix operator / (const Matrix& a, double b)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator / (const OMatrix& a, double b)
+//
+//--
+{
+  OMatrix result(a);
   return (result /= b);
 }
 
 //++
-Matrix operator * (const Matrix& a, int b)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator * (const OMatrix& a, int b)
+//
+//--
+{
+  OMatrix result(a);
   return (result *= b);
 }
 
 //++
-Matrix operator * (int b, const Matrix& a)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator * (int b, const OMatrix& a)
+//
+//--
+{
+  OMatrix result(a);
   return (result *= b);
 }
 
 //++
-Matrix operator + (const Matrix& a, int b)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator + (const OMatrix& a, int b)
+//
+//--
+{
+  OMatrix result(a);
   return (result += b);
 }
 
 //++
-Matrix operator + (int b, const Matrix& a)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator + (int b, const OMatrix& a)
+//
+//--
+{
+  OMatrix result(a);
   return (result += b);
 }
 
 //++
-Matrix operator - (const Matrix& a, int b)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator - (const OMatrix& a, int b)
+//
+//--
+{
+  OMatrix result(a);
   return (result -= b);
 }
 
 //++
-Matrix operator - (int b, const Matrix& a)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator - (int b, const OMatrix& a)
+//
+//--
+{
+  OMatrix result(a);
   result *= -1;
   return (result += b);
@@ -370,9 +370,9 @@
 
 //++
-Matrix operator / (const Matrix& a, int b)
-//
-//--
-{
-  Matrix result(a);
+OMatrix operator / (const OMatrix& a, int b)
+//
+//--
+{
+  OMatrix result(a);
   return (result /= b);
 }
@@ -382,5 +382,5 @@
 
 //++
-Matrix& Matrix::operator += (const Matrix& a)
+OMatrix& OMatrix::operator += (const OMatrix& a)
 //
 //--
@@ -399,5 +399,5 @@
 
 //++
-Matrix& Matrix::operator -= (const Matrix& a)
+OMatrix& OMatrix::operator -= (const OMatrix& a)
 //
 //--
@@ -417,5 +417,5 @@
 
 //++
-Matrix& Matrix::operator *= (const Matrix& a)
+OMatrix& OMatrix::operator *= (const OMatrix& a)
 //
 //--
@@ -448,5 +448,5 @@
 
 //++
-Matrix operator + (const Matrix& a, const Matrix& b)
+OMatrix operator + (const OMatrix& a, const OMatrix& b)
 //
 //--
@@ -454,10 +454,10 @@
   if (b.nc != a.nc || b.nr != a.nr) THROW(sizeMismatchErr);
 
-  Matrix c(a);
+  OMatrix c(a);
   return (c += b);
 }
 
 //++
-Matrix operator - (const Matrix& a, const Matrix& b)
+OMatrix operator - (const OMatrix& a, const OMatrix& b)
 //
 //--
@@ -465,5 +465,5 @@
   if (b.nc != a.nc || b.nr != a.nr) THROW(sizeMismatchErr);
 
-  Matrix c(a);
+  OMatrix c(a);
   return (c -= b);
 }
@@ -471,9 +471,9 @@
 #if 0
 
-Matrix operator * (const Matrix& a, const Matrix& b)
+OMatrix operator * (const OMatrix& a, const OMatrix& b)
 {
   if (a.nc != b.nr) THROW(sizeMismatchErr);
 
-  Matrix c(a.nr, b.nc);
+  OMatrix c(a.nr, b.nc);
 
   double* pc = c.data;
@@ -505,5 +505,5 @@
 
 //++
-Matrix operator * (const Matrix& a, const Matrix& b)
+OMatrix operator * (const OMatrix& a, const OMatrix& b)
 //
 //--
@@ -511,5 +511,5 @@
   if (a.nc != b.nr) THROW(sizeMismatchErr);
 
-  Matrix c(a.nr, b.nc);
+  OMatrix c(a.nr, b.nc);
 
   for (int rc = 0; rc < c.nr; rc++)
@@ -527,5 +527,5 @@
 
 //++
-Matrix Matrix::Transpose() const
+OMatrix OMatrix::Transpose() const
 //
 //	Retourne la transposée.
@@ -536,5 +536,5 @@
 {
 #if !HAS_NAMED_RETURN
-Matrix a(nc,nr);
+OMatrix a(nc,nr);
 #endif
   for (int i=0; i<nr; i++)
@@ -548,5 +548,5 @@
 
 //++
-Matrix Matrix::Inverse() const
+OMatrix OMatrix::Inverse() const
 //
 //	Retourne la matrice inverse.
@@ -559,9 +559,9 @@
 {
 #if !HAS_NAMED_RETURN
-Matrix b(nc,nr);
-#endif
-  Matrix a(*this);
+OMatrix b(nc,nr);
+#endif
+  OMatrix a(*this);
   b = 1.0;
-  if (fabs(Matrix::GausPiv(a,b)) < 1.e-50) THROW(singMatxErr);
+  if (fabs(OMatrix::GausPiv(a,b)) < 1.e-50) THROW(singMatxErr);
 #if !HAS_NAMED_RETURN
 return b;
@@ -570,5 +570,5 @@
 
 
-void Matrix::WriteSelf(POutPersist& s) const
+void OMatrix::WriteSelf(POutPersist& s) const
 {
   ASSERT(ndata == nr*nc);
@@ -577,5 +577,5 @@
 }
 
-void Matrix::ReadSelf(PInPersist& s)
+void OMatrix::ReadSelf(PInPersist& s)
 {
   int_4 r,c;
@@ -587,9 +587,9 @@
 
 
-MatrixRC::MatrixRC()
+OMatrixRC::OMatrixRC()
 : matrix(0), data(0), index(0), step(0)
 {}
 
-MatrixRC::MatrixRC(Matrix& m, RCKind rckind, int ind)
+OMatrixRC::OMatrixRC(OMatrix& m, RCKind rckind, int ind)
 : matrix(&m), data(Org(m,rckind,ind)),
   index(ind), step(Step(m,rckind)), kind(rckind)
@@ -599,5 +599,5 @@
 
 
-int MatrixRC::Next()
+int OMatrixRC::Next()
 {
   if (!matrix) return -1;             // Failure ?
@@ -621,5 +621,5 @@
 
 
-int MatrixRC::Prev()
+int OMatrixRC::Prev()
 {
   if (!matrix) return -1;             // Failure ?
@@ -638,5 +638,5 @@
 
 
-int MatrixRC::SetCol(int c)
+int OMatrixRC::SetCol(int c)
 {
   if (!matrix) return -1;             // Failure ?
@@ -650,5 +650,5 @@
 
 
-int MatrixRC::SetRow(int r)
+int OMatrixRC::SetRow(int r)
 {
   if (!matrix) return -1;             // Failure ?
@@ -662,5 +662,5 @@
 
 
-int MatrixRC::SetDiag()
+int OMatrixRC::SetDiag()
 {
   if (!matrix) return -1;             // Failure ?
@@ -674,5 +674,5 @@
 
 
-MatrixRC& MatrixRC::operator = (const MatrixRC& rc)
+OMatrixRC& OMatrixRC::operator = (const OMatrixRC& rc)
 {
   matrix = rc.matrix;
@@ -684,6 +684,6 @@
 }
 
-//MatrixRC::operator Vector() const
-Vector MatrixRC::GetVect() const
+//OMatrixRC::operator OVector() const
+OVector OMatrixRC::GetVect() const
 #if HAS_NAMED_RETURN
 return v(NElts())
@@ -691,5 +691,5 @@
 {
 #if !HAS_NAMED_RETURN
-  Vector v(NElts());
+  OVector v(NElts());
 #endif
   int n = NElts();
@@ -702,5 +702,5 @@
 
 
-MatrixRC& MatrixRC::operator += (const MatrixRC& rc)
+OMatrixRC& OMatrixRC::operator += (const OMatrixRC& rc)
 {
   int n = NElts();
@@ -716,5 +716,5 @@
 
 
-MatrixRC& MatrixRC::operator -= (const MatrixRC& rc)
+OMatrixRC& OMatrixRC::operator -= (const OMatrixRC& rc)
 {
   int n = NElts();
@@ -729,5 +729,5 @@
 
 
-MatrixRC& MatrixRC::operator *= (double x)
+OMatrixRC& OMatrixRC::operator *= (double x)
 {
   int n = NElts();
@@ -740,5 +740,5 @@
 
 
-MatrixRC& MatrixRC::operator /= (double x)
+OMatrixRC& OMatrixRC::operator /= (double x)
 {
   int n = NElts();
@@ -751,5 +751,5 @@
 
 
-MatrixRC& MatrixRC::operator -= (double x)
+OMatrixRC& OMatrixRC::operator -= (double x)
 {
   int n = NElts();
@@ -762,5 +762,5 @@
 
 
-MatrixRC& MatrixRC::operator += (double x)
+OMatrixRC& OMatrixRC::operator += (double x)
 {
   int n = NElts();
@@ -774,5 +774,5 @@
 
 
-double operator * (const MatrixRC& a, const MatrixRC& b)
+double operator * (const OMatrixRC& a, const OMatrixRC& b)
 {
   int n = a.NElts();
@@ -786,5 +786,5 @@
 
 
-MatrixRC& MatrixRC::LinComb(double a, double b, const MatrixRC& rc, int first)
+OMatrixRC& OMatrixRC::LinComb(double a, double b, const OMatrixRC& rc, int first)
 {
   int n = NElts();
@@ -799,5 +799,5 @@
 
 
-MatrixRC& MatrixRC::LinComb(double b, const MatrixRC& rc, int first)
+OMatrixRC& OMatrixRC::LinComb(double b, const OMatrixRC& rc, int first)
 {
   int n = NElts();
@@ -813,11 +813,11 @@
 
 
-MatrixRC Matrix::Row(int r) const
+OMatrixRC OMatrix::Row(int r) const
 #if HAS_NAMED_RETURN
-return rc((Matrix&)*this, matrixRow, r)
+return rc((OMatrix&)*this, matrixRow, r)
 #endif
 {
 #if !HAS_NAMED_RETURN
-        MatrixRC rc((Matrix&)*this, matrixRow, r);
+        OMatrixRC rc((OMatrix&)*this, matrixRow, r);
         return rc;
 #endif
@@ -825,11 +825,11 @@
 
 
-MatrixRC Matrix::Col(int c) const
+OMatrixRC OMatrix::Col(int c) const
 #if HAS_NAMED_RETURN
-return rc((Matrix&)*this, matrixCol, c)
+return rc((OMatrix&)*this, matrixCol, c)
 #endif
 {
 #if !HAS_NAMED_RETURN
-        MatrixRC rc((Matrix&)*this, matrixCol, c);
+        OMatrixRC rc((OMatrix&)*this, matrixCol, c);
         return rc;
 #endif
@@ -837,11 +837,11 @@
 
 
-MatrixRC Matrix::Diag() const
+OMatrixRC OMatrix::Diag() const
 #if HAS_NAMED_RETURN
-return rc((Matrix&)*this, matrixDiag)
+return rc((OMatrix&)*this, matrixDiag)
 #endif
 {
 #if !HAS_NAMED_RETURN
-        MatrixRC rc((Matrix&)*this, matrixDiag);
+        OMatrixRC rc((OMatrix&)*this, matrixDiag);
         return rc;
 #endif
@@ -849,5 +849,5 @@
 
 
-int MatrixRC::IMaxAbs(int first)
+int OMatrixRC::IMaxAbs(int first)
 {
   int n=NElts();
@@ -865,5 +865,5 @@
 
 
-void MatrixRC::Swap(MatrixRC& rc1, MatrixRC& rc2)
+void OMatrixRC::Swap(OMatrixRC& rc1, OMatrixRC& rc2)
 {
   int n=rc1.NElts();
@@ -877,5 +877,5 @@
 
 
-double Matrix::GausPiv(Matrix& a, Matrix& b)
+double OMatrix::GausPiv(OMatrix& a, OMatrix& b)
 {
   int n = a.NRows();
@@ -902,5 +902,5 @@
     double ld = a.NRows() * log(nrm);
     if (ld <= LN_MINDOUBLE || ld >= LN_MAXDOUBLE) {
-     // cerr << "Matrix warning, overflow for det" << endl;
+     // cerr << "OMatrix warning, overflow for det" << endl;
     } else {
       det = exp(ld);
@@ -908,16 +908,16 @@
   }
 
-  MatrixRC pivRowa(a,matrixRow);
-  MatrixRC pivRowb(b,matrixRow);
+  OMatrixRC pivRowa(a,matrixRow);
+  OMatrixRC pivRowb(b,matrixRow);
 
   for (int k=0; k<n-1; k++) {
     int iPiv = a.Col(k).IMaxAbs(k);
     if (iPiv != k) {
-      MatrixRC aIPiv(a.Row(iPiv));
-      MatrixRC aK(a.Row(k));
-      MatrixRC::Swap(aIPiv,aK);
-      MatrixRC bIPiv(b.Row(iPiv));
-      MatrixRC bK(b.Row(k));
-      MatrixRC::Swap(bIPiv,bK);
+      OMatrixRC aIPiv(a.Row(iPiv));
+      OMatrixRC aK(a.Row(k));
+      OMatrixRC::Swap(aIPiv,aK);
+      OMatrixRC bIPiv(b.Row(iPiv));
+      OMatrixRC bK(b.Row(k));
+      OMatrixRC::Swap(bIPiv,bK);
     }
     double pivot = a(k,k);
@@ -958,5 +958,5 @@
 
 //++
-double Matrix::Norm1()
+double OMatrix::Norm1()
 //
 //	Norme 1 : somme des valeurs absolues.
@@ -970,5 +970,5 @@
 
 //++
-double Matrix::Norm2()
+double OMatrix::Norm2()
 //
 //	Norme 2, euclidienne.
@@ -983,5 +983,5 @@
 //////////////////////////////////////////////////////////
 //++
-Matrix Matrix::FitResidus(GeneralFit& gfit
+OMatrix OMatrix::FitResidus(GeneralFit& gfit
                ,double xorg,double yorg,double dx,double dy)
 //
@@ -992,10 +992,10 @@
 {
 if(NCol()<=0||NRows()<=0)
-  throw(SzMismatchError("Matrix::FitResidus: size mismatch\n"));
+  throw(SzMismatchError("OMatrix::FitResidus: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
 if(f==NULL)
-  throw(NullPtrError("Matrix::FitResidus: NULL pointer\n"));
-Vector par = gfit.GetParm();
-Matrix m(*this);
+  throw(NullPtrError("OMatrix::FitResidus: NULL pointer\n"));
+OVector par = gfit.GetParm();
+OMatrix m(*this);
 for(int i=0;i<NRows();i++) for(int j=0;j<NCol();j++) {
   double x[2] = {xorg+j*dx,yorg+i*dy};
@@ -1006,5 +1006,5 @@
 
 //++
-Matrix Matrix::FitFunction(GeneralFit& gfit
+OMatrix OMatrix::FitFunction(GeneralFit& gfit
                ,double xorg,double yorg,double dx,double dy)
 //
@@ -1015,10 +1015,10 @@
 {
 if(NCol()<=0||NRows()<=0)
-  throw(SzMismatchError("Matrix::FitFunction: size mismatch\n"));
+  throw(SzMismatchError("OMatrix::FitFunction: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
 if(f==NULL)
-  throw(NullPtrError("Matrix::FitFunction: NULL pointer\n"));
-Vector par = gfit.GetParm();
-Matrix m(*this);
+  throw(NullPtrError("OMatrix::FitFunction: NULL pointer\n"));
+OVector par = gfit.GetParm();
+OMatrix m(*this);
 for(int i=0;i<NRows();i++) for(int j=0;j<NCol();j++) {
   double x[2] = {xorg+j*dx,yorg+i*dy};
