Index: trunk/SophyaLib/NTools/difeq.cc
===================================================================
--- trunk/SophyaLib/NTools/difeq.cc	(revision 513)
+++ trunk/SophyaLib/NTools/difeq.cc	(revision 514)
@@ -106,5 +106,5 @@
 //++
 DiffEqSolver&
-DiffEqSolver::StartV(OVector const& yi, double t)
+DiffEqSolver::StartV(Vector 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(OMatrix&  y, double* t, double tf, int n)=0
+// virtual void DiffEqSolver::SolveArr(Matrix&  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(OVector& yf, double tf)
+DiffEqSolver::SolveV(Vector& yf, double tf)
 //
 //	Lance la résolution de l'équadif, jusqu'à la valeur
@@ -201,5 +201,5 @@
 {
   double t;
-  OMatrix m(1, mFunc->NFuncReal());
+  Matrix m(1, mFunc->NFuncReal());
   SolveArr(m, &t, tf, 1);
   yf.Realloc(mFunc->NFunc());
@@ -219,5 +219,5 @@
   ASSERT(mFunc->NFunc() == 1);
   double t;
-  OMatrix m(1,mFunc->NFuncReal());
+  Matrix m(1,mFunc->NFuncReal());
   SolveArr(m, &t, tf, 1);
   yf = m(0,0);
@@ -238,5 +238,5 @@
 {
   double t;
-  OMatrix m(1, mFunc->NFuncReal());
+  Matrix 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);
-  OMatrix m(n, mFunc->NFuncReal());
+  Matrix m(n, mFunc->NFuncReal());
   SolveArr(m, t, tf, n);
   for (int i=0; i<n; i++)
@@ -281,5 +281,5 @@
 //--
 {
-   OMatrix m(n, mFunc->NFuncReal());
+   Matrix m(n, mFunc->NFuncReal());
    SolveArr(m, t, tf, n);
    for (int i=0; i<n; i++)
@@ -318,5 +318,5 @@
 
 //++
-//  virtual void ComputeV(OVector& fpi, OVector const& fi)
+//  virtual void ComputeV(Vector& fpi, Vector 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(OVector& start, double tstart)
+// virtual void AdjustStart(Vector& 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(OVector& fpi, OVector const& fi)
+DiffEqFcnT1::ComputeV(Vector& fpi, Vector const& fi)
 {
   fpi(0) = (*mFcn)(fi(0), fi(1));
@@ -412,5 +412,5 @@
 
 void
-DiffEqFcnT1::AdjustStart(OVector& start, double tstart)
+DiffEqFcnT1::AdjustStart(Vector& start, double tstart)
 {
   start.Realloc(2);
@@ -446,5 +446,5 @@
 
 void
-DiffEqFcn2::ComputeV(OVector& fpi, OVector const& fi)
+DiffEqFcn2::ComputeV(Vector& fpi, Vector const& fi)
 {
   fpi(0) = fi(1);
@@ -481,5 +481,5 @@
 
 void
-DiffEqFcnT2::ComputeV(OVector& fpi, OVector const& fi)
+DiffEqFcnT2::ComputeV(Vector& fpi, Vector const& fi)
 {
   fpi(0) = fi(1);
@@ -489,5 +489,5 @@
 
 void
-DiffEqFcnT2::AdjustStart(OVector& start, double tstart)
+DiffEqFcnT2::AdjustStart(Vector& start, double tstart)
 {
   start.Realloc(3);
@@ -505,6 +505,6 @@
 //	un vecteur de dimension 3.
 //	On fournit une fonction de type
-//|	typedef void(*DIFEQFCNV)(OVector& y2, OVector const& y1, 
-//|	                         OVector const& y);
+//|	typedef void(*DIFEQFCNV)(Vector& y2, Vector const& y1, 
+//|	                         Vector 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(OVector& fpi, OVector const& fi)
+DiffEqFcnV::ComputeV(Vector& fpi, Vector const& fi)
 {
   fpi(0) = fi(3);
@@ -582,5 +582,5 @@
 
 void
-RK4DiffEq::SolveArr(OMatrix& y, double* t, double tf, int n)
+RK4DiffEq::SolveArr(Matrix& y, double* t, double tf, int n)
 {
   //TIMEF;
@@ -592,5 +592,5 @@
    double dx = (tf - mXStart)/(n*nStep);
    
-   OVector yt = mYStart;
+   Vector yt = mYStart;
 
    k1.Realloc(mFunc->NFuncReal());
@@ -610,16 +610,16 @@
 
 void
-RK4DiffEq::RKStep(OVector& newY, OVector const& y0, double dt)
+RK4DiffEq::RKStep(Vector& newY, Vector const& y0, double dt)
 {
     mFunc->ComputeV(k1, y0);
     k1 *= dt;
-    mFunc->ComputeV(k2, y0 + k1/2);
+    mFunc->ComputeV(k2, y0 + k1/2.);
     k2 *= dt;
-    mFunc->ComputeV(k3, y0 + k2/2);
+    mFunc->ComputeV(k3, y0 + k2/2.);
     k3 *= dt;
     mFunc->ComputeV(k4, y0 + k3);
     k4 *= dt;
     
-    newY = y0 + (k1 + k2*2. + k3*2. + k4)/6;
-}
-
+    newY = y0 + (k1 + k2*2. + k3*2. + k4)/6.;
+}
+
Index: trunk/SophyaLib/NTools/difeq.h
===================================================================
--- trunk/SophyaLib/NTools/difeq.h	(revision 513)
+++ trunk/SophyaLib/NTools/difeq.h	(revision 514)
@@ -5,7 +5,9 @@
 #include "machdefs.h"
 #include "pexceptions.h"
-#include "cvector.h"
-
-namespace PlanckDPC {class GeneralFunction;}
+#include "tvector.h"
+
+namespace PlanckDPC {
+
+class GeneralFunction;
 
 // <summary> fonction pour equadifs </summary>
@@ -28,5 +30,5 @@
   
   // Calcule les valeurs des derivees fpi a partir des valeurs des fonctions fi
-  virtual void ComputeV(OVector& fpi, OVector const& fi)
+  virtual void ComputeV(Vector& fpi, Vector const& fi)
        { Compute(fpi(0), fi(0)); }
 
@@ -44,5 +46,5 @@
   // Pour ajuster vecteur de depart quand il y a des fonctions a usage
   // interne...
-  virtual void AdjustStart(OVector& /*start*/, double /*tstart*/) 
+  virtual void AdjustStart(Vector& /*start*/, double /*tstart*/) 
     {}   
 protected:
@@ -87,8 +89,8 @@
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
-  virtual void ComputeV(OVector& fpi, OVector const& fi);
+  virtual void ComputeV(Vector& fpi, Vector const& fi);
 
   // Implementation de AdjustStart qui gere la fonction a usage interne.
-  virtual void AdjustStart(OVector& start, double tstart);
+  virtual void AdjustStart(Vector& start, double tstart);
 protected:
   DIFEQFCNT1 mFcn;
@@ -102,5 +104,5 @@
   DiffEqFcn2(DIFEQFCN2);
 
-  virtual void ComputeV(OVector& fpi, OVector const& fi);
+  virtual void ComputeV(Vector& fpi, Vector const& fi);
 protected:
   DIFEQFCN2 mFcn;
@@ -121,8 +123,8 @@
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
-  virtual void ComputeV(OVector& fpi, OVector const& fi);
+  virtual void ComputeV(Vector& fpi, Vector const& fi);
 
   // Implementation de AdjustStart qui gere la fonction a usage interne.
-  virtual void AdjustStart(OVector& start, double tstart);
+  virtual void AdjustStart(Vector& start, double tstart);
 protected:
   DIFEQFCNT2 mFcn;
@@ -130,12 +132,12 @@
 
 // Cas y'' = f(y',y) avec des 3-vecteurs
-typedef void(*DIFEQFCNV)(OVector&, OVector const&, OVector const&);
+typedef void(*DIFEQFCNV)(Vector&, Vector const&, Vector const&);
 
 // <summary> y'' = f(y',y,t) </summary>
 // Cas y'' = f(y',y,t), on fournit la fonction f, sous la forme
-// double f(OVector), et ca construit la bonne DiffEqFunction
+// double f(Vector), et ca construit la bonne DiffEqFunction
 class DiffEqFcnV : public DiffEqFunction {
 public:
-  // Constructeur, on fournit une fonction (OVector)->double
+  // Constructeur, on fournit une fonction (Vector)->double
   // qui donne y'' en fonction du vecteur (t, y, y')
   DiffEqFcnV(DIFEQFCNV);
@@ -143,8 +145,8 @@
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
-  virtual void ComputeV(OVector& fpi, OVector const& fi);
+  virtual void ComputeV(Vector& fpi, Vector const& fi);
 protected:
   DIFEQFCNV mFcn;
-  OVector tmp1, tmp2, tmp3;
+  Vector tmp1, tmp2, tmp3;
 };
 
@@ -176,5 +178,5 @@
   // Change les conditions initiales. Notation chainee possible.
   // <group>
-  DiffEqSolver& StartV(OVector const& yi, double t);
+  DiffEqSolver& StartV(Vector const& yi, double t);
   // si NFunc == 1
   DiffEqSolver& Start1(double        yi, double t);
@@ -184,9 +186,9 @@
   // Lance la resolution, avec ou sans conservation de n valeurs intermediaires
   // <group>
-  virtual void SolveV(OVector& yf, double tf);
+  virtual void SolveV(Vector& yf, double tf);
   // si NFunc == 1
   virtual void Solve1(double& yf, double tf);  
   virtual void Solve(double* yf, double tf);
-  virtual void SolveArr(OMatrix&  y, double* t, double tf, int n)=0;
+  virtual void SolveArr(Matrix&  y, double* t, double tf, int n)=0;
   // si NFunc == 1
   virtual void SolveArr1(double*  y, double* t, double tf, int n);   
@@ -198,5 +200,5 @@
   bool mOwnFunc;
 
-  OVector  mYStart;
+  Vector  mYStart;
   double  mXStart;
   double  mStep;
@@ -215,14 +217,15 @@
 
   // Implementation de RK4
-  virtual void SolveArr(OMatrix& y, double* t, double tf, int n);
+  virtual void SolveArr(Matrix& y, double* t, double tf, int n);
 
 protected:
   // Un pas RK4
-  void RKStep(OVector& newY, OVector const& y0, double dt);
+  void RKStep(Vector& newY, Vector const& y0, double dt);
   // Vecteurs utilises en interne, pour ne pas les reallouer.
-  OVector k1, k2, k3, k4;
-};
-
-
+  Vector k1, k2, k3, k4;
+};
+
+
+} // Fin du namespace
 
 #endif
Index: trunk/SophyaLib/NTools/dvlist.cc
===================================================================
--- trunk/SophyaLib/NTools/dvlist.cc	(revision 513)
+++ trunk/SophyaLib/NTools/dvlist.cc	(revision 514)
@@ -37,7 +37,4 @@
 // PPersist
 //--
-
-
-using namespace PlanckDPC;
 
 char MuTyV::myStrBuf[64];   // Declare static ds le .h 
Index: trunk/SophyaLib/NTools/fct1dfit.cc
===================================================================
--- trunk/SophyaLib/NTools/fct1dfit.cc	(revision 513)
+++ trunk/SophyaLib/NTools/fct1dfit.cc	(revision 514)
@@ -8,6 +8,4 @@
 #include "nbconst.h"
 #include "tabmath.h"
-
-using namespace PlanckDPC;
 
 //define EXPO exp
Index: trunk/SophyaLib/NTools/fct2dfit.cc
===================================================================
--- trunk/SophyaLib/NTools/fct2dfit.cc	(revision 513)
+++ trunk/SophyaLib/NTools/fct2dfit.cc	(revision 514)
@@ -16,6 +16,4 @@
 #define EXPO tabFExp
 #define MINEXPM (100.)
-
-using namespace PlanckDPC;
 
 //================================================================
Index: trunk/SophyaLib/NTools/fftserver.cc
===================================================================
--- trunk/SophyaLib/NTools/fftserver.cc	(revision 513)
+++ trunk/SophyaLib/NTools/fftserver.cc	(revision 514)
@@ -156,9 +156,9 @@
 }
 
-void FFTServer::fftf(OVector& in, OVector& out)
+void FFTServer::fftf(Vector& in, Vector& out)
 {
   int l = in.NElts();
-/* ----- Si c'etait un OVector<float> on aurait ecrit comme ca 
-   Pour le moment OVector est double, on passe donc par un tableau 
+/* ----- Si c'etait un Vector<float> on aurait ecrit comme ca 
+   Pour le moment Vector 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(OVector& in, OVector& out)
+void FFTServer::fftb(Vector& in, Vector& out)
 {
   int l = in.NElts();
-/* ----- Si c'etait un OVector<float> on aurait ecrit comme ca 
-   Pour le moment OVector est double, on passe donc par un tableau 
+/* ----- Si c'etait un Vector<float> on aurait ecrit comme ca 
+   Pour le moment Vector 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 513)
+++ trunk/SophyaLib/NTools/fftserver.h	(revision 514)
@@ -3,5 +3,5 @@
 
 #include <complex>
-#include "cvector.h"
+#include "tvector.h"
 
 class FFTServer{
@@ -17,6 +17,6 @@
   virtual void fftf(int l, complex<double>* inout);
   virtual void fftb(int l, complex<double>* inout);
-  virtual void fftf(OVector& in, OVector& out);
-  virtual void fftb(OVector& in, OVector& out);
+  virtual void fftf(Vector& in, Vector& out);
+  virtual void fftb(Vector& in, Vector& out);
 
  protected:
@@ -94,9 +94,9 @@
   \param inout input array /output backward FFT(original array destroyed)
 */
-/*!\fn  virtual void FFTServer::fftf(OVector& in, OVector& out)
+/*!\fn  virtual void FFTServer::fftf(Vector& in, Vector& out)
   \param in input array
   \param out forward FFT
 */
-/*! \fn virtual void FFTServer::fftb(OVector& in, OVector& out)
+/*! \fn virtual void FFTServer::fftb(Vector& in, Vector& out)
   \param in input array
   \param out backward FFT
Index: trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- trunk/SophyaLib/NTools/generaldata.cc	(revision 513)
+++ trunk/SophyaLib/NTools/generaldata.cc	(revision 514)
@@ -14,6 +14,4 @@
 #include "pexceptions.h"
 #include "objfio.h"
-
-using namespace PlanckDPC;
 
 //================================================================
@@ -748,7 +746,7 @@
 if(varx<0 || varx>=mNVar) return -2.;
 if(mNDataGood<=0) return -4.;
-OVector x(mNDataGood);
-OVector y(mNDataGood);
-OVector ey2(1);
+Vector x(mNDataGood);
+Vector y(mNDataGood);
+Vector ey2(1);
 if(ey) ey2.Realloc(mNDataGood,true);
 int ntest = 0;
@@ -763,5 +761,5 @@
 double res = 0.;
 if(ey) {
-  OVector errcoef(1);
+  Vector errcoef(1);
   res = pol.Fit(x,y,ey2,degre,errcoef);
 } else {
@@ -797,8 +795,8 @@
 if(vary<0 || vary>=mNVar || vary==varx) return -3.;
 if(mNDataGood<=0) return -4.;
-OVector x(mNDataGood);
-OVector y(mNDataGood);
-OVector z(mNDataGood);
-OVector ez2(1);
+Vector x(mNDataGood);
+Vector y(mNDataGood);
+Vector z(mNDataGood);
+Vector ez2(1);
 if(ez) ez2.Realloc(mNDataGood,true);
 int ntest = 0;
@@ -814,5 +812,5 @@
 double res = 0.;
 if(ez) {
-  OVector errcoef(1);
+  Vector 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 513)
+++ trunk/SophyaLib/NTools/generalfit.cc	(revision 514)
@@ -9,9 +9,6 @@
 #include "pexceptions.h"
 #include "generalfit.h"
-#include "cvector.h"
 
 #define EPS_FIT_MIN 1.e-8
-
-using namespace PlanckDPC;
 
 //================================================================
@@ -874,5 +871,5 @@
 
 //++
-OVector GeneralFit::GetParm()
+Vector GeneralFit::GetParm()
 //
 //	Retourne les valeurs des parametres dans un vecteur.
@@ -1096,11 +1093,11 @@
 {
  volatile double oldChi2;
- 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);
+ 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);
  nStop = nStopL = nStep = 0;
  Chi2 = oldChi2 = 0.;
@@ -1515,5 +1512,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::write_in_step(double ci2,OVector& par)
+void GeneralFit::write_in_step(double ci2,Vector& par)
 {
 if(FileStep==NULL) return;
@@ -1524,11 +1521,11 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::TryFunc(OVector& par,OVector& par_tr)
+void GeneralFit::TryFunc(Vector& par,Vector& par_tr)
 {
   BETA_Try = 0;
   ATGA_Try = 0;
   Chi2  = 0;
-  OVector deriv(mNPar);
-  OVector derivtr(mNPar);
+  Vector deriv(mNPar);
+  Vector derivtr(mNPar);
   double result;
 
@@ -1564,5 +1561,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::TryXi2(OVector& par,OVector& par_tr)
+void GeneralFit::TryXi2(Vector& par,Vector& par_tr)
 {
   double c, *parloc;
@@ -1664,7 +1661,7 @@
 
 //////////////////////////////////////////////////////////////////////
-OVector GeneralFit::p_vers_tr(OVector const& p)
-{
- OVector tr(p);
+Vector GeneralFit::p_vers_tr(Vector const& p)
+{
+ Vector tr(p);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1675,5 +1672,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::p_vers_tr(OVector const& p,OVector& tr)
+void GeneralFit::p_vers_tr(Vector const& p,Vector& tr)
 {
  for(int i=0;i<mNPar;i++) {
@@ -1695,7 +1692,7 @@
 
 //////////////////////////////////////////////////////////////////////
-OVector GeneralFit::tr_vers_p(OVector const& tr)
-{
- OVector p(tr);
+Vector GeneralFit::tr_vers_p(Vector const& tr)
+{
+ Vector p(tr);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1706,5 +1703,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::tr_vers_p(OVector const& tr,OVector& p)
+void GeneralFit::tr_vers_p(Vector const& tr,Vector& p)
 {
  for(int i=0;i<mNPar;i++) {
@@ -1727,7 +1724,7 @@
 
 //////////////////////////////////////////////////////////////////////
-OVector GeneralFit::dp_vers_dtr(OVector const& dp,OVector const& tr)
-{
- OVector dtr(dp);
+Vector GeneralFit::dp_vers_dtr(Vector const& dp,Vector const& tr)
+{
+ Vector dtr(dp);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1738,5 +1735,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::dp_vers_dtr(OVector const& dp,OVector const& tr,OVector& dtr)
+void GeneralFit::dp_vers_dtr(Vector const& dp,Vector const& tr,Vector& dtr)
 {
  for(int i=0;i<mNPar;i++) {
@@ -1759,7 +1756,7 @@
 
 //////////////////////////////////////////////////////////////////////
-OVector GeneralFit::dtr_vers_dp(OVector const& dtr,OVector const& tr)
-{
- OVector dp(dtr);
+Vector GeneralFit::dtr_vers_dp(Vector const& dtr,Vector const& tr)
+{
+ Vector dp(dtr);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1771,8 +1768,8 @@
 //////////////////////////////////////////////////////////////////////
 // inline fonction pour aller + vite dans le try()
-//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)
+//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)
 // 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 513)
+++ trunk/SophyaLib/NTools/generalfit.h	(revision 514)
@@ -4,6 +4,5 @@
 
 #include "pexceptions.h"
-#include "matrix.h"
-#include "cvector.h"
+#include "tvector.h"
 #include "generaldata.h"
 
@@ -124,5 +123,5 @@
 
   double          GetParm(int);
-  OVector          GetParm();
+  Vector          GetParm();
   double          GetParmErr(int);
   double          GetCoVar(int,int);
@@ -168,11 +167,11 @@
   GeneralFitData*   mData;
 
-  OVector          Param;
-  OVector          errParam;
-  OVector          stepParam;
-  OVector          minParam;
-  OVector          maxParam;
-  OVector          minStepDeriv;
-  OVector          Eps;
+  Vector          Param;
+  Vector          errParam;
+  Vector          stepParam;
+  Vector          minParam;
+  Vector          maxParam;
+  Vector          minStepDeriv;
+  Vector          Eps;
   unsigned short int* fixParam;
   unsigned short int* boundParam;
@@ -188,10 +187,10 @@
   FILE            *FileStep;
   
-  OMatrix          ATGA;
-  OVector          BETA;
-  OMatrix          ATGA_Try;
-  OVector          BETA_Try;
-  OVector          C;
-  OVector          D;
+  Matrix          ATGA;
+  Vector          BETA;
+  Matrix          ATGA_Try;
+  Vector          BETA_Try;
+  Vector          C;
+  Vector          D;
   
   double          Chi2;
@@ -202,24 +201,24 @@
   
   // Fonctions privees
-  void       write_in_step(double ci2,OVector& par);
+  void       write_in_step(double ci2,Vector& par);
   void       General_Init(void);
-  void       TryFunc(OVector& par,OVector& par_tr);
-  void       TryXi2(OVector& par,OVector& par_tr);
+  void       TryFunc(Vector& par,Vector& par_tr);
+  void       TryXi2(Vector& par,Vector& par_tr);
   void       CheckSanity();
   void       Set_Bound_C_D(int i);
   void       Set_Bound_C_D();
   double     p_vers_tr(int i,double p);
-  OVector     p_vers_tr(OVector const& p);
-  void       p_vers_tr(OVector const& p,OVector& tr);
+  Vector     p_vers_tr(Vector const& p);
+  void       p_vers_tr(Vector const& p,Vector& tr);
   double     tr_vers_p(int i,double tr);
-  OVector     tr_vers_p(OVector const& tr);
-  void       tr_vers_p(OVector const& tr,OVector& p);
+  Vector     tr_vers_p(Vector const& tr);
+  void       tr_vers_p(Vector const& tr,Vector& p);
   double     c_dp_vers_dtr(int i,double tr);
-  OVector       dp_vers_dtr(OVector const& dp,OVector const& tr);
-  void         dp_vers_dtr(OVector const& dp,OVector const& tr,OVector& dtr);
+  Vector       dp_vers_dtr(Vector const& dp,Vector const& tr);
+  void         dp_vers_dtr(Vector const& dp,Vector const& tr,Vector& dtr);
   double     c_dtr_vers_dp(int i,double tr);
-  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)
+  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)
               {  for(int i=0;i<mNPar;i++)
                    { if( fixParam[i] ) continue;
Index: trunk/SophyaLib/NTools/hisprof.cc
===================================================================
--- trunk/SophyaLib/NTools/hisprof.cc	(revision 513)
+++ trunk/SophyaLib/NTools/hisprof.cc	(revision 514)
@@ -5,7 +5,4 @@
 #include "hisprof.h"
 #include "perrors.h"
-#include "cvector.h"
-
-using namespace PlanckDPC;
 
 //++
@@ -260,9 +257,9 @@
 //--
 //++
-// inline void GetMean(OVector& v)
+// inline void GetMean(Vector& v)
 //	Retourne le contenu de la moyenne dans le vecteur v
 //--
 //++
-// inline void GetError2(OVector& v)
+// inline void GetError2(Vector& 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 513)
+++ trunk/SophyaLib/NTools/hisprof.h	(revision 514)
@@ -4,5 +4,5 @@
 #include <stdio.h>
 #include "peida.h"
-#include "cvector.h"
+#include "tvector.h"
 #include "ppersist.h"
 #include "histos.h"
@@ -29,6 +29,6 @@
   // Acces a l information
   inline Histo GetHisto() {if(!Ok) UpdateHisto(); return (Histo) *this;}
-  inline void GetMean(OVector& v) {if(!Ok) UpdateHisto(); Histo::GetValue(v);}
-  inline void GetError2(OVector& v) {if(!Ok) UpdateHisto(); Histo::GetError2(v);}
+  inline void GetMean(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetValue(v);}
+  inline void GetError2(Vector& 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 513)
+++ trunk/SophyaLib/NTools/histos.cc	(revision 514)
@@ -1,4 +1,4 @@
 //
-// $Id: histos.cc,v 1.5 1999-10-25 10:36:07 ansari Exp $
+// $Id: histos.cc,v 1.6 1999-10-25 16:39:57 ansari Exp $
 //
 
@@ -9,10 +9,7 @@
 #include "histos.h"
 #include "perrors.h"
-#include "cvector.h"
 #include "poly.h"
 #include "strutil.h"
 #include "generalfit.h"
-
-using namespace PlanckDPC;
 
 //++
@@ -404,5 +401,5 @@
 /********* Methode *********/
 //++
-void Histo::GetAbsc(OVector &v)
+void Histo::GetAbsc(Vector &v)
 //
 //	Remplissage d'un tableau avec la valeur des abscisses
@@ -415,5 +412,5 @@
 
 //++
-void Histo::GetValue(OVector &v)
+void Histo::GetValue(Vector &v)
 //
 //	Remplissage d'un tableau avec la valeur du contenu
@@ -426,5 +423,5 @@
 
 //++
-void Histo::GetError2(OVector &v)
+void Histo::GetError2(Vector &v)
 //
 //	Remplissage d'un tableau avec la valeur des erreurs au carre
@@ -438,5 +435,5 @@
 
 //++
-void Histo::GetError(OVector &v)
+void Histo::GetError(Vector &v)
 //
 //	Remplissage d'un tableau avec la valeur des erreurs
@@ -451,5 +448,5 @@
 /********* Methode *********/
 //++
-void Histo::PutValue(OVector &v, int ierr)
+void Histo::PutValue(Vector &v, int ierr)
 //
 //	Remplissage du contenu de l'histo avec les valeurs d'un vecteur
@@ -465,5 +462,5 @@
 
 //++
-void Histo::PutValueAdd(OVector &v, int ierr)
+void Histo::PutValueAdd(Vector &v, int ierr)
 //
 //	Addition du contenu de l'histo avec les valeurs d'un vecteur
@@ -479,5 +476,5 @@
 
 //++
-void Histo::PutError2(OVector &v)
+void Histo::PutError2(Vector &v)
 //
 //	Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur
@@ -491,5 +488,5 @@
 
 //++
-void Histo::PutError2Add(OVector &v)
+void Histo::PutError2Add(Vector &v)
 //
 //	Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur
@@ -503,5 +500,5 @@
 
 //++
-void Histo::PutError(OVector &v)
+void Histo::PutError(Vector &v)
 //
 //	Remplissage des erreurs de l'histo avec les valeurs d'un vecteur
@@ -1121,8 +1118,8 @@
   }
 
-  OVector xFit(nLowHigh);
-  OVector yFit(nLowHigh);
-  OVector e2Fit(nLowHigh);
-  OVector errcoef(1);
+  Vector xFit(nLowHigh);
+  Vector yFit(nLowHigh);
+  Vector e2Fit(nLowHigh);
+  Vector errcoef(1);
   int ii = 0;
   for (int j=iLow; j<=iHigh; j++) {
@@ -1444,5 +1441,5 @@
 if(f==NULL)
   throw(NullPtrError("Histo::FitResidus: NULL pointer\n"));
-OVector par = gfit.GetParm();
+Vector par = gfit.GetParm();
 Histo h(*this);
 for(int i=0;i<NBins();i++) {
@@ -1464,5 +1461,5 @@
 if(f==NULL)
   throw(NullPtrError("Histo::FitFunction: NULL pointer\n"));
-OVector par = gfit.GetParm();
+Vector 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 513)
+++ trunk/SophyaLib/NTools/histos.h	(revision 514)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: histos.h,v 1.4 1999-10-25 10:36:07 ansari Exp $
+// $Id: histos.h,v 1.5 1999-10-25 16:39:57 ansari Exp $
 //
 
@@ -11,5 +11,5 @@
 #include <stdio.h>
 #include "peida.h"
-#include "cvector.h"
+#include "tvector.h"
 #include "ppersist.h"
 #include "anydataobj.h"
@@ -66,13 +66,13 @@
 
   // get/put dans/depuis un vector
-  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);
+  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);
 
   // INLINES
Index: trunk/SophyaLib/NTools/histos2.cc
===================================================================
--- trunk/SophyaLib/NTools/histos2.cc	(revision 513)
+++ trunk/SophyaLib/NTools/histos2.cc	(revision 514)
@@ -15,6 +15,4 @@
 #include "histos2.h"
 #include "generalfit.h"
-
-using namespace PlanckDPC;
 
 //++
@@ -603,5 +601,5 @@
 ///////////////////////////////////////////////////////////////////
 //++
-void Histo2D::GetXCoor(OVector &v)
+void Histo2D::GetXCoor(Vector &v)
 //
 //	Remplissage d'un tableau avec les valeurs des abscisses.
@@ -615,5 +613,5 @@
 
 //++
-void Histo2D::GetYCoor(OVector &v)
+void Histo2D::GetYCoor(Vector &v)
 //
 //	Remplissage d'un tableau avec les valeurs des ordonnees.
@@ -644,5 +642,5 @@
 
 //++
-void Histo2D::GetValue(OMatrix &v)
+void Histo2D::GetValue(Matrix &v)
 //
 //	Remplissage d'un tableau avec les valeurs du contenu.
@@ -656,5 +654,5 @@
 
 //++
-void Histo2D::GetError2(OMatrix &v)
+void Histo2D::GetError2(Matrix &v)
 //
 //	Remplissage d'un tableau avec les valeurs du carre des erreurs.
@@ -670,5 +668,5 @@
 
 //++
-void Histo2D::GetError(OMatrix &v)
+void Histo2D::GetError(Matrix &v)
 //
 //	Remplissage d'un tableau avec les valeurs des erreurs.
@@ -685,5 +683,5 @@
 ///////////////////////////////////////////////////////////////////
 //++
-void Histo2D::PutValue(OMatrix &v, int ierr)
+void Histo2D::PutValue(Matrix &v, int ierr)
 //
 //	Remplissage du contenu de l'histo avec les valeurs d'un tableau.
@@ -700,5 +698,5 @@
 
 //++
-void Histo2D::PutValueAdd(OMatrix &v, int ierr)
+void Histo2D::PutValueAdd(Matrix &v, int ierr)
 //
 //	Addition du contenu de l'histo avec les valeurs d'un tableau.
@@ -715,5 +713,5 @@
 
 //++
-void Histo2D::PutError2(OMatrix &v)
+void Histo2D::PutError2(Matrix &v)
 //
 //	Remplissage des erreurs au carre de l'histo
@@ -729,5 +727,5 @@
 
 //++
-void Histo2D::PutError2Add(OMatrix &v)
+void Histo2D::PutError2Add(Matrix &v)
 //
 //	Addition des erreurs au carre de l'histo
@@ -744,5 +742,5 @@
 
 //++
-void Histo2D::PutError(OMatrix &v)
+void Histo2D::PutError(Matrix &v)
 //
 //	Remplissage des erreurs de l'histo avec les valeurs d'un tableau.
@@ -1105,5 +1103,5 @@
 if(f==NULL)
   throw(NullPtrError("Histo2D::FitResidus: NULL pointer\n"));
-OVector par = gfit.GetParm();
+Vector par = gfit.GetParm();
 Histo2D h2(*this);
 for(int i=0;i<NBinX();i++) for(int j=0;j<NBinY();j++) {
@@ -1127,5 +1125,5 @@
 if(f==NULL)
   throw(NullPtrError("Histo2D::FitFunction: NULL pointer\n"));
-OVector par = gfit.GetParm();
+Vector 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 513)
+++ trunk/SophyaLib/NTools/histos2.h	(revision 514)
@@ -63,14 +63,14 @@
 
   // get/put dans/depuis une matrice / vector
-  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);
+  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);
 
   // INLINES
Index: trunk/SophyaLib/NTools/integ.h
===================================================================
--- trunk/SophyaLib/NTools/integ.h	(revision 513)
+++ trunk/SophyaLib/NTools/integ.h	(revision 514)
@@ -3,5 +3,5 @@
 // integ.h
 //
-// $Id: integ.h,v 1.4 1999-10-21 15:25:49 ansari Exp $
+// $Id: integ.h,v 1.5 1999-10-25 16:39:59 ansari Exp $
 //
 
@@ -13,5 +13,7 @@
 #include <set>
 
-namespace PlanckDPC {class GeneralFunction;}
+namespace PlanckDPC {
+
+class GeneralFunction;
 
 class Integrator EXC_AWARE {
@@ -95,5 +97,5 @@
 };
 
-
+} // Fin du namespace
 
 #endif
Index: trunk/SophyaLib/NTools/linfit.cc
===================================================================
--- trunk/SophyaLib/NTools/linfit.cc	(revision 513)
+++ trunk/SophyaLib/NTools/linfit.cc	(revision 514)
@@ -2,14 +2,12 @@
 #include "peida.h"
 #include "linfit.h"
-#include "matrix.h"
-#include "cvector.h"
 
-double LinFit(const OVector& x, const OVector& y, int nf, double (*f)(int, double), 
-	   OVector& c)
+double LinFit(const Vector& x, const Vector& y, int nf, double (*f)(int, double), 
+	   Vector& c)
 {
   int n = x.NElts();
   if (n != y.NElts()) THROW(sizeMismatchErr);
   
-  OMatrix fx(nf, n);
+  Matrix fx(nf, n);
   for (int i=0; i<nf; i++)
     for (int j=0; j<n; j++)
@@ -21,5 +19,5 @@
 
 
-double LinFit(const OMatrix& fx, const OVector& y, OVector& c)
+double LinFit(const Matrix& fx, const Vector& y, Vector& c)
 {
   int n = y.NElts();
@@ -28,5 +26,5 @@
   int nf = fx.NRows();
 
-  OMatrix a(nf,nf);
+  Matrix a(nf,nf);
 
   for (int j=0; j<nf; j++)
@@ -36,5 +34,5 @@
   c = fx * y;
 
-  if (OMatrix::GausPiv(a,c) == 0) THROW(singMatxErr);
+  if (Matrix::GausPiv(a,c) == 0) THROW(singMatxErr);
 
   double xi2 = 0;
@@ -52,11 +50,11 @@
 
 
-double LinFit(const OVector& x, const OVector& y, const OVector& errY2, int nf,
-	   double (*f)(int, double), OVector& c, OVector& errC)
+double LinFit(const Vector& x, const Vector& y, const Vector& errY2, int nf,
+	   double (*f)(int, double), Vector& c, Vector& errC)
 {
   int n = x.NElts();
   if (n != y.NElts()) THROW(sizeMismatchErr);
   
-  OMatrix fx(nf, n);
+  Matrix fx(nf, n);
   for (int i=0; i<nf; i++)
     for (int j=0; j<n; j++)
@@ -67,6 +65,6 @@
 
 
-double LinFit(const OMatrix& fx, const OVector& y, const OVector& errY2,
-	   OVector& c, OVector& errC)
+double LinFit(const Matrix& fx, const Vector& y, const Vector& errY2,
+	   Vector& c, Vector& errC)
 {
   int n = y.NElts();
@@ -76,5 +74,5 @@
   int nf = fx.NRows();
 
-  OMatrix a(nf,nf);
+  Matrix a(nf,nf);
 
   c.Realloc(nf);
@@ -89,5 +87,5 @@
     }
  
-  OMatrix d(nf,nf+1);
+  Matrix d(nf,nf+1);
   for (int k=0; k<nf; k++) {
     double x=0;
@@ -99,5 +97,5 @@
   }
 
-  if (OMatrix::GausPiv(a,d) == 0) THROW(singMatxErr);
+  if (Matrix::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 513)
+++ trunk/SophyaLib/NTools/linfit.h	(revision 514)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: linfit.h,v 1.3 1999-10-25 10:36:08 ansari Exp $
+// $Id: linfit.h,v 1.4 1999-10-25 16:40:00 ansari Exp $
 //
 
@@ -10,13 +10,14 @@
 
 #include "machdefs.h"
-class OMatrix;
-class OVector;
+#include "tvector.h"
 
-double LinFit(const OVector& x, const OVector& y, int nf,
-	   double (*f)(int, double), OVector& c);
+namespace PlanckDPC {
+
+double LinFit(const Vector& x, const Vector& y, int nf,
+	   double (*f)(int, double), Vector& c);
 // fit lineaire des y en tant que somme de c(i)f(i,x), i=0..nf-1;
 
 
-double LinFit(const OMatrix& fx, const OVector& y, OVector& c);
+double LinFit(const Matrix& fx, const Vector& y, Vector& 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 +25,6 @@
 		      
 
-double LinFit(const OVector& x, const OVector& y, const OVector& errY2, int nf,
-	   double (*f)(int, double), OVector& c, OVector& errC);
+double LinFit(const Vector& x, const Vector& y, const Vector& errY2, int nf,
+	   double (*f)(int, double), Vector& c, Vector& 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 +32,6 @@
 
 
-double LinFit(const OMatrix& fx, const OVector& y, const OVector& errY2,
-	   OVector& c, OVector& errC);
+double LinFit(const Matrix& fx, const Vector& y, const Vector& errY2,
+	   Vector& c, Vector& 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:
@@ -39,3 +40,5 @@
 // au retour, errC contient les erreurs sur les coefs.
 
+} // Fin du namespace
+
 #endif // LINFIT_SEEN 
Index: trunk/SophyaLib/NTools/outilsinit.cc
===================================================================
--- trunk/SophyaLib/NTools/outilsinit.cc	(revision 513)
+++ trunk/SophyaLib/NTools/outilsinit.cc	(revision 514)
@@ -34,6 +34,6 @@
   PPRegister(OMatrix);
   PPRegister(OVector);
-  PPRegister(Poly);
-  PPRegister(Poly2);
+  PPRegister(ObjFileIO<Poly>);
+  PPRegister(ObjFileIO<Poly2>);
   PPRegister(ObjFileIO<DVList>);
   PPRegister(ObjFileIO<Histo>);
Index: trunk/SophyaLib/NTools/poly.cc
===================================================================
--- trunk/SophyaLib/NTools/poly.cc	(revision 513)
+++ trunk/SophyaLib/NTools/poly.cc	(revision 514)
@@ -13,5 +13,5 @@
 //++
 // Links	Parents
-// OVector
+// Vector
 //--
 
@@ -21,4 +21,5 @@
 
 
+//////////////////////////////////////////////////////////////////////////
 //++
 // Poly::Poly(int degre=0)
@@ -29,14 +30,24 @@
 
 Poly::Poly(int degre)
-: OVector(degre+1), dirty(0), deg(0)
+: Vector(degre+1), dirty(0), deg(0)
 {
   END_CONSTRUCTOR
 }
 
+//++
+Poly::Poly(Poly const& a)
+//
+//	Constructeur par copie.
+//--
+:Vector(a), dirty(a.dirty), deg(a.deg)
+{
+  END_CONSTRUCTOR
+}
+
 
 void Poly::UpdateDeg() const
 {
-  int i = nalloc-1;
-  while (data[i] == 0 && i>0) i--;
+  int i = NElts()-1;
+  while (Element(i) == 0 && i>0) i--;
 
   (int&) deg = i;          // bientot mutable dans ANSI C++ 
@@ -61,8 +72,8 @@
 {
   UpdateDegIfDirty();
-  double res = data[deg];
+  double res = Element(deg);
   for (int i=deg-1; i>=0; i--) {
     res *= x;
-    res += data[i];
+    res += Element(i);
   }
   return res;
@@ -76,8 +87,8 @@
 {
   UpdateDegIfDirty();
-  if (deg == 0) { data[0] = 0; return;}
+  if (deg == 0) { Element(0) = 0; return;}
   for (int i=1; i<=deg; i++)
-    data[i-1] = data[i]*i;
-  data[deg] = 0;
+    Element(i-1) = Element(i)*i;
+  Element(deg) = 0;
   deg--;
 }
@@ -94,10 +105,10 @@
 //  der.Zero();    // on sait que Realloc met a zero le reste.
   for (int i=1; i<=deg; i++)
-    der.data[i-1] = data[i]*i;
-}
-
-
-//++
-int Poly::Roots(OVector& roots) const
+    der.Element(i-1) = Element(i)*i;
+}
+
+
+//++
+int Poly::Roots(Vector& roots) const
 //
 //	Retourne dans roots les racines réelles, si on sait
@@ -133,6 +144,6 @@
   if (deg != 1) THROW(sizeMismatchErr);
 
-  if (data[1] == 0) return 0;
-  r = -data[0]/data[1];
+  if (Element(1) == 0) return 0;
+  r = -Element(0)/Element(1);
   return 1;
 }
@@ -149,12 +160,12 @@
   if (deg != 2) THROW(sizeMismatchErr);
 
-  double delta = data[1]*data[1] - 4*data[0]*data[2];
+  double delta = Element(1)*Element(1) - 4*Element(0)*Element(2);
   if (delta < 0) return 0;
   if (delta == 0) {
-    r1 = r2 = -data[1]/2/data[0];
+    r1 = r2 = -Element(1)/2/Element(0);
     return 1;
   }
-  r1 = (-data[1] - sqrt(delta))/2/data[0];
-  r2 = (-data[1] + sqrt(delta))/2/data[0];
+  r1 = (-Element(1) - sqrt(delta))/2/Element(0);
+  r2 = (-Element(1) + sqrt(delta))/2/Element(0);
   return 2;
 }
@@ -167,5 +178,5 @@
 {
   if (this == &a) return *this;
-  OVector::operator=(a);
+  Vector::operator=(a);
 
   UpdateDeg();
@@ -185,10 +196,8 @@
   b.UpdateDegIfDirty();
 
-  if (b.deg > deg)
-    Realloc(b.deg);
+  if (b.deg > deg) Realloc(b.deg);
 
   int n = (deg > b.deg) ? deg : b.deg;
-  for (int i=0; i<=n; i++)
-    data[i] += b.data[i];
+  for (int i=0; i<=n; i++) Element(i) += b.Element(i);
 
   UpdateDeg();
@@ -204,10 +213,8 @@
   b.UpdateDegIfDirty();
 
-  if (b.deg > deg)
-    Realloc(b.deg);
+  if (b.deg > deg) Realloc(b.deg);
 
   int n = (deg > b.deg) ? deg : b.deg;
-  for (int i=0; i<=n; i++)
-    data[i] -= b.data[i];
+  for (int i=0; i<=n; i++) Element(i) -= b.Element(i);
 
   UpdateDeg();
@@ -215,131 +222,33 @@
 }
 
-
-//++
-Poly operator+ (Poly const& a, Poly const& b)
-//
-//--
-#if HAS_NAMED_RETURN
-     return c((a.deg > b.deg)?(a.deg+1):(b.deg+1))
-#endif
-{
-#if !HAS_NAMED_RETURN
-Poly c((a.deg > b.deg)?(a.deg+1):(b.deg+1));
-#endif
-  c = a;
-  c += b;
-#if !HAS_NAMED_RETURN
-return c;
-#endif
-}
-
-//++
-Poly operator- (Poly const& a, Poly const& b)
-//
-//--
-#if HAS_NAMED_RETURN
-     return c((a.deg > b.deg)?(a.deg+1):(b.deg+1))
-#endif
-{
-#if !HAS_NAMED_RETURN
-Poly c((a.deg > b.deg)?(a.deg+1):(b.deg+1));
-#endif
-  c = a;
-  c -= b;
-#if !HAS_NAMED_RETURN
-return c;
-#endif
-}
-
-//++
-Poly operator* (Poly const& a, Poly const& b)
-//
-//--
-//#if HAS_NAMED_RETURN
-//     return c(a.deg + b.deg)
-//#endif
-{
-//#if !HAS_NAMED_RETURN
-Poly c(a.deg + b.deg);
-//#endif
-  a.UpdateDegIfDirty();
+//++
+Poly& Poly::operator *= (double a)
+//
+//--
+{
+  UpdateDegIfDirty();
+  for (int i=0; i<=deg; i++) Element(i) *= a;
+  return *this;
+}
+
+//++
+Poly Poly::Mult(Poly const& b) const
+//
+//--
+{
+Poly c(deg + b.deg);
+  UpdateDegIfDirty();
   b.UpdateDegIfDirty();
 
-  c.deg = a.deg + b.deg;
+  c.deg = deg + b.deg;
 
   for (int i=0; i<=c.deg; i++) {
     c[i] = 0;
-    int kmin = (i <= a.deg) ? 0 : i - a.deg;
-    int kmax = (i <= a.deg) ? i : a.deg;
+    int kmin = (i <= deg) ? 0 : i - deg;
+    int kmax = (i <= deg) ? i : deg;
     for (int k=kmin; k<=kmax; k++)
-      c[i] += a[k] * b[i-k];
-  }
-//#if !HAS_NAMED_RETURN
+      c[i] += (*this)[k] * b[i-k];
+  }
 return c;
-//#endif
-}
-
-//++
-Poly& Poly::operator *= (double a)
-//
-//--
-{
-  UpdateDegIfDirty();
-
-  for (int i=0; i<=deg; i++)
-    data[i] *= a;
-
-  return *this;
-}
-
-
-//++
-Poly operator* (double a, Poly const& b)
-//
-//--
-#if HAS_NAMED_RETURN
-     return c(b)
-#endif
-{
-#if !HAS_NAMED_RETURN
-  Poly c(b);
-#endif
-
-   c *= a;
-
-#if !HAS_NAMED_RETURN
-  return c;
-#endif
-}
-
-
-void Poly::ReadSelf(PInPersist& s)
-{
-  int_4 dg;
-  s >> dg;
-  Realloc(dg, true);
-
-#ifdef DEBUG
-  int r = nr; int c = nc;
-#endif
-
-  OVector::ReadSelf(s);
-
-#ifdef DEBUG
-  DBASSERT(r == nr && c == nc);
-#endif
-  UpdateDeg();
-
-  #ifdef DEBUG
-  DBASSERT(dg == deg);
-  #endif
-}
-
-void Poly::WriteSelf(POutPersist& s) const
-{
-  UpdateDegIfDirty();
-  ((Poly*)(this))->Realloc(deg, true);
-  s << deg;
-  OVector::WriteSelf(s);
 }
 
@@ -365,15 +274,5 @@
 
 //++
-ostream& operator << (ostream& s, const Poly& a)
-//
-//	Impressions sur le stream "s".
-//--
-{
-  a.Print(s);
-  return s;
-}
-
-//++
-double Poly::Fit(OVector const& x, OVector const& y, int degre)
+double Poly::Fit(Vector const& x, Vector const& y, int degre)
 //
 //	Ajustement polynomial par moindre carrés. Un polynôme de
@@ -387,5 +286,5 @@
   Realloc(degre);
 
-  OMatrix a(degre+1, n);
+  Matrix a(degre+1, n);
 
   for (int c=0; c<n; c++) {
@@ -397,5 +296,5 @@
   }
 
-  double rc = LinFit(a,y,(OVector&)*this);
+  double rc = LinFit(a,y,(Vector&)*this);
   UpdateDeg();
   return rc;
@@ -403,6 +302,6 @@
 
 //++
-double Poly::Fit(OVector const& x, OVector const& y, OVector const& erry2, int degre,
-                 OVector& errCoef)
+double Poly::Fit(Vector const& x, Vector const& y, Vector const& erry2, int degre,
+                 Vector& errCoef)
 //
 //	Ajustement polynomial par moindre carrés. Un polynôme de
@@ -419,5 +318,5 @@
   errCoef.Realloc(degre+1);
 
-  OMatrix a(degre+1, n);
+  Matrix a(degre+1, n);
 
   for (int c=0; c<n; c++) {
@@ -429,9 +328,58 @@
   }
 
-  double rc = LinFit(a,y,erry2,(OVector&)*this,errCoef);
+  double rc = LinFit(a,y,erry2,(Vector&)*this,errCoef);
   UpdateDeg();
   return rc;
 }
 
+
+//++
+// Poly Poly::power(int n) const
+//
+//	Retourne le polynôme à la puissance n
+//--
+
+Poly Poly::power(int n) const // a accelerer !!!
+{
+  if (n < 0) THROW(rangeCheckErr);
+  if (n == 0) { Poly r(0); r[0] = 1; return r;}
+  if (n == 1) { return *this; }
+  return *this * power(n-1);
+}
+
+//++
+Poly Poly::operator() (Poly const& b) const
+//
+//	Substitution d'un polynôme dans un autre.
+//--
+{
+  Poly c(b.Degre()*Degre());
+  for (int i=0; i<= Degre(); i++)
+    c += (*this)[i] * b.power(i);
+  return c;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+void ObjFileIO<Poly>::ReadSelf(PInPersist& is)
+{
+if(dobj==NULL) dobj=new Poly;
+int_4 dg;
+is >> dg;
+dobj->Realloc(dg,true);
+is >> *((Vector *) dobj);
+dobj->UpdateDeg();
+}
+
+void ObjFileIO<Poly>::WriteSelf(POutPersist& os) const
+{
+if(dobj == NULL) return;
+dobj->UpdateDegIfDirty();
+dobj->Realloc(dobj->deg,true);
+os << dobj->deg;
+os << *((Vector *) dobj);
+}
+
+//////////////////////////////////////////////////////////////////////////
 int binomial(int n, int p)
 {
@@ -442,34 +390,6 @@
 }
 
-
-//++
-// Poly Poly::power(int n) const
-//
-//	Retourne le polynôme à la puissance n
-//--
-
-Poly Poly::power(int n) const // a accelerer !!!
-{
-  if (n < 0) THROW(rangeCheckErr);
-  if (n == 0) { Poly r(0); r[0] = 1; return r;}
-  if (n == 1) { return *this; }
-  return *this * power(n-1);
-}
-
-//++
-Poly Poly::operator() (Poly const& b) const
-//
-//	Substitution d'un polynôme dans un autre.
-//--
-{
-  Poly c(b.Degre()*Degre());
-  for (int i=0; i<= Degre(); i++)
-    c += (*this)[i] * b.power(i);
-  return c;
-}
-
-
+//////////////////////////////////////////////////////////////////////////
 // ******************* POLY 2 VARIABLES ******************
-
 //++
 // Class	Poly2
@@ -482,5 +402,5 @@
 //++
 // Links	Parents
-// OVector
+// Vector
 //--
 
@@ -494,5 +414,5 @@
 //	Crée un polynôme de degrés partiels degreX et degreY.
 //--
-:OVector((degreX+1)*(degreY+1)), dirty(0),
+:Vector((degreX+1)*(degreY+1)), dirty(0),
  maxDegX(degreX), maxDegY(degreY), degX(0), degY(0), deg(0)
 {
@@ -506,5 +426,5 @@
 //	de deux polynômes à une variable, p2(x,y)=px(x)py(y)
 //--
-:OVector((polX.Degre()+1)*(polY.Degre()+1)), dirty(0),
+:Vector((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 +441,5 @@
 //	Constructeur par copie.
 //--
-:OVector(a), dirty(a.dirty),
+:Vector(a), dirty(a.dirty),
  maxDegX(a.maxDegX), maxDegY(a.maxDegY),
  degX(a.degX), degY(a.degY), deg(a.deg)
@@ -561,6 +481,6 @@
   UpdateDegIfDirty();
   Poly2 tmp(*this);
-  OVector::Realloc((degreX+1)*(degreY+1));
-  Zero();
+  Vector::Realloc((degreX+1)*(degreY+1));
+  Reset();
   maxDegX = degreX;
   maxDegY = degreY;
@@ -631,5 +551,5 @@
 
 //++
-double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
+double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
                   int degreX, int degreY)
 //
@@ -643,5 +563,5 @@
   Realloc(degreX, degreY);
 
-  OMatrix a((degreX+1)*(degreY+1), n);
+  Matrix a((degreX+1)*(degreY+1), n);
 
   for (int c=0; c<n; c++) {
@@ -657,5 +577,5 @@
   }
 
-  double rc = LinFit(a,z,(OVector&)*this);
+  double rc = LinFit(a,z,(Vector&)*this);
   UpdateDeg();
   return rc;
@@ -664,7 +584,7 @@
 
 //++
-double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
-                  OVector const& errz2, int degreX, int degreY,
-                  OVector& errCoef)
+double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
+                  Vector const& errz2, int degreX, int degreY,
+                  Vector& errCoef)
 //
 //	Ajustement par moindre carrés z = P(x,y), degrés partiels imposés,
@@ -680,5 +600,5 @@
   errCoef.Realloc((degreX+1)*(degreY+1));
 
-  OMatrix a((degreX+1)*(degreY+1), n);
+  Matrix a((degreX+1)*(degreY+1), n);
 
   for (int c=0; c<n; c++) {
@@ -694,5 +614,5 @@
   }
 
-  double rc = LinFit(a,z,errz2,(OVector&)*this,errCoef);
+  double rc = LinFit(a,z,errz2,(Vector&)*this,errCoef);
   UpdateDeg();
   return rc;
@@ -700,5 +620,5 @@
 
 //++
-double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
+double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
                   int degre)
 //
@@ -712,6 +632,6 @@
   Realloc(degre, degre);   // certains vaudront 0, impose.
 
-  OMatrix a((degre+1)*(degre+2)/2, n);
-  OVector cf((degre+1)*(degre+2)/2);
+  Matrix a((degre+1)*(degre+2)/2, n);
+  Vector cf((degre+1)*(degre+2)/2);
 #define C_INDEX(i,j) ((i) + (j)*(2*degre+3-(j))/2)
 
@@ -744,7 +664,7 @@
 
 //++
-double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
-                  OVector const& errz2, int degre,
-                  OVector& errCoef)
+double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
+                  Vector const& errz2, int degre,
+                  Vector& errCoef)
 //
 //	Ajustement par moindre carrés z = P(x,y), degré total imposé,
@@ -761,7 +681,7 @@
 #define C_INDEX(i,j) ((i) + (j)*(2*degre+3-(j))/2)
 
-  OMatrix a((degre+1)*(degre+2)/2, n);
-  OVector cf((degre+1)*(degre+2)/2);
-  OVector ecf((degre+1)*(degre+2)/2);
+  Matrix a((degre+1)*(degre+2)/2, n);
+  Vector cf((degre+1)*(degre+2)/2);
+  Vector ecf((degre+1)*(degre+2)/2);
 
   for (int c=0; c<n; c++) {
@@ -792,30 +712,4 @@
   UpdateDeg();
   return rc;
-}
-
-
-void Poly2::ReadSelf(PInPersist& s)
-{
-  int_4 dgx, dgy;
-  s >> dgx >> dgy;
-
-  Realloc(dgx, dgy);
-
-#ifdef DEBUG
-  int r = nr; int c = nc;
-#endif
-
-  OVector::ReadSelf(s);
-
-#ifdef DEBUG
-  DBASSERT(r == nr && c == nc);
-#endif
-  UpdateDeg();
-}
-
-void Poly2::WriteSelf(POutPersist& s) const
-{
-  s << maxDegX << maxDegY;
-  OVector::WriteSelf(s);
 }
 
@@ -850,15 +744,4 @@
 
 //++
-ostream& operator << (ostream& s, const Poly2& a)
-//
-//	Impression sur stream s.
-//--
-{
-  a.Print(s);
-  return s;
-}
-
-
-//++
 // Titre	Opérations
 //--
@@ -905,38 +788,4 @@
 
 //++
-Poly2 operator+ (Poly2 const& a, Poly2 const& b)
-//
-//--
-#if HAS_NAMED_RETURN
-     return c(a)
-#endif
-{
-#if !HAS_NAMED_RETURN
-Poly2 c(a);
-#endif
-  c += b;
-#if !HAS_NAMED_RETURN
-return c;
-#endif
-}
-
-//++
-Poly2 operator- (Poly2 const& a, Poly2 const& b)
-//
-//--
-#if HAS_NAMED_RETURN
-     return c(a)
-#endif
-{
-#if !HAS_NAMED_RETURN
-Poly2 c(a);
-#endif
-  c -= b;
-#if !HAS_NAMED_RETURN
-return c;
-#endif
-}
-
-//++
 Poly2& Poly2::operator *= (double a)
 //
@@ -944,5 +793,5 @@
 {
   for (int i=0; i<NElts(); i++)
-    data[i] *= a;
+    Element(i) *= a;
 
   return *this;
@@ -950,34 +799,17 @@
 
 //++
-Poly2 operator * (double a, Poly2 const& b)
-//
-//--
-#if HAS_NAMED_RETURN
-     return c(b)
-#endif
-{
-#if !HAS_NAMED_RETURN
-Poly2 c(b);
-#endif
-  c *= a;
-#if !HAS_NAMED_RETURN
-return c;
-#endif
-}
-
-//++
-Poly2 operator* (Poly2 const& a, Poly2 const& b)
-//
-//--
-{
-  Poly2 c(a.DegX() + b.DegX(), a.DegY() + b.DegY());
-  a.UpdateDegIfDirty();
+Poly2 Poly2::Mult(Poly2 const& b) const
+//
+//--
+{
+  Poly2 c(DegX() + b.DegX(), DegY() + b.DegY());
+  UpdateDegIfDirty();
   b.UpdateDegIfDirty();
 
-  for (int i=0; i<=a.DegX(); i++)
-    for (int j=0; j<=a.DegY(); j++)
+  for (int i=0; i<=DegX(); i++)
+    for (int j=0; j<=DegY(); j++)
       for (int k=0; k<=b.DegX(); k++)
         for (int l=0; l<=b.DegY(); l++)
-          c.Coef(i+k,j+l) += a.Coef(i,j)*b.Coef(k,l);
+          c.Coef(i+k,j+l) += Coef(i,j)*b.Coef(k,l);
   return c;
 }
@@ -1029,3 +861,31 @@
 }
 
-
+//////////////////////////////////////////////////////////////////////////
+void ObjFileIO<Poly2>::ReadSelf(PInPersist& is)
+{
+if(dobj==NULL) dobj=new Poly2;
+int_4 dgx, dgy;
+is >> dgx >> dgy;
+dobj->Realloc(dgx,dgy);
+is >> *((Vector *) dobj);
+dobj->UpdateDeg();
+}
+
+void ObjFileIO<Poly2>::WriteSelf(POutPersist& os) const
+{
+if(dobj == NULL) return;
+os << dobj->maxDegX << dobj->maxDegY;
+os << *((Vector *) dobj);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+#ifdef __CXX_PRAGMA_TEMPLATES__
+#pragma define_template ObjFileIO<Poly>
+#pragma define_template ObjFileIO<Poly2>
+#endif
+
+#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
+template class ObjFileIO<Poly>;
+template class ObjFileIO<Poly2>;
+#endif
Index: trunk/SophyaLib/NTools/poly.h
===================================================================
--- trunk/SophyaLib/NTools/poly.h	(revision 513)
+++ trunk/SophyaLib/NTools/poly.h	(revision 514)
@@ -1,7 +1,6 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: poly.h,v 1.2 1999-10-25 10:36:11 ansari Exp $
+// $Id: poly.h,v 1.3 1999-10-25 16:40:01 ansari Exp $
 //
-
 
 // Des polynomes avec des operations de bases et surtout des fits.
@@ -10,24 +9,31 @@
 #define POLY_SEEN
 
+#include "objfio.h"
 #include <stdio.h>
 #include "peida.h"
-#include "cvector.h"
+#include "tvector.h"
+#include "ppersist.h"
+#include "anydataobj.h"
+
+namespace PlanckDPC {
 
 class Poly2;
 
-class Poly : public OVector {
+//////////////////////////////////////////////////////////////////////////
+class Poly : public Vector {
+  friend class ObjFileIO<Poly>;
 public:
   Poly(int degre = 0);
+  Poly(Poly const& a);
 
   enum {classId = ClassId_Poly1};
-  int_4                 ClassId() const         { return classId; }
-  static PPersist*      Create() {return new Poly;}
+  int_4  ClassId() const         { return classId; }
 
   inline int Degre() const {UpdateDegIfDirty(); return deg;}
 
-  inline void Realloc(int n, bool force=false) {OVector::Realloc(n+1,force);}
-
-  inline double operator[](int i) const {return data[i];}
-  inline double& operator[](int i) {dirty = 1; return data[i];}
+  inline void Realloc(int n, bool force=false) {Vector::Realloc(n+1,force);}
+
+  inline double operator[](int i) const {return Element(i);}
+  inline double& operator[](int i) {dirty = 1; return Element(i);}
   // Retourne le coefficient de degre i
 
@@ -41,5 +47,5 @@
   // Derive le polynome dans un autre
 
-  int    Roots(OVector& roots) const;
+  int    Roots(Vector& roots) const;
   // retourne les racines si on peut les calculer...
 
@@ -49,8 +55,4 @@
   int    Root2(double& r1, double& r2) const;
   // special degre 2
-
-  friend Poly operator* (Poly const& a, Poly const& b);
-  friend Poly operator+ (Poly const& a, Poly const& b);
-  friend Poly operator- (Poly const& a, Poly const& b);
 
   Poly& operator = (Poly const& b);
@@ -58,7 +60,7 @@
   Poly& operator -= (Poly const& b);
 
-  friend Poly operator* (double a, Poly const& b);
-
   Poly& operator *= (double a);
+
+  Poly Mult(Poly const& b) const;
 
   Poly power(int n) const;
@@ -66,15 +68,11 @@
   Poly2 operator() (Poly2 const& b) const;
 
-  void ReadSelf(PInPersist&);
-  void WriteSelf(POutPersist&) const;
-
   void Print(ostream& s) const;
-  friend ostream& operator << (ostream& s, const Poly& a);
-
-  double Fit(OVector const& x, OVector const& y, int degre);
+
+  double Fit(Vector const& x, Vector const& y, int degre);
   // Fit d'un polynome de degre donne sur les x et y.
 
-  double Fit(OVector const& x, OVector const& y, OVector const& erry2, int degre,
-            OVector& errCoef);
+  double Fit(Vector const& x, Vector const& y, Vector const& erry2, int degre,
+            Vector& errCoef);
   // En plus, on fournit les carres des erreurs sur y et on a les erreurs
   // sur les coefficients dans un vecteur.
@@ -87,11 +85,35 @@
 };
 
+inline Poly operator* (Poly const& a, Poly const& b)
+  { return a.Mult(b); }
+
+inline Poly operator+ (Poly const& a, Poly const& b)
+ { Poly c((a.Degre() > b.Degre())?(a.Degre()+1):(b.Degre()+1));
+   c = a; c += b; return c; }
+
+inline Poly operator- (Poly const& a, Poly const& b)
+  { Poly c((a.Degre() > b.Degre())?(a.Degre()+1):(b.Degre()+1));
+    c = a; c -= b; return c; }
+
+inline Poly operator* (double a, Poly const& b)
+  { Poly c(b); c *= a; return c; }
+
+inline ostream& operator << (ostream& s, const Poly& a)
+  { a.Print(s); return s; }
+
+//////////////////////////////////////////////////////////////////////////
+inline POutPersist& operator << (POutPersist& os, Poly & obj)
+  { ObjFileIO<Poly> fio(&obj);  fio.Write(os);  return(os); }
+inline PInPersist& operator >> (PInPersist& is, Poly & obj)
+  { ObjFileIO<Poly> fio(&obj);  fio.Read(is);  return(is); }
+// Classe pour la gestion de persistance
+// ObjFileIO<Poly>
+
+//////////////////////////////////////////////////////////////////////////
 int binomial(int n, int p);
 
-
-class Poly2 : public OVector {  // Ca pourrait etre une matrice mais
-                                  // la encore, un vecteur est utile pour les
-                                  // fits.
-
+//////////////////////////////////////////////////////////////////////////
+class Poly2 : public Vector {
+  friend class ObjFileIO<Poly2>;
 public:
   Poly2(int degreX=0, int degreY=0);
@@ -101,6 +123,5 @@
 
   enum {classId = ClassId_Poly2};
-  int_4                 ClassId() const         { return classId; }
-  static PPersist*      Create() {return new Poly2;}
+  int_4 ClassId() const         { return classId; }
 
   inline int DegX() const {UpdateDegIfDirty(); return degX;}
@@ -123,25 +144,25 @@
 
   inline double Coef(int dx, int dy) const {
-    return (dx>maxDegX || dy>maxDegY) ? 0 : data[IndCoef(dx,dy)];
+    return (dx>maxDegX || dy>maxDegY) ? 0 : Element(IndCoef(dx,dy));
   }
   inline double& Coef(int dx, int dy) {
     if (dx>maxDegX || dy>maxDegY) THROW(rangeCheckErr);
-    dirty = 1; return data[IndCoef(dx,dy)];
+    dirty = 1; return Element(IndCoef(dx,dy));
   }
   // retourne le coefficient de degre (dx,dy)
 
-  double Fit(OVector const& x, OVector const& y, OVector const& z,
+  double Fit(Vector const& x, Vector const& y, Vector const& z,
              int degreX, int degreY);
-  double Fit(OVector const& x, OVector const& y, OVector const& z,
-             OVector const& errz2, int degreX, int degreY,
-             OVector& errCoef);
+  double Fit(Vector const& x, Vector const& y, Vector const& z,
+             Vector const& errz2, int degreX, int degreY,
+             Vector& errCoef);
   // degres partiels imposes. cf Poly::Fit sinon
 
 
-  double Fit(OVector const& x, OVector const& y, OVector const& z,
+  double Fit(Vector const& x, Vector const& y, Vector const& z,
              int degre);
-  double Fit(OVector const& x, OVector const& y, OVector const& z,
-             OVector const& errz2, int degre,
-             OVector& errCoef);
+  double Fit(Vector const& x, Vector const& y, Vector const& z,
+             Vector const& errz2, int degre,
+             Vector& errCoef);
   // degre total impose. cf Poly::Fit sinon
 
@@ -151,12 +172,9 @@
   Poly2& operator -= (Poly2 const& b);
 
-  friend Poly2 operator + (Poly2 const& a, Poly2 const& b);
-  friend Poly2 operator - (Poly2 const& a, Poly2 const& b);
-  friend Poly2 operator * (Poly2 const& a, Poly2 const& b);
+  Poly2& operator *= (double a);
+
+  Poly2 Mult(Poly2 const& b) const;
 
   Poly2 power(int n) const;
-
-  Poly2& operator *= (double a);
-  friend Poly2 operator * (double a, Poly2 const& b);
 
   Poly2 operator() (Poly const& px, Poly const& py) const;
@@ -165,9 +183,5 @@
   void Realloc(int degreX, int degreY);
 
-  void ReadSelf(PInPersist&);
-  void WriteSelf(POutPersist&) const;
-
   void Print(ostream& s) const;
-  friend ostream& operator << (ostream& s, const Poly2& a);
 
 private:
@@ -182,3 +196,29 @@
 };
 
+inline Poly2 operator* (Poly2 const& a, Poly2 const& b)
+  { return a.Mult(b); }
+
+inline Poly2 operator+ (Poly2 const& a, Poly2 const& b)
+  { Poly2 c(a); c += b; return c; }
+
+inline Poly2 operator- (Poly2 const& a, Poly2 const& b)
+  { Poly2 c(a); c -= b; return c; }
+
+inline Poly2 operator * (double a, Poly2 const& b)
+  { Poly2 c(b); c *= a; return c; }
+
+inline ostream& operator << (ostream& s, const Poly2& a)
+  { a.Print(s); return s; }
+
+//////////////////////////////////////////////////////////////////////////
+inline POutPersist& operator << (POutPersist& os, Poly2 & obj)
+  { ObjFileIO<Poly2> fio(&obj);  fio.Write(os);  return(os); }
+inline PInPersist& operator >> (PInPersist& is, Poly2 & obj)
+  { ObjFileIO<Poly2> fio(&obj);  fio.Read(is);  return(is); }
+// Classe pour la gestion de persistance
+// ObjFileIO<Poly2>
+
+
+} // Fin du namespace
+
 #endif // POLY_SEEN
Index: trunk/SophyaLib/NTools/rk4cdifeq.cc
===================================================================
--- trunk/SophyaLib/NTools/rk4cdifeq.cc	(revision 513)
+++ trunk/SophyaLib/NTools/rk4cdifeq.cc	(revision 514)
@@ -74,5 +74,5 @@
 //++
 RK4CDiffEq&  
-RK4CDiffEq::AbsAccuracy(OVector const& vScal)
+RK4CDiffEq::AbsAccuracy(Vector const& vScal)
 //
 //	On souhaite une précision absolue, et le vecteur vScal contient
@@ -118,5 +118,5 @@
 
 void
-RK4CDiffEq::RKCStep(OVector& newY, OVector const& y0, OVector const& yScale, 
+RK4CDiffEq::RKCStep(Vector& newY, Vector const& y0, Vector const& yScale, 
 	       double dttry, double& dtdone, double& dtnext)
 {
@@ -151,9 +151,9 @@
   // Et on corrige a l'ordre 5
 
-  newY += yTemp/15;
+  newY += yTemp/15.;
 }
 
 void
-RK4CDiffEq::SolveArr(OMatrix& y, double* t, double tf, int n)
+RK4CDiffEq::SolveArr(Matrix& y, double* t, double tf, int n)
 {
   //TIMEF;
@@ -162,5 +162,5 @@
   double dxres = (tf - mXStart)/n;
 
-  OVector yt = mYStart;
+  Vector yt = mYStart;
   
   k1.Realloc(mFunc->NFuncReal());
Index: trunk/SophyaLib/NTools/rk4cdifeq.h
===================================================================
--- trunk/SophyaLib/NTools/rk4cdifeq.h	(revision 513)
+++ trunk/SophyaLib/NTools/rk4cdifeq.h	(revision 514)
@@ -4,4 +4,6 @@
 
 #include "difeq.h"
+
+namespace PlanckDPC {
 
 // <summary> Runge-Kutta ordre 4 adaptatif </summary>
@@ -20,5 +22,5 @@
   // <group>
   RK4CDiffEq& Accuracy(double);
-  RK4CDiffEq& AbsAccuracy(OVector const& vScal);
+  RK4CDiffEq& AbsAccuracy(Vector const& vScal);
   RK4CDiffEq& AbsAccuracy(double scal);
   RK4CDiffEq& RelAccuracy();
@@ -26,17 +28,19 @@
   
   // Implementation RK4 adaptatif
-  virtual void SolveArr(OMatrix& y, double* t, double tf, int n);
+  virtual void SolveArr(Matrix& y, double* t, double tf, int n);
 
 protected:
   // Un pas adaptatif
-  void RKCStep(OVector& newY, OVector const& y0, OVector const& yScale, 
+  void RKCStep(Vector& newY, Vector const& y0, Vector const& yScale, 
 	       double dttry, double& dtdone, double& dtnext);
 
   double eps;
   bool   relAccuracy;
-  OVector accScale;
-  OVector yTemp; // Pour ne pas reallouer
-  OVector ySave;
+  Vector accScale;
+  Vector yTemp; // Pour ne pas reallouer
+  Vector ySave;
 };
 
+} // Fin du namespace
+
 #endif
Index: trunk/SophyaLib/NTools/rzimage.cc
===================================================================
--- trunk/SophyaLib/NTools/rzimage.cc	(revision 513)
+++ trunk/SophyaLib/NTools/rzimage.cc	(revision 514)
@@ -5,5 +5,5 @@
 // LAL (Orsay) / IN2P3-CNRS  DAPNIA/SPP (Saclay) / CEA
 
-//  $Id: rzimage.cc,v 1.5 1999-10-25 10:36:12 ansari Exp $
+//  $Id: rzimage.cc,v 1.6 1999-10-25 16:40:03 ansari Exp $
 
 #include "machdefs.h"
@@ -765,5 +765,5 @@
 GeneralFunction* f = gfit.GetFunction();
 if(f==NULL) return NULL;
-OVector par = gfit.GetParm();
+Vector 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;
-OVector par = gfit.GetParm();
+Vector 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 513)
+++ trunk/SophyaLib/NTools/tmatrix.cc	(revision 514)
@@ -1,3 +1,3 @@
-// $Id: tmatrix.cc,v 1.11 1999-10-25 10:36:12 ansari Exp $
+// $Id: tmatrix.cc,v 1.12 1999-10-25 16:40:03 ansari Exp $
 //                         C.Magneville          04/99
 #include "machdefs.h"
@@ -10,6 +10,4 @@
 #include "tmatrix.h"
 #include "objfio.h"
-
-using namespace PlanckDPC;
 
 ////////////////////////////////////////////////////////////////
@@ -184,5 +182,4 @@
 }
 
-#include "matrix.h"
 ////////////////////////////////////////////////////////////////
 //**** Pour inversion
Index: trunk/SophyaLib/NTools/tmatrix.h
===================================================================
--- trunk/SophyaLib/NTools/tmatrix.h	(revision 513)
+++ trunk/SophyaLib/NTools/tmatrix.h	(revision 514)
@@ -50,4 +50,5 @@
   inline uint_4 NRows() const {return mNr;}
   inline uint_4 NCols() const {return mNc;}
+  inline uint_4 NCol() const {return mNc;} // back-compat Peida
   inline T const& operator()(uint_4 r,uint_4 c) const
                             {return *(mNDBlock.Begin()+r*mNc+c);}
@@ -139,5 +140,5 @@
 
 ////////////////////////////////////////////////////////////////
-// Surcharge d'operateurs A (+=,-=,*=,/=) (T) x
+// Surcharge d'operateurs A (+,-,*,/) (T) x
 
 template <class T> inline TMatrix<T> operator + (const TMatrix<T>& a, T b)
Index: trunk/SophyaLib/NTools/tvector.cc
===================================================================
--- trunk/SophyaLib/NTools/tvector.cc	(revision 513)
+++ trunk/SophyaLib/NTools/tvector.cc	(revision 514)
@@ -1,3 +1,3 @@
-// $Id: tvector.cc,v 1.4 1999-05-19 10:17:42 ansari Exp $
+// $Id: tvector.cc,v 1.5 1999-10-25 16:40:04 ansari Exp $
 //                         C.Magneville          04/99
 #include "machdefs.h"
@@ -9,6 +9,4 @@
 #include "tvector.h"
 #include "objfio.h"
-
-using namespace PlanckDPC;
 
 template <class T>
Index: trunk/SophyaLib/NTools/tvector.h
===================================================================
--- trunk/SophyaLib/NTools/tvector.h	(revision 513)
+++ trunk/SophyaLib/NTools/tvector.h	(revision 514)
@@ -47,5 +47,6 @@
 
 // produit scalaire, matrice*vecteur
-template <class T> inline T operator* (const TVector<T>& v1, const TVector<T>& v2)
+template <class T>
+inline T operator* (const TVector<T>& v1, const TVector<T>& v2)
   {if(v1.NRows() != v2.NRows())
      throw(SzMismatchError("TVector::operator*(TVector& v1,TVector v2) size mismatch"));
@@ -55,6 +56,7 @@
    return r;}
 
-template <class T> inline TVector<T> operator* (const TMatrix<T>& a, const TVector<T>& b)
-                   {return TVector<T>(a * ((TMatrix<T> const&)(b)));}
+template <class T>
+inline TVector<T> operator* (const TMatrix<T>& a, const TVector<T>& b)
+   {return TVector<T>(a * ((TMatrix<T> const&)(b)));}
 
 // Resolution du systeme A*C = B
Index: trunk/SophyaLib/Samba/anagen.cc
===================================================================
--- trunk/SophyaLib/Samba/anagen.cc	(revision 513)
+++ trunk/SophyaLib/Samba/anagen.cc	(revision 514)
@@ -37,5 +37,5 @@
     double phi0;
     float theta;
-    OVector phin, datan, phis, datas;
+    Vector 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, OVector datain,
+void comp_phas2gen(int nsmax,int nlmax,int nmmax, Vector datain,
 	       	int nph,vector< complex<double> >& dataout,double phi0){
   /*=======================================================================
@@ -92,5 +92,5 @@
   //FFTVector outf=FFTServer::solve(inf,-1);
   FFTServer fft;
-  OVector outf;
+  Vector outf;
   //cout<<"in :"<<datain<<endl;
   fft.fftb(datain,outf);
Index: trunk/SophyaLib/Samba/anagen.h
===================================================================
--- trunk/SophyaLib/Samba/anagen.h	(revision 513)
+++ trunk/SophyaLib/Samba/anagen.h	(revision 514)
@@ -4,5 +4,5 @@
 #include <complex>
 #include <vector>
-#include "cvector.h"
+#include "tvector.h"
 #include "sphericalmap.h"
 
@@ -10,5 +10,5 @@
 	     vector< vector< complex<double> > >& alm, double cos_theta_cut);
 
-void comp_phas2gen(int nsmax,int nlmax,int nmmax, OVector datain,
+void comp_phas2gen(int nsmax,int nlmax,int nmmax, Vector datain,
 	       	int nph,vector< complex<double> >& dataout,double phi0);
 
Index: trunk/SophyaLib/Samba/syngen.cc
===================================================================
--- trunk/SophyaLib/Samba/syngen.cc	(revision 513)
+++ trunk/SophyaLib/Samba/syngen.cc	(revision 514)
@@ -43,5 +43,5 @@
     double phi0;
     float theta,thetas;
-    OVector phin, datan,phis,datas;
+    Vector 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, OVector& dataout, double phi0,
+	      int nph, Vector& dataout, double phi0,
 	      vector< complex<long double> >& bw){
 
Index: trunk/SophyaLib/Samba/syngen.h
===================================================================
--- trunk/SophyaLib/Samba/syngen.h	(revision 513)
+++ trunk/SophyaLib/Samba/syngen.h	(revision 514)
@@ -4,5 +4,5 @@
 #include <complex>
 #include <vector>
-#include "cvector.h"
+#include "tvector.h"
 #include "sphericalmap.h"
 
@@ -18,5 +18,5 @@
 void syn_phasgen(const int nsmax,const int nlmax,const int nmmax,
 	      const vector< complex<long double> >& datain,
-	      int nph, OVector& dataout, double phi0,
+	      int nph, Vector& dataout, double phi0,
 	      vector< complex<long double> >& bw);
 
