Index: trunk/SophyaLib/NTools/matrix.h
===================================================================
--- trunk/SophyaLib/NTools/matrix.h	(revision 494)
+++ trunk/SophyaLib/NTools/matrix.h	(revision 508)
@@ -18,20 +18,20 @@
 // <summary> Operations matricielles </summary>
 // Operations matricielles, algebre lineaire...
-class Matrix : public PPersist, public AnyDataObj {
-  friend class Vector;
-  friend class MatrixRC;
+class OMatrix : public PPersist, public AnyDataObj {
+  friend class OVector;
+  friend class OMatrixRC;
   friend class TMatrix<r_8>;
 public:
-  Matrix();
+  OMatrix();
   // Constructeur, matrice a zero
-  Matrix(int r, int c);
+  OMatrix(int r, int c);
   // Constructeur avec des valeurs. Pas d'allocation, juste pointe.
-  Matrix(int r, int c, double* values);
+  OMatrix(int r, int c, double* values);
   // Constructeur par copie
-  Matrix(const Matrix& a);
+  OMatrix(const OMatrix& a);
   // Constructeur par copie a partir d'une TMatrix<r_8>
-  Matrix(const TMatrix<r_8>& a);
+  OMatrix(const TMatrix<r_8>& a);
   // Destructeur
-  virtual ~Matrix();
+  virtual ~OMatrix();
 
   // Construction automatique pour PPF
@@ -39,5 +39,5 @@
   enum {classId = ClassId_Matrix};
   int_4                 ClassId() const         { return classId; }
-  static PPersist*      Create() {return new Matrix(1,1);}
+  static PPersist*      Create() {return new OMatrix(1,1);}
   // </group>
 
@@ -49,10 +49,10 @@
 
   // Operateur d'affectation
-  Matrix& operator = (const Matrix& a);
+  OMatrix& operator = (const OMatrix& a);
   // Affectation depuis scalaire : identite * scalaire
-  Matrix& operator = (double x);
+  OMatrix& operator = (double x);
 
   // Impression
-  friend ostream& operator << (ostream& s, const Matrix& a);
+  friend ostream& operator << (ostream& s, const OMatrix& a);
 
   // Acces aux elements
@@ -74,50 +74,50 @@
   // Operations matricielles avec scalaire, allocation d'une nouvelle matrice
   // <group>
-  friend Matrix operator * (const Matrix& a, double b);
-  friend Matrix operator * (double b, const Matrix& a);
-  friend Matrix operator + (const Matrix& a, double b);
-  friend Matrix operator + (double b, const Matrix& a);
-  friend Matrix operator - (const Matrix& a, double b);
-  friend Matrix operator - (double b, const Matrix& a);
-  friend Matrix operator / (const Matrix& a, double b);
+  friend OMatrix operator * (const OMatrix& a, double b);
+  friend OMatrix operator * (double b, const OMatrix& a);
+  friend OMatrix operator + (const OMatrix& a, double b);
+  friend OMatrix operator + (double b, const OMatrix& a);
+  friend OMatrix operator - (const OMatrix& a, double b);
+  friend OMatrix operator - (double b, const OMatrix& a);
+  friend OMatrix operator / (const OMatrix& a, double b);
   // </group>
 
   // Operations matricielles avec scalaires entiers, pour eviter l'appel
   // du constructeur de vecteur a partir d'un entier...
-  // sinon v*2 = v * Vector(2), BUG !
-  // <group>
-  friend Matrix operator * (const Matrix& a, int b);
-  friend Matrix operator * (int b, const Matrix& a);
-  friend Matrix operator + (const Matrix& a, int b);
-  friend Matrix operator + (int b, const Matrix& a);
-  friend Matrix operator - (const Matrix& a, int b);
-  friend Matrix operator - (int b, const Matrix& a);
-  friend Matrix operator / (const Matrix& a, int b);
+  // sinon v*2 = v * OVector(2), BUG !
+  // <group>
+  friend OMatrix operator * (const OMatrix& a, int b);
+  friend OMatrix operator * (int b, const OMatrix& a);
+  friend OMatrix operator + (const OMatrix& a, int b);
+  friend OMatrix operator + (int b, const OMatrix& a);
+  friend OMatrix operator - (const OMatrix& a, int b);
+  friend OMatrix operator - (int b, const OMatrix& a);
+  friend OMatrix operator / (const OMatrix& a, int b);
   // </group>
 
   // Operations matricielles "en place", avec scalaire
   // <group>
-  Matrix& operator *= (double b);
-  Matrix& operator += (double b);
-  Matrix& operator -= (double b);
-  Matrix& operator /= (double b);
+  OMatrix& operator *= (double b);
+  OMatrix& operator += (double b);
+  OMatrix& operator -= (double b);
+  OMatrix& operator /= (double b);
   // </group>
 
   // Operations matricielles
   // <group>
-  friend Matrix operator * (const Matrix& a, const Matrix& b);
-  friend Matrix operator + (const Matrix& a, const Matrix& b);
-  friend Matrix operator - (const Matrix& a, const Matrix& b);
-
-  Matrix& operator *= (const Matrix& a);
-  Matrix& operator += (const Matrix& b);
-  Matrix& operator -= (const Matrix& b);
+  friend OMatrix operator * (const OMatrix& a, const OMatrix& b);
+  friend OMatrix operator + (const OMatrix& a, const OMatrix& b);
+  friend OMatrix operator - (const OMatrix& a, const OMatrix& b);
+
+  OMatrix& operator *= (const OMatrix& a);
+  OMatrix& operator += (const OMatrix& b);
+  OMatrix& operator -= (const OMatrix& b);
   // </group>
 
   // Matrice transposee
-  Matrix Transpose() const;
+  OMatrix Transpose() const;
   // Matrice inverse
   // <thrown> singMatxErr </thrown>
-  Matrix Inverse() const;
+  OMatrix Inverse() const;
 
   // Nombre de lignes
@@ -134,10 +134,10 @@
   // Acces aux rangees et colonnes
   // <group>
-  MatrixRC Row(int r) const;
-  MatrixRC Col(int c) const;
-  MatrixRC Diag() const;
-  // </group>
-  /* Versions const ? Alors il faut constructeur const pour MatrixRC,    */
-  /* mais MatrixRC contient un Matrix* qui detruit const....             */
+  OMatrixRC Row(int r) const;
+  OMatrixRC Col(int c) const;
+  OMatrixRC Diag() const;
+  // </group>
+  /* Versions const ? Alors il faut constructeur const pour OMatrixRC,    */
+  /* mais OMatrixRC contient un OMatrix* qui detruit const....             */
   /* mais en eux-meme, ils ne modifient pas la matrice. Ils permettent   */
   /* de le faire...                                                      */
@@ -145,10 +145,10 @@
   // Pivot de Gauss : diagonalise la matrice A, en effectuant les memes
   // operations sur la matrice B
-  static double GausPiv(Matrix& A, Matrix& B);
+  static double GausPiv(OMatrix& A, OMatrix& B);
 
   // Residus et fonction fittees.
-  Matrix FitResidus(GeneralFit& gfit
+  OMatrix FitResidus(GeneralFit& gfit
             ,double xorg=0.,double yorg=0.,double dx=1.,double dy=1.);
-  Matrix FitFunction(GeneralFit& gfit
+  OMatrix FitFunction(GeneralFit& gfit
             ,double xorg=0.,double yorg=0.,double dx=1.,double dy=1.);
 
@@ -163,5 +163,5 @@
 
 
-inline r_8& Matrix::operator()(int r, int c)
+inline r_8& OMatrix::operator()(int r, int c)
 {
 #ifdef RGCHECK
@@ -172,5 +172,5 @@
 
 
-inline r_8 const& Matrix::operator()(int r, int c) const
+inline r_8 const& OMatrix::operator()(int r, int c) const
 {
 #ifdef RGCHECK
@@ -186,11 +186,11 @@
 // Permet d'acceder a une ligne ou colonne d'une matrice, en place, comme
 // avec un vecteur.
-class MatrixRC EXC_AWARE {
-friend class Vector;
-friend class Matrix;
+class OMatrixRC EXC_AWARE {
+friend class OVector;
+friend class OMatrix;
 public:
-  MatrixRC();
-
-  virtual ~MatrixRC() {}
+  OMatrixRC();
+
+  virtual ~OMatrixRC() {}
 
   int Next();
@@ -200,6 +200,6 @@
   int SetDiag();
 
-  static int Step(const Matrix& m, RCKind rckind);
-  static double* Org(const Matrix&, RCKind rckind, int ind=0);
+  static int Step(const OMatrix& m, RCKind rckind);
+  static double* Org(const OMatrix&, RCKind rckind, int ind=0);
 
   int NElts() const;
@@ -207,30 +207,30 @@
   r_8  operator()(int i) const;
 
-  MatrixRC& operator = (const MatrixRC& rc);
-  //operator Vector() const;
-  Vector GetVect() const;
-
-  MatrixRC& operator += (const MatrixRC& rc);
-  MatrixRC& operator -= (const MatrixRC& rc);
-
-  MatrixRC& operator *= (double x);
-  MatrixRC& operator /= (double x);
-  MatrixRC& operator -= (double x);
-  MatrixRC& operator += (double x);
-
-  friend double operator * (const MatrixRC& a, const MatrixRC& b);
-
-  MatrixRC& LinComb(double a, double b, const MatrixRC& rc, int first=0);
-  MatrixRC& LinComb(double b, const MatrixRC& rc, int first=0);
+  OMatrixRC& operator = (const OMatrixRC& rc);
+  //operator OVector() const;
+  OVector GetVect() const;
+
+  OMatrixRC& operator += (const OMatrixRC& rc);
+  OMatrixRC& operator -= (const OMatrixRC& rc);
+
+  OMatrixRC& operator *= (double x);
+  OMatrixRC& operator /= (double x);
+  OMatrixRC& operator -= (double x);
+  OMatrixRC& operator += (double x);
+
+  friend double operator * (const OMatrixRC& a, const OMatrixRC& b);
+
+  OMatrixRC& LinComb(double a, double b, const OMatrixRC& rc, int first=0);
+  OMatrixRC& LinComb(double b, const OMatrixRC& rc, int first=0);
 
   int IMaxAbs(int first=0);
 
-  static void Swap(MatrixRC& rc1, MatrixRC& rc2);
-  // comme c'est symetrique, soit c'est static MatrixRC, soit static Matrix,
-  // soit Matrix avec verification qu'on parle bien de la meme...
+  static void Swap(OMatrixRC& rc1, OMatrixRC& rc2);
+  // comme c'est symetrique, soit c'est static OMatrixRC, soit static OMatrix,
+  // soit OMatrix avec verification qu'on parle bien de la meme...
 
 protected:
-  MatrixRC(Matrix& m, RCKind kind, int index=0);
-  Matrix* matrix;
+  OMatrixRC(OMatrix& m, RCKind kind, int index=0);
+  OMatrix* matrix;
   r_8*    data;
   int     index;
@@ -240,5 +240,5 @@
 
 
-inline int MatrixRC::Step(const Matrix& m, RCKind rckind)
+inline int OMatrixRC::Step(const OMatrix& m, RCKind rckind)
 {
   switch (rckind)
@@ -255,5 +255,5 @@
 
 
-inline double* MatrixRC::Org(const Matrix& m, RCKind rckind, int index)
+inline double* OMatrixRC::Org(const OMatrix& m, RCKind rckind, int index)
 {
   switch (rckind)
@@ -270,5 +270,5 @@
 
 
-inline int MatrixRC::NElts() const
+inline int OMatrixRC::NElts() const
 {
   if (!matrix) return -1;             // Failure ?
@@ -287,5 +287,5 @@
 
 
-inline  double& MatrixRC::operator()(int i)
+inline  double& OMatrixRC::operator()(int i)
 {
   return data[i*step];
@@ -293,5 +293,5 @@
 
 
-inline  double MatrixRC::operator()(int i) const
+inline  double OMatrixRC::operator()(int i) const
 {
   return data[i*step];
