Index: /trunk/SophyaLib/NTools/cvector.cc
===================================================================
--- /trunk/SophyaLib/NTools/cvector.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/cvector.cc	(revision 508)
@@ -6,5 +6,5 @@
 
 //++
-// Class	Vector
+// Class	OVector
 // Lib	Outils++
 // include	cvector.h
@@ -16,5 +16,5 @@
 //++
 // Links	Parents
-// Matrix
+// OMatrix
 //--
 
@@ -24,32 +24,32 @@
 
 //++
-Vector::Vector(int n)
+OVector::OVector(int n)
 //
 //	Constructeur, n = nombre d'éléments.
 //--
-: Matrix(n, 1)
+: OMatrix(n, 1)
 {END_CONSTRUCTOR}
 
 
 //++
-Vector::Vector(int n, double* values)
+OVector::OVector(int n, double* values)
 //
 //	Constructeur, à partir des valeurs. Pas d'allocation.
 //--
-: Matrix(n, 1, values)
+: OMatrix(n, 1, values)
 {END_CONSTRUCTOR}
 
 
 //++
-Vector::Vector(const Vector& v)
+OVector::OVector(const OVector& v)
 //
 //	Constructeur par copie.
 //--
-: Matrix(v)
+: OMatrix(v)
 {END_CONSTRUCTOR}
 
 
 //++
-Vector::Vector(const Matrix& a)
+OVector::OVector(const OMatrix& a)
 //
 //	Constructeur par "copie" à partir d'une matrice, qui doit avoir une seule colonne.
@@ -58,5 +58,5 @@
 //	sizeMismatchErr    si la matrice a plus d'une colonne
 //--
-: Matrix(a.nr,1)      // Matrix(a) ne marche pas, pourquoi ???? bug gcc ???
+: OMatrix(a.nr,1)      // OMatrix(a) ne marche pas, pourquoi ???? bug gcc ???
 {
   if (a.nc != 1) THROW(sizeMismatchErr);
@@ -66,10 +66,10 @@
 
 //++
-Vector::Vector(const TVector<r_8>& v)
+OVector::OVector(const TVector<r_8>& v)
 //
 //	Constructeur par "copie" a partir d'un TVector<r_8>.
 //	Attention, les donnees sont partagees.
 //--
-: Matrix(v)
+: OMatrix(v)
 {
 }
@@ -87,5 +87,5 @@
 
 //++
-Vector& Vector::operator = (double x)
+OVector& OVector::operator = (double x)
 //
 //	Affectation à partir d'un scalaire. Tous les éléments prennent cette valeur.
@@ -98,5 +98,5 @@
 
 //++
-double operator* (const Vector& v1, const Vector& v2)
+double operator* (const OVector& v1, const OVector& v2)
 //
 //	Produit scalaire entre deux vecteurs.
@@ -117,10 +117,10 @@
 
 //++
-// Vector operator* (const Vector& v, double b)
+// OVector operator* (const OVector& v, double b)
 //	multiplication par un scalaire.
 //--
 
 //++
-// Vector operator* (const Matrix& a, const Vector& b)
+// OVector operator* (const OMatrix& a, const OVector& b)
 //	produit matrice*vecteur.
 //--
@@ -144,5 +144,5 @@
 
 //++
-double LinSolveInPlace(Matrix& a, Vector& b)
+double LinSolveInPlace(OMatrix& a, OVector& b)
 //
 //	Résolution du système A*C = B
@@ -152,10 +152,10 @@
   if (a.NCol() != a.NRows()) THROW(sizeMismatchErr);
 
-  return Matrix::GausPiv(a,b);
-}
-
-
-//++
-double LinSolve(const Matrix& a, const Vector& b, Vector& c)
+  return OMatrix::GausPiv(a,b);
+}
+
+
+//++
+double LinSolve(const OMatrix& a, const OVector& b, OVector& c)
 //
 //	Résolution du système A*C = B, avec C retourné dans B
@@ -165,11 +165,11 @@
   if (a.NCol() != a.NRows()) THROW(sizeMismatchErr);
   c = b;
-  Matrix a1(a);
-  return Matrix::GausPiv(a1,c);
+  OMatrix a1(a);
+  return OMatrix::GausPiv(a1,c);
 }
 
 //////////////////////////////////////////////////////////
 //++
-Vector Vector::FitResidus(GeneralFit& gfit,double xorg,double dx)
+OVector OVector::FitResidus(GeneralFit& gfit,double xorg,double dx)
 //
 //	Retourne une classe contenant les residus du fit ``gfit''.
@@ -178,10 +178,10 @@
 {
 if(NElts()<=0)
-  throw(SzMismatchError("Vector::FitResidus: size mismatch\n"));
+  throw(SzMismatchError("OVector::FitResidus: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
 if(f==NULL)
-  throw(NullPtrError("Vector::FitResidus: NULL pointer\n"));
-Vector par = gfit.GetParm();
-Vector v(*this);
+  throw(NullPtrError("OVector::FitResidus: NULL pointer\n"));
+OVector par = gfit.GetParm();
+OVector v(*this);
 for(int i=0;i<NElts();i++) {
   double x = xorg+i*dx;
@@ -192,5 +192,5 @@
 
 //++
-Vector Vector::FitFunction(GeneralFit& gfit,double xorg,double dx)
+OVector OVector::FitFunction(GeneralFit& gfit,double xorg,double dx)
 //
 //	Retourne une classe contenant la fonction du fit ``gfit''.
@@ -199,10 +199,10 @@
 {
 if(NElts()<=0)
-  throw(SzMismatchError("Vector::FitResidus: size mismatch\n"));
+  throw(SzMismatchError("OVector::FitResidus: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
 if(f==NULL)
-  throw(NullPtrError("Vector::FitResidus: NULL pointer\n"));
-Vector par = gfit.GetParm();
-Vector v(*this);
+  throw(NullPtrError("OVector::FitResidus: NULL pointer\n"));
+OVector par = gfit.GetParm();
+OVector v(*this);
 for(int i=0;i<NElts();i++) {
   double x = xorg+i*dx;
Index: /trunk/SophyaLib/NTools/cvector.h
===================================================================
--- /trunk/SophyaLib/NTools/cvector.h	(revision 507)
+++ /trunk/SophyaLib/NTools/cvector.h	(revision 508)
@@ -13,18 +13,18 @@
 // Vecteur colonne, en fait une matrice avec une seule colonne, pour faire
 // des operations matricielles.
-class Vector : public Matrix {
+class OVector : public OMatrix {
   friend class TVector<r_8>;
 public:
   // Constructeur, n = nombre d'elements.
-  EXPLICIT Vector(int n=1);
+  EXPLICIT OVector(int n=1);
   // Constructeur, a partir des valeurs. Pas d'allocation.
-  Vector(int n, double* values);
+  OVector(int n, double* values);
   // Constructeur par copie
-  Vector(const Vector& v);
+  OVector(const OVector& v);
   // Constructeur par "copie" a partir d'une matrice, qui doit avoir une colonne
   // <thrown> sizeMismatchErr </thrown>
-  Vector(const Matrix& a);
+  OVector(const OMatrix& a);
   // Constructeur par copie a partir d'un TVector<r_8>
-  Vector(const TVector<r_8>& v);
+  OVector(const TVector<r_8>& v);
 
   // Construction automatique pour PPF
@@ -32,5 +32,5 @@
   enum {classId = ClassId_Vector};
   int_4                 ClassId() const         { return classId; }
-  static PPersist*      Create() {return new Vector(1);}
+  static PPersist*      Create() {return new OVector(1);}
   // </group>
   
@@ -39,6 +39,6 @@
   void Realloc(int n, bool force=false);
 
-  Vector& operator = (const Vector& v);
-  Vector& operator = (double x);
+  OVector& operator = (const OVector& v);
+  OVector& operator = (double x);
 
   // Acces aux elements
@@ -50,11 +50,11 @@
   // produit scalaire
   // <group>
-  friend double operator* (const Vector& v1, const Vector& v2);
-  friend Vector operator* (const Vector& v, double b)
-  {return Vector(((Matrix const&)v) * b);}
+  friend double operator* (const OVector& v1, const OVector& v2);
+  friend OVector operator* (const OVector& v, double b)
+  {return OVector(((OMatrix const&)v) * b);}
   // </group>
   // produit matrice*vecteur
-  friend Vector operator* (const Matrix& a, const Vector& b)
-  {return Vector(a * ((Matrix const&) (b)));}
+  friend OVector operator* (const OMatrix& a, const OVector& b)
+  {return OVector(a * ((OMatrix const&) (b)));}
 
   // Nombre de lignes du vecteur
@@ -62,21 +62,21 @@
 
   // Resolution du systeme A*C = B
-  friend double LinSolve(const Matrix& a, const Vector& b, Vector& c);
+  friend double LinSolve(const OMatrix& a, const OVector& b, OVector& c);
   
   // Resolution du systeme A*C = B, avec C retourne dans B
-  friend double LinSolveInPlace(Matrix& a, Vector& b);
+  friend double LinSolveInPlace(OMatrix& a, OVector& b);
 
   // Residus et fonction fittees.
-  Vector FitResidus(GeneralFit& gfit,double xorg=0.,double dx=1.);
-  Vector FitFunction(GeneralFit& gfit,double xorg=0.,double dx=1.);
+  OVector FitResidus(GeneralFit& gfit,double xorg=0.,double dx=1.);
+  OVector FitFunction(GeneralFit& gfit,double xorg=0.,double dx=1.);
 
 };
 
 
-inline Vector& Vector::operator = (const Vector& v)
-{ Matrix::operator =(v); return *this; }
+inline OVector& OVector::operator = (const OVector& v)
+{ OMatrix::operator =(v); return *this; }
 
 
-inline double const& Vector::operator()(int n) const
+inline double const& OVector::operator()(int n) const
 {
 #ifdef RGCHECK
@@ -87,5 +87,5 @@
 
 
-inline double& Vector::operator()(int n)
+inline double& OVector::operator()(int n)
 { 
 #ifdef RGCHECK
@@ -95,6 +95,6 @@
 }
 
-inline void Vector::Realloc(int n, bool force)
-{ Matrix::Realloc(n,1,force);}
+inline void OVector::Realloc(int n, bool force)
+{ OMatrix::Realloc(n,1,force);}
 
 
Index: /trunk/SophyaLib/NTools/difeq.cc
===================================================================
--- /trunk/SophyaLib/NTools/difeq.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/difeq.cc	(revision 508)
@@ -106,5 +106,5 @@
 //++
 DiffEqSolver&
-DiffEqSolver::StartV(Vector const& yi, double t)
+DiffEqSolver::StartV(OVector const& yi, double t)
 //
 //	Spécifie le point de départ de l'intégration de l'équadif.
@@ -169,5 +169,5 @@
 
 //++
-// virtual void DiffEqSolver::SolveArr(Matrix&  y, double* t, double tf, int n)=0
+// virtual void DiffEqSolver::SolveArr(OMatrix&  y, double* t, double tf, int n)=0
 //	Lance la résolution de l'équadif, jusqu'à la valeur
 //	tf du temps. N valeurs intermédiaires sont retournées dans 
@@ -189,5 +189,5 @@
 //++
 void
-DiffEqSolver::SolveV(Vector& yf, double tf)
+DiffEqSolver::SolveV(OVector& yf, double tf)
 //
 //	Lance la résolution de l'équadif, jusqu'à la valeur
@@ -201,5 +201,5 @@
 {
   double t;
-  Matrix m(1, mFunc->NFuncReal());
+  OMatrix m(1, mFunc->NFuncReal());
   SolveArr(m, &t, tf, 1);
   yf.Realloc(mFunc->NFunc());
@@ -219,5 +219,5 @@
   ASSERT(mFunc->NFunc() == 1);
   double t;
-  Matrix m(1,mFunc->NFuncReal());
+  OMatrix m(1,mFunc->NFuncReal());
   SolveArr(m, &t, tf, 1);
   yf = m(0,0);
@@ -238,5 +238,5 @@
 {
   double t;
-  Matrix m(1, mFunc->NFuncReal());
+  OMatrix m(1, mFunc->NFuncReal());
   SolveArr(m, &t, tf, 1);
   for (int i=0; i<mFunc->NFunc(); i++)
@@ -258,5 +258,5 @@
 {
   ASSERT(mFunc->NFunc() == 1);
-  Matrix m(n, mFunc->NFuncReal());
+  OMatrix m(n, mFunc->NFuncReal());
   SolveArr(m, t, tf, n);
   for (int i=0; i<n; i++)
@@ -281,5 +281,5 @@
 //--
 {
-   Matrix m(n, mFunc->NFuncReal());
+   OMatrix m(n, mFunc->NFuncReal());
    SolveArr(m, t, tf, n);
    for (int i=0; i<n; i++)
@@ -318,5 +318,5 @@
 
 //++
-//  virtual void ComputeV(Vector& fpi, Vector const& fi)
+//  virtual void ComputeV(OVector& fpi, OVector const& fi)
 //	Calcule les valeurs des dérivées fpi à partir des valeurs 
 //	des fonctions fi. A redéfinir.
@@ -340,5 +340,5 @@
 
 //++
-// virtual void AdjustStart(Vector& start, double tstart)
+// virtual void AdjustStart(OVector& start, double tstart)
 //	Pour ajuster le vecteur de départ quand il y a des 
 //	fonctions à usage interne...
@@ -405,5 +405,5 @@
 
 void
-DiffEqFcnT1::ComputeV(Vector& fpi, Vector const& fi)
+DiffEqFcnT1::ComputeV(OVector& fpi, OVector const& fi)
 {
   fpi(0) = (*mFcn)(fi(0), fi(1));
@@ -412,5 +412,5 @@
 
 void
-DiffEqFcnT1::AdjustStart(Vector& start, double tstart)
+DiffEqFcnT1::AdjustStart(OVector& start, double tstart)
 {
   start.Realloc(2);
@@ -446,5 +446,5 @@
 
 void
-DiffEqFcn2::ComputeV(Vector& fpi, Vector const& fi)
+DiffEqFcn2::ComputeV(OVector& fpi, OVector const& fi)
 {
   fpi(0) = fi(1);
@@ -481,5 +481,5 @@
 
 void
-DiffEqFcnT2::ComputeV(Vector& fpi, Vector const& fi)
+DiffEqFcnT2::ComputeV(OVector& fpi, OVector const& fi)
 {
   fpi(0) = fi(1);
@@ -489,5 +489,5 @@
 
 void
-DiffEqFcnT2::AdjustStart(Vector& start, double tstart)
+DiffEqFcnT2::AdjustStart(OVector& start, double tstart)
 {
   start.Realloc(3);
@@ -505,6 +505,6 @@
 //	un vecteur de dimension 3.
 //	On fournit une fonction de type
-//|	typedef void(*DIFEQFCNV)(Vector& y2, Vector const& y1, 
-//|	                         Vector const& y);
+//|	typedef void(*DIFEQFCNV)(OVector& y2, OVector const& y1, 
+//|	                         OVector const& y);
 //	qui retourne y'' en fonction de y' et y.
 //	Note : le système résolu est alors en fait
@@ -527,5 +527,5 @@
 
 void
-DiffEqFcnV::ComputeV(Vector& fpi, Vector const& fi)
+DiffEqFcnV::ComputeV(OVector& fpi, OVector const& fi)
 {
   fpi(0) = fi(3);
@@ -582,5 +582,5 @@
 
 void
-RK4DiffEq::SolveArr(Matrix& y, double* t, double tf, int n)
+RK4DiffEq::SolveArr(OMatrix& y, double* t, double tf, int n)
 {
   //TIMEF;
@@ -592,5 +592,5 @@
    double dx = (tf - mXStart)/(n*nStep);
    
-   Vector yt = mYStart;
+   OVector yt = mYStart;
 
    k1.Realloc(mFunc->NFuncReal());
@@ -610,5 +610,5 @@
 
 void
-RK4DiffEq::RKStep(Vector& newY, Vector const& y0, double dt)
+RK4DiffEq::RKStep(OVector& newY, OVector const& y0, double dt)
 {
     mFunc->ComputeV(k1, y0);
Index: /trunk/SophyaLib/NTools/difeq.h
===================================================================
--- /trunk/SophyaLib/NTools/difeq.h	(revision 507)
+++ /trunk/SophyaLib/NTools/difeq.h	(revision 508)
@@ -28,5 +28,5 @@
   
   // Calcule les valeurs des derivees fpi a partir des valeurs des fonctions fi
-  virtual void ComputeV(Vector& fpi, Vector const& fi)
+  virtual void ComputeV(OVector& fpi, OVector const& fi)
        { Compute(fpi(0), fi(0)); }
 
@@ -44,5 +44,5 @@
   // Pour ajuster vecteur de depart quand il y a des fonctions a usage
   // interne...
-  virtual void AdjustStart(Vector& /*start*/, double /*tstart*/) 
+  virtual void AdjustStart(OVector& /*start*/, double /*tstart*/) 
     {}   
 protected:
@@ -87,8 +87,8 @@
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
-  virtual void ComputeV(Vector& fpi, Vector const& fi);
+  virtual void ComputeV(OVector& fpi, OVector const& fi);
 
   // Implementation de AdjustStart qui gere la fonction a usage interne.
-  virtual void AdjustStart(Vector& start, double tstart);
+  virtual void AdjustStart(OVector& start, double tstart);
 protected:
   DIFEQFCNT1 mFcn;
@@ -102,5 +102,5 @@
   DiffEqFcn2(DIFEQFCN2);
 
-  virtual void ComputeV(Vector& fpi, Vector const& fi);
+  virtual void ComputeV(OVector& fpi, OVector const& fi);
 protected:
   DIFEQFCN2 mFcn;
@@ -121,8 +121,8 @@
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
-  virtual void ComputeV(Vector& fpi, Vector const& fi);
+  virtual void ComputeV(OVector& fpi, OVector const& fi);
 
   // Implementation de AdjustStart qui gere la fonction a usage interne.
-  virtual void AdjustStart(Vector& start, double tstart);
+  virtual void AdjustStart(OVector& start, double tstart);
 protected:
   DIFEQFCNT2 mFcn;
@@ -130,12 +130,12 @@
 
 // Cas y'' = f(y',y) avec des 3-vecteurs
-typedef void(*DIFEQFCNV)(Vector&, Vector const&, Vector const&);
+typedef void(*DIFEQFCNV)(OVector&, OVector const&, OVector const&);
 
 // <summary> y'' = f(y',y,t) </summary>
 // Cas y'' = f(y',y,t), on fournit la fonction f, sous la forme
-// double f(Vector), et ca construit la bonne DiffEqFunction
+// double f(OVector), et ca construit la bonne DiffEqFunction
 class DiffEqFcnV : public DiffEqFunction {
 public:
-  // Constructeur, on fournit une fonction (Vector)->double
+  // Constructeur, on fournit une fonction (OVector)->double
   // qui donne y'' en fonction du vecteur (t, y, y')
   DiffEqFcnV(DIFEQFCNV);
@@ -143,8 +143,8 @@
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
-  virtual void ComputeV(Vector& fpi, Vector const& fi);
+  virtual void ComputeV(OVector& fpi, OVector const& fi);
 protected:
   DIFEQFCNV mFcn;
-  Vector tmp1, tmp2, tmp3;
+  OVector tmp1, tmp2, tmp3;
 };
 
@@ -176,5 +176,5 @@
   // Change les conditions initiales. Notation chainee possible.
   // <group>
-  DiffEqSolver& StartV(Vector const& yi, double t);
+  DiffEqSolver& StartV(OVector const& yi, double t);
   // si NFunc == 1
   DiffEqSolver& Start1(double        yi, double t);
@@ -184,9 +184,9 @@
   // Lance la resolution, avec ou sans conservation de n valeurs intermediaires
   // <group>
-  virtual void SolveV(Vector& yf, double tf);
+  virtual void SolveV(OVector& yf, double tf);
   // si NFunc == 1
   virtual void Solve1(double& yf, double tf);  
   virtual void Solve(double* yf, double tf);
-  virtual void SolveArr(Matrix&  y, double* t, double tf, int n)=0;
+  virtual void SolveArr(OMatrix&  y, double* t, double tf, int n)=0;
   // si NFunc == 1
   virtual void SolveArr1(double*  y, double* t, double tf, int n);   
@@ -198,5 +198,5 @@
   bool mOwnFunc;
 
-  Vector  mYStart;
+  OVector  mYStart;
   double  mXStart;
   double  mStep;
@@ -215,11 +215,11 @@
 
   // Implementation de RK4
-  virtual void SolveArr(Matrix& y, double* t, double tf, int n);
+  virtual void SolveArr(OMatrix& y, double* t, double tf, int n);
 
 protected:
   // Un pas RK4
-  void RKStep(Vector& newY, Vector const& y0, double dt);
+  void RKStep(OVector& newY, OVector const& y0, double dt);
   // Vecteurs utilises en interne, pour ne pas les reallouer.
-  Vector k1, k2, k3, k4;
+  OVector k1, k2, k3, k4;
 };
 
Index: /trunk/SophyaLib/NTools/fftserver.cc
===================================================================
--- /trunk/SophyaLib/NTools/fftserver.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/fftserver.cc	(revision 508)
@@ -156,9 +156,9 @@
 }
 
-void FFTServer::fftf(Vector& in, Vector& out)
+void FFTServer::fftf(OVector& in, OVector& out)
 {
   int l = in.NElts();
-/* ----- Si c'etait un Vector<float> on aurait ecrit comme ca 
-   Pour le moment Vector est double, on passe donc par un tableau 
+/* ----- Si c'etait un OVector<float> on aurait ecrit comme ca 
+   Pour le moment OVector est double, on passe donc par un tableau 
    intermediare
 // La transformee sur le tableau de flaot se fait en place,
@@ -175,9 +175,9 @@
 }
 
-void FFTServer::fftb(Vector& in, Vector& out)
+void FFTServer::fftb(OVector& in, OVector& out)
 {
   int l = in.NElts();
-/* ----- Si c'etait un Vector<float> on aurait ecrit comme ca 
-   Pour le moment Vector est double, on passe donc par un tableau 
+/* ----- Si c'etait un OVector<float> on aurait ecrit comme ca 
+   Pour le moment OVector est double, on passe donc par un tableau 
    intermediare
 // La transformee sur le tableau de flaot se fait en place,
Index: /trunk/SophyaLib/NTools/fftserver.h
===================================================================
--- /trunk/SophyaLib/NTools/fftserver.h	(revision 507)
+++ /trunk/SophyaLib/NTools/fftserver.h	(revision 508)
@@ -17,6 +17,6 @@
   virtual void fftf(int l, complex<double>* inout);
   virtual void fftb(int l, complex<double>* inout);
-  virtual void fftf(Vector& in, Vector& out);
-  virtual void fftb(Vector& in, Vector& out);
+  virtual void fftf(OVector& in, OVector& out);
+  virtual void fftb(OVector& in, OVector& out);
 
  protected:
@@ -94,9 +94,9 @@
   \param inout input array /output backward FFT(original array destroyed)
 */
-/*!\fn  virtual void FFTServer::fftf(Vector& in, Vector& out)
+/*!\fn  virtual void FFTServer::fftf(OVector& in, OVector& out)
   \param in input array
   \param out forward FFT
 */
-/*! \fn virtual void FFTServer::fftb(Vector& in, Vector& out)
+/*! \fn virtual void FFTServer::fftb(OVector& in, OVector& out)
   \param in input array
   \param out backward FFT
Index: /trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- /trunk/SophyaLib/NTools/generaldata.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/generaldata.cc	(revision 508)
@@ -748,7 +748,7 @@
 if(varx<0 || varx>=mNVar) return -2.;
 if(mNDataGood<=0) return -4.;
-Vector x(mNDataGood);
-Vector y(mNDataGood);
-Vector ey2(1);
+OVector x(mNDataGood);
+OVector y(mNDataGood);
+OVector ey2(1);
 if(ey) ey2.Realloc(mNDataGood,true);
 int ntest = 0;
@@ -763,5 +763,5 @@
 double res = 0.;
 if(ey) {
-  Vector errcoef(1);
+  OVector errcoef(1);
   res = pol.Fit(x,y,ey2,degre,errcoef);
 } else {
@@ -797,8 +797,8 @@
 if(vary<0 || vary>=mNVar || vary==varx) return -3.;
 if(mNDataGood<=0) return -4.;
-Vector x(mNDataGood);
-Vector y(mNDataGood);
-Vector z(mNDataGood);
-Vector ez2(1);
+OVector x(mNDataGood);
+OVector y(mNDataGood);
+OVector z(mNDataGood);
+OVector ez2(1);
 if(ez) ez2.Realloc(mNDataGood,true);
 int ntest = 0;
@@ -814,5 +814,5 @@
 double res = 0.;
 if(ez) {
-  Vector errcoef(1);
+  OVector errcoef(1);
   if(degre2>0) res = pol.Fit(x,y,z,ez2,degre1,degre2,errcoef);
   else         res = pol.Fit(x,y,z,ez2,degre1,errcoef);
Index: /trunk/SophyaLib/NTools/generalfit.cc
===================================================================
--- /trunk/SophyaLib/NTools/generalfit.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/generalfit.cc	(revision 508)
@@ -874,5 +874,5 @@
 
 //++
-Vector GeneralFit::GetParm()
+OVector GeneralFit::GetParm()
 //
 //	Retourne les valeurs des parametres dans un vecteur.
@@ -1096,11 +1096,11 @@
 {
  volatile double oldChi2;
- Matrix COVAR(mNPar,mNPar);
- Vector DA(mNPar);
- Vector dparam(mNPar);
- Vector paramTry(mNPar);
- Vector param_tr(mNPar);
- Vector paramTry_tr(mNPar);
- Vector step_tr(mNPar);
+ OMatrix COVAR(mNPar,mNPar);
+ OVector DA(mNPar);
+ OVector dparam(mNPar);
+ OVector paramTry(mNPar);
+ OVector param_tr(mNPar);
+ OVector paramTry_tr(mNPar);
+ OVector step_tr(mNPar);
  nStop = nStopL = nStep = 0;
  Chi2 = oldChi2 = 0.;
@@ -1515,5 +1515,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::write_in_step(double ci2,Vector& par)
+void GeneralFit::write_in_step(double ci2,OVector& par)
 {
 if(FileStep==NULL) return;
@@ -1524,11 +1524,11 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::TryFunc(Vector& par,Vector& par_tr)
+void GeneralFit::TryFunc(OVector& par,OVector& par_tr)
 {
   BETA_Try = 0;
   ATGA_Try = 0;
   Chi2  = 0;
-  Vector deriv(mNPar);
-  Vector derivtr(mNPar);
+  OVector deriv(mNPar);
+  OVector derivtr(mNPar);
   double result;
 
@@ -1564,5 +1564,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::TryXi2(Vector& par,Vector& par_tr)
+void GeneralFit::TryXi2(OVector& par,OVector& par_tr)
 {
   double c, *parloc;
@@ -1664,7 +1664,7 @@
 
 //////////////////////////////////////////////////////////////////////
-Vector GeneralFit::p_vers_tr(Vector const& p)
-{
- Vector tr(p);
+OVector GeneralFit::p_vers_tr(OVector const& p)
+{
+ OVector tr(p);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1675,5 +1675,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::p_vers_tr(Vector const& p,Vector& tr)
+void GeneralFit::p_vers_tr(OVector const& p,OVector& tr)
 {
  for(int i=0;i<mNPar;i++) {
@@ -1695,7 +1695,7 @@
 
 //////////////////////////////////////////////////////////////////////
-Vector GeneralFit::tr_vers_p(Vector const& tr)
-{
- Vector p(tr);
+OVector GeneralFit::tr_vers_p(OVector const& tr)
+{
+ OVector p(tr);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1706,5 +1706,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::tr_vers_p(Vector const& tr,Vector& p)
+void GeneralFit::tr_vers_p(OVector const& tr,OVector& p)
 {
  for(int i=0;i<mNPar;i++) {
@@ -1727,7 +1727,7 @@
 
 //////////////////////////////////////////////////////////////////////
-Vector GeneralFit::dp_vers_dtr(Vector const& dp,Vector const& tr)
-{
- Vector dtr(dp);
+OVector GeneralFit::dp_vers_dtr(OVector const& dp,OVector const& tr)
+{
+ OVector dtr(dp);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1738,5 +1738,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::dp_vers_dtr(Vector const& dp,Vector const& tr,Vector& dtr)
+void GeneralFit::dp_vers_dtr(OVector const& dp,OVector const& tr,OVector& dtr)
 {
  for(int i=0;i<mNPar;i++) {
@@ -1759,7 +1759,7 @@
 
 //////////////////////////////////////////////////////////////////////
-Vector GeneralFit::dtr_vers_dp(Vector const& dtr,Vector const& tr)
-{
- Vector dp(dtr);
+OVector GeneralFit::dtr_vers_dp(OVector const& dtr,OVector const& tr)
+{
+ OVector dp(dtr);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1771,8 +1771,8 @@
 //////////////////////////////////////////////////////////////////////
 // inline fonction pour aller + vite dans le try()
-//void GeneralFit::dtr_vers_dp(Vector const& dtr,Vector const& tr,Vector& dp)
-
-//////////////////////////////////////////////////////////////////////
-int GeneralFit::put_in_limits_for_deriv(Vector const& p,Vector& dp,double dist)
+//void GeneralFit::dtr_vers_dp(OVector const& dtr,OVector const& tr,OVector& dp)
+
+//////////////////////////////////////////////////////////////////////
+int GeneralFit::put_in_limits_for_deriv(OVector const& p,OVector& dp,double dist)
 // 1-/ Redefinit dp pour qu'il soit superieur a minStepDeriv
 // 2-/ Redefinit dp pour que p+/-dp reste dans les limites (parametre borne)
Index: /trunk/SophyaLib/NTools/generalfit.h
===================================================================
--- /trunk/SophyaLib/NTools/generalfit.h	(revision 507)
+++ /trunk/SophyaLib/NTools/generalfit.h	(revision 508)
@@ -124,5 +124,5 @@
 
   double          GetParm(int);
-  Vector          GetParm();
+  OVector          GetParm();
   double          GetParmErr(int);
   double          GetCoVar(int,int);
@@ -168,11 +168,11 @@
   GeneralFitData*   mData;
 
-  Vector          Param;
-  Vector          errParam;
-  Vector          stepParam;
-  Vector          minParam;
-  Vector          maxParam;
-  Vector          minStepDeriv;
-  Vector          Eps;
+  OVector          Param;
+  OVector          errParam;
+  OVector          stepParam;
+  OVector          minParam;
+  OVector          maxParam;
+  OVector          minStepDeriv;
+  OVector          Eps;
   unsigned short int* fixParam;
   unsigned short int* boundParam;
@@ -188,10 +188,10 @@
   FILE            *FileStep;
   
-  Matrix          ATGA;
-  Vector          BETA;
-  Matrix          ATGA_Try;
-  Vector          BETA_Try;
-  Vector          C;
-  Vector          D;
+  OMatrix          ATGA;
+  OVector          BETA;
+  OMatrix          ATGA_Try;
+  OVector          BETA_Try;
+  OVector          C;
+  OVector          D;
   
   double          Chi2;
@@ -202,24 +202,24 @@
   
   // Fonctions privees
-  void       write_in_step(double ci2,Vector& par);
+  void       write_in_step(double ci2,OVector& par);
   void       General_Init(void);
-  void       TryFunc(Vector& par,Vector& par_tr);
-  void       TryXi2(Vector& par,Vector& par_tr);
+  void       TryFunc(OVector& par,OVector& par_tr);
+  void       TryXi2(OVector& par,OVector& par_tr);
   void       CheckSanity();
   void       Set_Bound_C_D(int i);
   void       Set_Bound_C_D();
   double     p_vers_tr(int i,double p);
-  Vector     p_vers_tr(Vector const& p);
-  void       p_vers_tr(Vector const& p,Vector& tr);
+  OVector     p_vers_tr(OVector const& p);
+  void       p_vers_tr(OVector const& p,OVector& tr);
   double     tr_vers_p(int i,double tr);
-  Vector     tr_vers_p(Vector const& tr);
-  void       tr_vers_p(Vector const& tr,Vector& p);
+  OVector     tr_vers_p(OVector const& tr);
+  void       tr_vers_p(OVector const& tr,OVector& p);
   double     c_dp_vers_dtr(int i,double tr);
-  Vector       dp_vers_dtr(Vector const& dp,Vector const& tr);
-  void         dp_vers_dtr(Vector const& dp,Vector const& tr,Vector& dtr);
+  OVector       dp_vers_dtr(OVector const& dp,OVector const& tr);
+  void         dp_vers_dtr(OVector const& dp,OVector const& tr,OVector& dtr);
   double     c_dtr_vers_dp(int i,double tr);
-  Vector       dtr_vers_dp(Vector const& dtr,Vector const& tr);
-  int        put_in_limits_for_deriv(Vector const& p,Vector& dp,double dist=0.66);
-  inline void dtr_vers_dp(Vector const& dtr,Vector const& tr,Vector& dp)
+  OVector       dtr_vers_dp(OVector const& dtr,OVector const& tr);
+  int        put_in_limits_for_deriv(OVector const& p,OVector& dp,double dist=0.66);
+  inline void dtr_vers_dp(OVector const& dtr,OVector const& tr,OVector& dp)
               {  for(int i=0;i<mNPar;i++)
                    { if( fixParam[i] ) continue;
Index: /trunk/SophyaLib/NTools/hisprof.cc
===================================================================
--- /trunk/SophyaLib/NTools/hisprof.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/hisprof.cc	(revision 508)
@@ -260,9 +260,9 @@
 //--
 //++
-// inline void GetMean(Vector& v)
+// inline void GetMean(OVector& v)
 //	Retourne le contenu de la moyenne dans le vecteur v
 //--
 //++
-// inline void GetError2(Vector& v)
+// inline void GetError2(OVector& v)
 //	Retourne le contenu au carre de la dispersion/erreur dans le vecteur v
 //--
Index: /trunk/SophyaLib/NTools/hisprof.h
===================================================================
--- /trunk/SophyaLib/NTools/hisprof.h	(revision 507)
+++ /trunk/SophyaLib/NTools/hisprof.h	(revision 508)
@@ -29,6 +29,6 @@
   // Acces a l information
   inline Histo GetHisto() {if(!Ok) UpdateHisto(); return (Histo) *this;}
-  inline void GetMean(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetValue(v);}
-  inline void GetError2(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetError2(v);}
+  inline void GetMean(OVector& v) {if(!Ok) UpdateHisto(); Histo::GetValue(v);}
+  inline void GetError2(OVector& v) {if(!Ok) UpdateHisto(); Histo::GetError2(v);}
   inline float operator()(int i) const {if(!Ok) UpdateHisto(); return data[i];}
   inline float Error2(int i) const {if(!Ok) UpdateHisto(); return (float) err2[i];}
Index: /trunk/SophyaLib/NTools/histos.cc
===================================================================
--- /trunk/SophyaLib/NTools/histos.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/histos.cc	(revision 508)
@@ -1,4 +1,4 @@
 //
-// $Id: histos.cc,v 1.4 1999-10-21 15:25:45 ansari Exp $
+// $Id: histos.cc,v 1.5 1999-10-25 10:36:07 ansari Exp $
 //
 
@@ -404,5 +404,5 @@
 /********* Methode *********/
 //++
-void Histo::GetAbsc(Vector &v)
+void Histo::GetAbsc(OVector &v)
 //
 //	Remplissage d'un tableau avec la valeur des abscisses
@@ -415,5 +415,5 @@
 
 //++
-void Histo::GetValue(Vector &v)
+void Histo::GetValue(OVector &v)
 //
 //	Remplissage d'un tableau avec la valeur du contenu
@@ -426,5 +426,5 @@
 
 //++
-void Histo::GetError2(Vector &v)
+void Histo::GetError2(OVector &v)
 //
 //	Remplissage d'un tableau avec la valeur des erreurs au carre
@@ -438,5 +438,5 @@
 
 //++
-void Histo::GetError(Vector &v)
+void Histo::GetError(OVector &v)
 //
 //	Remplissage d'un tableau avec la valeur des erreurs
@@ -451,5 +451,5 @@
 /********* Methode *********/
 //++
-void Histo::PutValue(Vector &v, int ierr)
+void Histo::PutValue(OVector &v, int ierr)
 //
 //	Remplissage du contenu de l'histo avec les valeurs d'un vecteur
@@ -465,5 +465,5 @@
 
 //++
-void Histo::PutValueAdd(Vector &v, int ierr)
+void Histo::PutValueAdd(OVector &v, int ierr)
 //
 //	Addition du contenu de l'histo avec les valeurs d'un vecteur
@@ -479,5 +479,5 @@
 
 //++
-void Histo::PutError2(Vector &v)
+void Histo::PutError2(OVector &v)
 //
 //	Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur
@@ -491,5 +491,5 @@
 
 //++
-void Histo::PutError2Add(Vector &v)
+void Histo::PutError2Add(OVector &v)
 //
 //	Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur
@@ -503,5 +503,5 @@
 
 //++
-void Histo::PutError(Vector &v)
+void Histo::PutError(OVector &v)
 //
 //	Remplissage des erreurs de l'histo avec les valeurs d'un vecteur
@@ -1121,8 +1121,8 @@
   }
 
-  Vector xFit(nLowHigh);
-  Vector yFit(nLowHigh);
-  Vector e2Fit(nLowHigh);
-  Vector errcoef(1);
+  OVector xFit(nLowHigh);
+  OVector yFit(nLowHigh);
+  OVector e2Fit(nLowHigh);
+  OVector errcoef(1);
   int ii = 0;
   for (int j=iLow; j<=iHigh; j++) {
@@ -1444,5 +1444,5 @@
 if(f==NULL)
   throw(NullPtrError("Histo::FitResidus: NULL pointer\n"));
-Vector par = gfit.GetParm();
+OVector par = gfit.GetParm();
 Histo h(*this);
 for(int i=0;i<NBins();i++) {
@@ -1464,5 +1464,5 @@
 if(f==NULL)
   throw(NullPtrError("Histo::FitFunction: NULL pointer\n"));
-Vector par = gfit.GetParm();
+OVector par = gfit.GetParm();
 Histo h(*this);
 for(int i=0;i<NBins();i++) {
Index: /trunk/SophyaLib/NTools/histos.h
===================================================================
--- /trunk/SophyaLib/NTools/histos.h	(revision 507)
+++ /trunk/SophyaLib/NTools/histos.h	(revision 508)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: histos.h,v 1.3 1999-10-21 15:25:47 ansari Exp $
+// $Id: histos.h,v 1.4 1999-10-25 10:36:07 ansari Exp $
 //
 
@@ -66,13 +66,13 @@
 
   // get/put dans/depuis un vector
-  void GetAbsc(Vector& v);
-  void GetValue(Vector& v);
-  void GetError2(Vector& v);
-  void GetError(Vector& v);
-  void PutValue(Vector& v, int ierr=0);
-  void PutValueAdd(Vector &v, int ierr=0);
-  void PutError2(Vector& v);
-  void PutError2Add(Vector& v);
-  void PutError(Vector& v);
+  void GetAbsc(OVector& v);
+  void GetValue(OVector& v);
+  void GetError2(OVector& v);
+  void GetError(OVector& v);
+  void PutValue(OVector& v, int ierr=0);
+  void PutValueAdd(OVector &v, int ierr=0);
+  void PutError2(OVector& v);
+  void PutError2Add(OVector& v);
+  void PutError(OVector& v);
 
   // INLINES
Index: /trunk/SophyaLib/NTools/histos2.cc
===================================================================
--- /trunk/SophyaLib/NTools/histos2.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/histos2.cc	(revision 508)
@@ -603,5 +603,5 @@
 ///////////////////////////////////////////////////////////////////
 //++
-void Histo2D::GetXCoor(Vector &v)
+void Histo2D::GetXCoor(OVector &v)
 //
 //	Remplissage d'un tableau avec les valeurs des abscisses.
@@ -615,5 +615,5 @@
 
 //++
-void Histo2D::GetYCoor(Vector &v)
+void Histo2D::GetYCoor(OVector &v)
 //
 //	Remplissage d'un tableau avec les valeurs des ordonnees.
@@ -644,5 +644,5 @@
 
 //++
-void Histo2D::GetValue(Matrix &v)
+void Histo2D::GetValue(OMatrix &v)
 //
 //	Remplissage d'un tableau avec les valeurs du contenu.
@@ -656,5 +656,5 @@
 
 //++
-void Histo2D::GetError2(Matrix &v)
+void Histo2D::GetError2(OMatrix &v)
 //
 //	Remplissage d'un tableau avec les valeurs du carre des erreurs.
@@ -670,5 +670,5 @@
 
 //++
-void Histo2D::GetError(Matrix &v)
+void Histo2D::GetError(OMatrix &v)
 //
 //	Remplissage d'un tableau avec les valeurs des erreurs.
@@ -685,5 +685,5 @@
 ///////////////////////////////////////////////////////////////////
 //++
-void Histo2D::PutValue(Matrix &v, int ierr)
+void Histo2D::PutValue(OMatrix &v, int ierr)
 //
 //	Remplissage du contenu de l'histo avec les valeurs d'un tableau.
@@ -700,5 +700,5 @@
 
 //++
-void Histo2D::PutValueAdd(Matrix &v, int ierr)
+void Histo2D::PutValueAdd(OMatrix &v, int ierr)
 //
 //	Addition du contenu de l'histo avec les valeurs d'un tableau.
@@ -715,5 +715,5 @@
 
 //++
-void Histo2D::PutError2(Matrix &v)
+void Histo2D::PutError2(OMatrix &v)
 //
 //	Remplissage des erreurs au carre de l'histo
@@ -729,5 +729,5 @@
 
 //++
-void Histo2D::PutError2Add(Matrix &v)
+void Histo2D::PutError2Add(OMatrix &v)
 //
 //	Addition des erreurs au carre de l'histo
@@ -744,5 +744,5 @@
 
 //++
-void Histo2D::PutError(Matrix &v)
+void Histo2D::PutError(OMatrix &v)
 //
 //	Remplissage des erreurs de l'histo avec les valeurs d'un tableau.
@@ -1105,5 +1105,5 @@
 if(f==NULL)
   throw(NullPtrError("Histo2D::FitResidus: NULL pointer\n"));
-Vector par = gfit.GetParm();
+OVector par = gfit.GetParm();
 Histo2D h2(*this);
 for(int i=0;i<NBinX();i++) for(int j=0;j<NBinY();j++) {
@@ -1127,5 +1127,5 @@
 if(f==NULL)
   throw(NullPtrError("Histo2D::FitFunction: NULL pointer\n"));
-Vector par = gfit.GetParm();
+OVector par = gfit.GetParm();
 Histo2D h2(*this);
 for(int i=0;i<NBinX();i++) for(int j=0;j<NBinY();j++) {
Index: /trunk/SophyaLib/NTools/histos2.h
===================================================================
--- /trunk/SophyaLib/NTools/histos2.h	(revision 507)
+++ /trunk/SophyaLib/NTools/histos2.h	(revision 508)
@@ -63,14 +63,14 @@
 
   // get/put dans/depuis une matrice / vector
-  void GetXCoor(Vector& v);
-  void GetValue(Matrix &v);
-  void GetYCoor(Vector& v);
-  void GetError2(Matrix& v);
-  void GetError(Matrix& v);
-  void PutValue(Matrix& v, int ierr=0);
-  void PutValueAdd(Matrix& v, int ierr=0);
-  void PutError2(Matrix& v);
-  void PutError2Add(Matrix& v);
-  void PutError(Matrix& v);
+  void GetXCoor(OVector& v);
+  void GetValue(OMatrix &v);
+  void GetYCoor(OVector& v);
+  void GetError2(OMatrix& v);
+  void GetError(OMatrix& v);
+  void PutValue(OMatrix& v, int ierr=0);
+  void PutValueAdd(OMatrix& v, int ierr=0);
+  void PutError2(OMatrix& v);
+  void PutError2Add(OMatrix& v);
+  void PutError(OMatrix& v);
 
   // INLINES
Index: /trunk/SophyaLib/NTools/linfit.cc
===================================================================
--- /trunk/SophyaLib/NTools/linfit.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/linfit.cc	(revision 508)
@@ -5,11 +5,11 @@
 #include "cvector.h"
 
-double LinFit(const Vector& x, const Vector& y, int nf, double (*f)(int, double), 
-	   Vector& c)
+double LinFit(const OVector& x, const OVector& y, int nf, double (*f)(int, double), 
+	   OVector& c)
 {
   int n = x.NElts();
   if (n != y.NElts()) THROW(sizeMismatchErr);
   
-  Matrix fx(nf, n);
+  OMatrix fx(nf, n);
   for (int i=0; i<nf; i++)
     for (int j=0; j<n; j++)
@@ -21,5 +21,5 @@
 
 
-double LinFit(const Matrix& fx, const Vector& y, Vector& c)
+double LinFit(const OMatrix& fx, const OVector& y, OVector& c)
 {
   int n = y.NElts();
@@ -28,5 +28,5 @@
   int nf = fx.NRows();
 
-  Matrix a(nf,nf);
+  OMatrix a(nf,nf);
 
   for (int j=0; j<nf; j++)
@@ -36,5 +36,5 @@
   c = fx * y;
 
-  if (Matrix::GausPiv(a,c) == 0) THROW(singMatxErr);
+  if (OMatrix::GausPiv(a,c) == 0) THROW(singMatxErr);
 
   double xi2 = 0;
@@ -52,11 +52,11 @@
 
 
-double LinFit(const Vector& x, const Vector& y, const Vector& errY2, int nf,
-	   double (*f)(int, double), Vector& c, Vector& errC)
+double LinFit(const OVector& x, const OVector& y, const OVector& errY2, int nf,
+	   double (*f)(int, double), OVector& c, OVector& errC)
 {
   int n = x.NElts();
   if (n != y.NElts()) THROW(sizeMismatchErr);
   
-  Matrix fx(nf, n);
+  OMatrix fx(nf, n);
   for (int i=0; i<nf; i++)
     for (int j=0; j<n; j++)
@@ -67,6 +67,6 @@
 
 
-double LinFit(const Matrix& fx, const Vector& y, const Vector& errY2,
-	   Vector& c, Vector& errC)
+double LinFit(const OMatrix& fx, const OVector& y, const OVector& errY2,
+	   OVector& c, OVector& errC)
 {
   int n = y.NElts();
@@ -76,5 +76,5 @@
   int nf = fx.NRows();
 
-  Matrix a(nf,nf);
+  OMatrix a(nf,nf);
 
   c.Realloc(nf);
@@ -89,5 +89,5 @@
     }
  
-  Matrix d(nf,nf+1);
+  OMatrix d(nf,nf+1);
   for (int k=0; k<nf; k++) {
     double x=0;
@@ -99,5 +99,5 @@
   }
 
-  if (Matrix::GausPiv(a,d) == 0) THROW(singMatxErr);
+  if (OMatrix::GausPiv(a,d) == 0) THROW(singMatxErr);
 
   for (int l=0; l<nf; l++) {
Index: /trunk/SophyaLib/NTools/linfit.h
===================================================================
--- /trunk/SophyaLib/NTools/linfit.h	(revision 507)
+++ /trunk/SophyaLib/NTools/linfit.h	(revision 508)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: linfit.h,v 1.2 1999-10-21 18:45:46 ansari Exp $
+// $Id: linfit.h,v 1.3 1999-10-25 10:36:08 ansari Exp $
 //
 
@@ -10,13 +10,13 @@
 
 #include "machdefs.h"
-class Matrix;
-class Vector;
+class OMatrix;
+class OVector;
 
-double LinFit(const Vector& x, const Vector& y, int nf,
-	   double (*f)(int, double), Vector& c);
+double LinFit(const OVector& x, const OVector& y, int nf,
+	   double (*f)(int, double), OVector& c);
 // fit lineaire des y en tant que somme de c(i)f(i,x), i=0..nf-1;
 
 
-double LinFit(const Matrix& fx, const Vector& y, Vector& c);
+double LinFit(const OMatrix& fx, const OVector& y, OVector& c);
 // fit lineaire des y en tant que somme de c(i)f(i,x), i=0..nf-1,
 // la matrice fx contient les valeurs des f:
@@ -24,6 +24,6 @@
 		      
 
-double LinFit(const Vector& x, const Vector& y, const Vector& errY2, int nf,
-	   double (*f)(int, double), Vector& c, Vector& errC);
+double LinFit(const OVector& x, const OVector& y, const OVector& errY2, int nf,
+	   double (*f)(int, double), OVector& c, OVector& errC);
 // fit lineaire des y en tant que somme de c(i)f(i,x), i=0..nf-1,
 // errY2 contient les carres des erreurs sur les Y.
@@ -31,6 +31,6 @@
 
 
-double LinFit(const Matrix& fx, const Vector& y, const Vector& errY2,
-	   Vector& c, Vector& errC);
+double LinFit(const OMatrix& fx, const OVector& y, const OVector& errY2,
+	   OVector& c, OVector& errC);
 // fit lineaire des y en tant que somme de c(i)f(i,x), i=0..nf-1,
 // la matrice fx contient les valeurs des f:
Index: /trunk/SophyaLib/NTools/matrix.cc
===================================================================
--- /trunk/SophyaLib/NTools/matrix.cc	(revision 507)
+++ /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};
Index: /trunk/SophyaLib/NTools/matrix.h
===================================================================
--- /trunk/SophyaLib/NTools/matrix.h	(revision 507)
+++ /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];
Index: /trunk/SophyaLib/NTools/outilsinit.cc
===================================================================
--- /trunk/SophyaLib/NTools/outilsinit.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/outilsinit.cc	(revision 508)
@@ -32,6 +32,6 @@
 //   Enregistrement des classes PPersist du modules Outils++
   
-  PPRegister(Matrix);
-  PPRegister(Vector);
+  PPRegister(OMatrix);
+  PPRegister(OVector);
   PPRegister(Poly);
   PPRegister(Poly2);
@@ -73,5 +73,5 @@
   PPRegister(ImageR4);
 
-  //PPersistMgr::RegisterClass(Matrix::classId,  Matrix::Create);
+  //PPersistMgr::RegisterClass(OMatrix::classId,  OMatrix::Create);
 
   int pnice;
Index: /trunk/SophyaLib/NTools/pclassids.h
===================================================================
--- /trunk/SophyaLib/NTools/pclassids.h	(revision 507)
+++ /trunk/SophyaLib/NTools/pclassids.h	(revision 508)
@@ -20,8 +20,8 @@
    ClassId_DVList   = 0x0105,
 
-   ClassId_PMatrixF = 0x0110,
-   ClassId_PMatrixD = 0x0111,
-   ClassId_PVectorF = 0x0112,
-   ClassId_PVectorD = 0x0113,
+   ClassId_POMatrixF = 0x0110,
+   ClassId_POMatrixD = 0x0111,
+   ClassId_POVectorF = 0x0112,
+   ClassId_POVectorD = 0x0113,
 
    ClassId_Histo1D  = 0x0201,
Index: /trunk/SophyaLib/NTools/poly.cc
===================================================================
--- /trunk/SophyaLib/NTools/poly.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/poly.cc	(revision 508)
@@ -13,5 +13,5 @@
 //++
 // Links	Parents
-// Vector
+// OVector
 //--
 
@@ -29,5 +29,5 @@
 
 Poly::Poly(int degre)
-: Vector(degre+1), dirty(0), deg(0)
+: OVector(degre+1), dirty(0), deg(0)
 {
   END_CONSTRUCTOR
@@ -99,5 +99,5 @@
 
 //++
-int Poly::Roots(Vector& roots) const
+int Poly::Roots(OVector& roots) const
 //
 //	Retourne dans roots les racines réelles, si on sait
@@ -167,5 +167,5 @@
 {
   if (this == &a) return *this;
-  Vector::operator=(a);
+  OVector::operator=(a);
 
   UpdateDeg();
@@ -324,5 +324,5 @@
 #endif
 
-  Vector::ReadSelf(s);
+  OVector::ReadSelf(s);
 
 #ifdef DEBUG
@@ -341,5 +341,5 @@
   ((Poly*)(this))->Realloc(deg, true);
   s << deg;
-  Vector::WriteSelf(s);
+  OVector::WriteSelf(s);
 }
 
@@ -375,5 +375,5 @@
 
 //++
-double Poly::Fit(Vector const& x, Vector const& y, int degre)
+double Poly::Fit(OVector const& x, OVector const& y, int degre)
 //
 //	Ajustement polynomial par moindre carrés. Un polynôme de
@@ -387,5 +387,5 @@
   Realloc(degre);
 
-  Matrix a(degre+1, n);
+  OMatrix a(degre+1, n);
 
   for (int c=0; c<n; c++) {
@@ -397,5 +397,5 @@
   }
 
-  double rc = LinFit(a,y,(Vector&)*this);
+  double rc = LinFit(a,y,(OVector&)*this);
   UpdateDeg();
   return rc;
@@ -403,6 +403,6 @@
 
 //++
-double Poly::Fit(Vector const& x, Vector const& y, Vector const& erry2, int degre,
-                 Vector& errCoef)
+double Poly::Fit(OVector const& x, OVector const& y, OVector const& erry2, int degre,
+                 OVector& errCoef)
 //
 //	Ajustement polynomial par moindre carrés. Un polynôme de
@@ -419,5 +419,5 @@
   errCoef.Realloc(degre+1);
 
-  Matrix a(degre+1, n);
+  OMatrix a(degre+1, n);
 
   for (int c=0; c<n; c++) {
@@ -429,5 +429,5 @@
   }
 
-  double rc = LinFit(a,y,erry2,(Vector&)*this,errCoef);
+  double rc = LinFit(a,y,erry2,(OVector&)*this,errCoef);
   UpdateDeg();
   return rc;
@@ -482,5 +482,5 @@
 //++
 // Links	Parents
-// Vector
+// OVector
 //--
 
@@ -494,5 +494,5 @@
 //	Crée un polynôme de degrés partiels degreX et degreY.
 //--
-:Vector((degreX+1)*(degreY+1)), dirty(0),
+:OVector((degreX+1)*(degreY+1)), dirty(0),
  maxDegX(degreX), maxDegY(degreY), degX(0), degY(0), deg(0)
 {
@@ -506,5 +506,5 @@
 //	de deux polynômes à une variable, p2(x,y)=px(x)py(y)
 //--
-:Vector((polX.Degre()+1)*(polY.Degre()+1)), dirty(0),
+:OVector((polX.Degre()+1)*(polY.Degre()+1)), dirty(0),
  maxDegX(polX.Degre()), maxDegY(polY.Degre()),
  degX(polX.Degre()), degY(polY.Degre()), deg(degX+degY)
@@ -521,5 +521,5 @@
 //	Constructeur par copie.
 //--
-:Vector(a), dirty(a.dirty),
+:OVector(a), dirty(a.dirty),
  maxDegX(a.maxDegX), maxDegY(a.maxDegY),
  degX(a.degX), degY(a.degY), deg(a.deg)
@@ -561,5 +561,5 @@
   UpdateDegIfDirty();
   Poly2 tmp(*this);
-  Vector::Realloc((degreX+1)*(degreY+1));
+  OVector::Realloc((degreX+1)*(degreY+1));
   Zero();
   maxDegX = degreX;
@@ -631,5 +631,5 @@
 
 //++
-double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
+double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
                   int degreX, int degreY)
 //
@@ -643,5 +643,5 @@
   Realloc(degreX, degreY);
 
-  Matrix a((degreX+1)*(degreY+1), n);
+  OMatrix a((degreX+1)*(degreY+1), n);
 
   for (int c=0; c<n; c++) {
@@ -657,5 +657,5 @@
   }
 
-  double rc = LinFit(a,z,(Vector&)*this);
+  double rc = LinFit(a,z,(OVector&)*this);
   UpdateDeg();
   return rc;
@@ -664,7 +664,7 @@
 
 //++
-double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
-                  Vector const& errz2, int degreX, int degreY,
-                  Vector& errCoef)
+double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
+                  OVector const& errz2, int degreX, int degreY,
+                  OVector& errCoef)
 //
 //	Ajustement par moindre carrés z = P(x,y), degrés partiels imposés,
@@ -680,5 +680,5 @@
   errCoef.Realloc((degreX+1)*(degreY+1));
 
-  Matrix a((degreX+1)*(degreY+1), n);
+  OMatrix a((degreX+1)*(degreY+1), n);
 
   for (int c=0; c<n; c++) {
@@ -694,5 +694,5 @@
   }
 
-  double rc = LinFit(a,z,errz2,(Vector&)*this,errCoef);
+  double rc = LinFit(a,z,errz2,(OVector&)*this,errCoef);
   UpdateDeg();
   return rc;
@@ -700,5 +700,5 @@
 
 //++
-double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
+double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
                   int degre)
 //
@@ -712,6 +712,6 @@
   Realloc(degre, degre);   // certains vaudront 0, impose.
 
-  Matrix a((degre+1)*(degre+2)/2, n);
-  Vector cf((degre+1)*(degre+2)/2);
+  OMatrix a((degre+1)*(degre+2)/2, n);
+  OVector cf((degre+1)*(degre+2)/2);
 #define C_INDEX(i,j) ((i) + (j)*(2*degre+3-(j))/2)
 
@@ -744,7 +744,7 @@
 
 //++
-double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
-                  Vector const& errz2, int degre,
-                  Vector& errCoef)
+double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
+                  OVector const& errz2, int degre,
+                  OVector& errCoef)
 //
 //	Ajustement par moindre carrés z = P(x,y), degré total imposé,
@@ -761,7 +761,7 @@
 #define C_INDEX(i,j) ((i) + (j)*(2*degre+3-(j))/2)
 
-  Matrix a((degre+1)*(degre+2)/2, n);
-  Vector cf((degre+1)*(degre+2)/2);
-  Vector ecf((degre+1)*(degre+2)/2);
+  OMatrix a((degre+1)*(degre+2)/2, n);
+  OVector cf((degre+1)*(degre+2)/2);
+  OVector ecf((degre+1)*(degre+2)/2);
 
   for (int c=0; c<n; c++) {
@@ -806,5 +806,5 @@
 #endif
 
-  Vector::ReadSelf(s);
+  OVector::ReadSelf(s);
 
 #ifdef DEBUG
@@ -817,5 +817,5 @@
 {
   s << maxDegX << maxDegY;
-  Vector::WriteSelf(s);
+  OVector::WriteSelf(s);
 }
 
Index: /trunk/SophyaLib/NTools/poly.h
===================================================================
--- /trunk/SophyaLib/NTools/poly.h	(revision 507)
+++ /trunk/SophyaLib/NTools/poly.h	(revision 508)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: poly.h,v 1.1.1.1 1999-04-09 17:57:58 ansari Exp $
+// $Id: poly.h,v 1.2 1999-10-25 10:36:11 ansari Exp $
 //
 
@@ -16,5 +16,5 @@
 class Poly2;
 
-class Poly : public Vector {
+class Poly : public OVector {
 public:
   Poly(int degre = 0);
@@ -26,5 +26,5 @@
   inline int Degre() const {UpdateDegIfDirty(); return deg;}
 
-  inline void Realloc(int n, bool force=false) {Vector::Realloc(n+1,force);}
+  inline void Realloc(int n, bool force=false) {OVector::Realloc(n+1,force);}
 
   inline double operator[](int i) const {return data[i];}
@@ -41,5 +41,5 @@
   // Derive le polynome dans un autre
 
-  int    Roots(Vector& roots) const;
+  int    Roots(OVector& roots) const;
   // retourne les racines si on peut les calculer...
 
@@ -72,9 +72,9 @@
   friend ostream& operator << (ostream& s, const Poly& a);
 
-  double Fit(Vector const& x, Vector const& y, int degre);
+  double Fit(OVector const& x, OVector const& y, int degre);
   // Fit d'un polynome de degre donne sur les x et y.
 
-  double Fit(Vector const& x, Vector const& y, Vector const& erry2, int degre,
-            Vector& errCoef);
+  double Fit(OVector const& x, OVector const& y, OVector const& erry2, int degre,
+            OVector& errCoef);
   // En plus, on fournit les carres des erreurs sur y et on a les erreurs
   // sur les coefficients dans un vecteur.
@@ -90,5 +90,5 @@
 
 
-class Poly2 : public Vector {  // Ca pourrait etre une matrice mais
+class Poly2 : public OVector {  // Ca pourrait etre une matrice mais
                                   // la encore, un vecteur est utile pour les
                                   // fits.
@@ -131,17 +131,17 @@
   // retourne le coefficient de degre (dx,dy)
 
-  double Fit(Vector const& x, Vector const& y, Vector const& z,
+  double Fit(OVector const& x, OVector const& y, OVector const& z,
              int degreX, int degreY);
-  double Fit(Vector const& x, Vector const& y, Vector const& z,
-             Vector const& errz2, int degreX, int degreY,
-             Vector& errCoef);
+  double Fit(OVector const& x, OVector const& y, OVector const& z,
+             OVector const& errz2, int degreX, int degreY,
+             OVector& errCoef);
   // degres partiels imposes. cf Poly::Fit sinon
 
 
-  double Fit(Vector const& x, Vector const& y, Vector const& z,
+  double Fit(OVector const& x, OVector const& y, OVector const& z,
              int degre);
-  double Fit(Vector const& x, Vector const& y, Vector const& z,
-             Vector const& errz2, int degre,
-             Vector& errCoef);
+  double Fit(OVector const& x, OVector const& y, OVector const& z,
+             OVector const& errz2, int degre,
+             OVector& errCoef);
   // degre total impose. cf Poly::Fit sinon
 
Index: /trunk/SophyaLib/NTools/rk4cdifeq.cc
===================================================================
--- /trunk/SophyaLib/NTools/rk4cdifeq.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/rk4cdifeq.cc	(revision 508)
@@ -74,5 +74,5 @@
 //++
 RK4CDiffEq&  
-RK4CDiffEq::AbsAccuracy(Vector const& vScal)
+RK4CDiffEq::AbsAccuracy(OVector const& vScal)
 //
 //	On souhaite une précision absolue, et le vecteur vScal contient
@@ -118,5 +118,5 @@
 
 void
-RK4CDiffEq::RKCStep(Vector& newY, Vector const& y0, Vector const& yScale, 
+RK4CDiffEq::RKCStep(OVector& newY, OVector const& y0, OVector const& yScale, 
 	       double dttry, double& dtdone, double& dtnext)
 {
@@ -155,5 +155,5 @@
 
 void
-RK4CDiffEq::SolveArr(Matrix& y, double* t, double tf, int n)
+RK4CDiffEq::SolveArr(OMatrix& y, double* t, double tf, int n)
 {
   //TIMEF;
@@ -162,5 +162,5 @@
   double dxres = (tf - mXStart)/n;
 
-  Vector yt = mYStart;
+  OVector yt = mYStart;
   
   k1.Realloc(mFunc->NFuncReal());
Index: /trunk/SophyaLib/NTools/rk4cdifeq.h
===================================================================
--- /trunk/SophyaLib/NTools/rk4cdifeq.h	(revision 507)
+++ /trunk/SophyaLib/NTools/rk4cdifeq.h	(revision 508)
@@ -20,5 +20,5 @@
   // <group>
   RK4CDiffEq& Accuracy(double);
-  RK4CDiffEq& AbsAccuracy(Vector const& vScal);
+  RK4CDiffEq& AbsAccuracy(OVector const& vScal);
   RK4CDiffEq& AbsAccuracy(double scal);
   RK4CDiffEq& RelAccuracy();
@@ -26,16 +26,16 @@
   
   // Implementation RK4 adaptatif
-  virtual void SolveArr(Matrix& y, double* t, double tf, int n);
+  virtual void SolveArr(OMatrix& y, double* t, double tf, int n);
 
 protected:
   // Un pas adaptatif
-  void RKCStep(Vector& newY, Vector const& y0, Vector const& yScale, 
+  void RKCStep(OVector& newY, OVector const& y0, OVector const& yScale, 
 	       double dttry, double& dtdone, double& dtnext);
 
   double eps;
   bool   relAccuracy;
-  Vector accScale;
-  Vector yTemp; // Pour ne pas reallouer
-  Vector ySave;
+  OVector accScale;
+  OVector yTemp; // Pour ne pas reallouer
+  OVector ySave;
 };
 
Index: /trunk/SophyaLib/NTools/rzimage.cc
===================================================================
--- /trunk/SophyaLib/NTools/rzimage.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/rzimage.cc	(revision 508)
@@ -5,5 +5,5 @@
 // LAL (Orsay) / IN2P3-CNRS  DAPNIA/SPP (Saclay) / CEA
 
-//  $Id: rzimage.cc,v 1.4 1999-04-28 13:36:50 ansari Exp $
+//  $Id: rzimage.cc,v 1.5 1999-10-25 10:36:12 ansari Exp $
 
 #include "machdefs.h"
@@ -765,5 +765,5 @@
 GeneralFunction* f = gfit.GetFunction();
 if(f==NULL) return NULL;
-Vector par = gfit.GetParm();
+OVector par = gfit.GetParm();
 RzImage* img = new RzImage(DataType((r_4)0.),XSize(),YSize());
 img->SetOrg(XOrg(),YOrg());
@@ -790,5 +790,5 @@
 GeneralFunction* f = gfit.GetFunction();
 if(f==NULL) return NULL;
-Vector par = gfit.GetParm();
+OVector par = gfit.GetParm();
 RzImage* img = new RzImage(DataType((r_4)0.),XSize(),YSize());
 img->SetOrg(XOrg(),YOrg());
Index: /trunk/SophyaLib/NTools/tmatrix.cc
===================================================================
--- /trunk/SophyaLib/NTools/tmatrix.cc	(revision 507)
+++ /trunk/SophyaLib/NTools/tmatrix.cc	(revision 508)
@@ -1,3 +1,3 @@
-// $Id: tmatrix.cc,v 1.10 1999-10-23 10:21:23 ansari Exp $
+// $Id: tmatrix.cc,v 1.11 1999-10-25 10:36:12 ansari Exp $
 //                         C.Magneville          04/99
 #include "machdefs.h"
@@ -284,5 +284,5 @@
 TMatrix<r_8> b(mNc,mNr); TMatrix<r_8> a(*this); b = 1.;
 if(fabs(TMatrix<r_8>::GausPiv(a,b)) < 1.e-50)
-  throw(MathExc("TMatrix Inverse() Singular Matrix"));
+  throw(MathExc("TMatrix Inverse() Singular OMatrix"));
 return b;
 }
Index: /trunk/SophyaLib/NTools/tmatrix.h
===================================================================
--- /trunk/SophyaLib/NTools/tmatrix.h	(revision 507)
+++ /trunk/SophyaLib/NTools/tmatrix.h	(revision 508)
@@ -1,6 +1,6 @@
 // This may look like C code, but it is really -*- C++ -*-
 //                         C.Magneville          04/99
-#ifndef TMATRIX_SEEN
-#define TMATRIX_SEEN
+#ifndef TMatrix_SEEN
+#define TMatrix_SEEN
 
 #include "machdefs.h"
@@ -179,6 +179,6 @@
 
 ////////////////////////////////////////////////////////////////
-// Typedef pour simplifier
-// typedef TMatrix<r_8> Matrix;
+// Typedef pour simplifier et compatibilite Peida
+typedef TMatrix<r_8> Matrix;
 
 /////////////////////////////////////////////////////////////////////////
@@ -314,4 +314,8 @@
 inline T  TMatrixRC<T>::operator()(uint_4 i) const {return data[i*step];}
 
+////////////////////////////////////////////////////////////////
+// Typedef pour simplifier et compatibilite Peida
+typedef TMatrixRC<r_8> MatrixRC;
+
 } // Fin du namespace
 
Index: /trunk/SophyaLib/NTools/tvector.h
===================================================================
--- /trunk/SophyaLib/NTools/tvector.h	(revision 507)
+++ /trunk/SophyaLib/NTools/tvector.h	(revision 508)
@@ -1,6 +1,6 @@
 // This may look like C code, but it is really -*- C++ -*-
 //                         C.Magneville          05/99
-#ifndef TVECTOR_SEEN
-#define TVECTOR_SEEN
+#ifndef TVector_SEEN
+#define TVector_SEEN
 
 #include "tmatrix.h"
@@ -76,6 +76,6 @@
 }
 
-// Typedef pour simplifier
-// typedef TVector<r_8> Vector;
+// Typedef pour simplifier et compatibilite Peida
+typedef TVector<r_8> Vector;
 
 /////////////////////////////////////////////////////////////////////////
Index: /trunk/SophyaLib/Samba/anagen.cc
===================================================================
--- /trunk/SophyaLib/Samba/anagen.cc	(revision 507)
+++ /trunk/SophyaLib/Samba/anagen.cc	(revision 508)
@@ -37,5 +37,5 @@
     double phi0;
     float theta;
-    Vector phin, datan, phis, datas;
+    OVector phin, datan, phis, datas;
     map.GetThetaSlice(map.NbThetaSlices()-ith-1,theta,phis,datas);
     map.GetThetaSlice(ith,theta,phin,datan);
@@ -77,5 +77,5 @@
 
 
-void comp_phas2gen(int nsmax,int nlmax,int nmmax, Vector datain,
+void comp_phas2gen(int nsmax,int nlmax,int nmmax, OVector datain,
 	       	int nph,vector< complex<double> >& dataout,double phi0){
   /*=======================================================================
@@ -92,5 +92,5 @@
   //FFTVector outf=FFTServer::solve(inf,-1);
   FFTServer fft;
-  Vector outf;
+  OVector outf;
   //cout<<"in :"<<datain<<endl;
   fft.fftb(datain,outf);
Index: /trunk/SophyaLib/Samba/anagen.h
===================================================================
--- /trunk/SophyaLib/Samba/anagen.h	(revision 507)
+++ /trunk/SophyaLib/Samba/anagen.h	(revision 508)
@@ -10,5 +10,5 @@
 	     vector< vector< complex<double> > >& alm, double cos_theta_cut);
 
-void comp_phas2gen(int nsmax,int nlmax,int nmmax, Vector datain,
+void comp_phas2gen(int nsmax,int nlmax,int nmmax, OVector datain,
 	       	int nph,vector< complex<double> >& dataout,double phi0);
 
Index: /trunk/SophyaLib/Samba/syngen.cc
===================================================================
--- /trunk/SophyaLib/Samba/syngen.cc	(revision 507)
+++ /trunk/SophyaLib/Samba/syngen.cc	(revision 508)
@@ -43,5 +43,5 @@
     double phi0;
     float theta,thetas;
-    Vector phin, datan,phis,datas;
+    OVector phin, datan,phis,datas;
     map.GetThetaSlice(map.NbThetaSlices()-ith-1,thetas,phis,datas);
     map.GetThetaSlice(ith,theta,phin,datan);
@@ -104,5 +104,5 @@
 void syn_phasgen(const int nsmax,const int nlmax,const int nmmax,
 	      const vector< complex<long double> >& datain,
-	      int nph, Vector& dataout, double phi0,
+	      int nph, OVector& dataout, double phi0,
 	      vector< complex<long double> >& bw){
 
Index: /trunk/SophyaLib/Samba/syngen.h
===================================================================
--- /trunk/SophyaLib/Samba/syngen.h	(revision 507)
+++ /trunk/SophyaLib/Samba/syngen.h	(revision 508)
@@ -18,5 +18,5 @@
 void syn_phasgen(const int nsmax,const int nlmax,const int nmmax,
 	      const vector< complex<long double> >& datain,
-	      int nph, Vector& dataout, double phi0,
+	      int nph, OVector& dataout, double phi0,
 	      vector< complex<long double> >& bw);
 
Index: /trunk/SophyaLib/Samba/utilgeom.cc
===================================================================
--- /trunk/SophyaLib/Samba/utilgeom.cc	(revision 507)
+++ /trunk/SophyaLib/Samba/utilgeom.cc	(revision 508)
@@ -95,4 +95,4 @@
 }
 
-//Matrix vecTxMat(const Vector& v, const Matrix& M) {
+//OMatrix vecTxMat(const OVector& v, const OMatrix& M) {
   
