Index: trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- trunk/SophyaLib/NTools/generaldata.cc	(revision 936)
+++ trunk/SophyaLib/NTools/generaldata.cc	(revision 938)
@@ -722,7 +722,7 @@
 if(varx<0 || varx>=mNVar) return -2.;
 if(mNDataGood<=0) return -4.;
-Vector x(mNDataGood);
-Vector y(mNDataGood);
-Vector ey2(1);
+TVector<r_8> x(mNDataGood);
+TVector<r_8> y(mNDataGood);
+TVector<r_8> ey2(1);
 if(ey) ey2.Realloc(mNDataGood,true);
 int ntest = 0;
@@ -737,5 +737,5 @@
 double res = 0.;
 if(ey) {
-  Vector errcoef(1);
+  TVector<r_8> errcoef(1);
   res = pol.Fit(x,y,ey2,degre,errcoef);
 } else {
@@ -771,8 +771,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);
+TVector<r_8> x(mNDataGood);
+TVector<r_8> y(mNDataGood);
+TVector<r_8> z(mNDataGood);
+TVector<r_8> ez2(1);
 if(ez) ez2.Realloc(mNDataGood,true);
 int ntest = 0;
@@ -788,5 +788,5 @@
 double res = 0.;
 if(ez) {
-  Vector errcoef(1);
+  TVector<r_8> 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 936)
+++ trunk/SophyaLib/NTools/generalfit.cc	(revision 938)
@@ -797,5 +797,5 @@
   Retourne les valeurs des parametres dans un vecteur.
 */
-Vector GeneralFit::GetParm()
+TVector<r_8> GeneralFit::GetParm()
 {
 return Param;
@@ -1003,11 +1003,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);
+ TMatrix<r_8> COVAR(mNPar,mNPar);
+ TVector<r_8> DA(mNPar);
+ TVector<r_8> dparam(mNPar);
+ TVector<r_8> paramTry(mNPar);
+ TVector<r_8> param_tr(mNPar);
+ TVector<r_8> paramTry_tr(mNPar);
+ TVector<r_8> step_tr(mNPar);
  nStop = nStopL = nStep = 0;
  Chi2 = oldChi2 = 0.;
@@ -1418,5 +1418,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::write_in_step(double ci2,Vector& par)
+void GeneralFit::write_in_step(double ci2,TVector<r_8>& par)
 {
 if(FileStep==NULL) return;
@@ -1427,11 +1427,11 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::TryFunc(Vector& par,Vector& par_tr)
+void GeneralFit::TryFunc(TVector<r_8>& par,TVector<r_8>& par_tr)
 {
   BETA_Try = 0;
   ATGA_Try = 0;
   Chi2  = 0;
-  Vector deriv(mNPar);
-  Vector derivtr(mNPar);
+  TVector<r_8> deriv(mNPar);
+  TVector<r_8> derivtr(mNPar);
   double result;
 
@@ -1467,5 +1467,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::TryXi2(Vector& par,Vector& par_tr)
+void GeneralFit::TryXi2(TVector<r_8>& par,TVector<r_8>& par_tr)
 {
   double c, *parloc;
@@ -1575,7 +1575,7 @@
 
 //////////////////////////////////////////////////////////////////////
-Vector GeneralFit::p_vers_tr(Vector const& p)
-{
- Vector tr(p);
+TVector<r_8> GeneralFit::p_vers_tr(TVector<r_8> const& p)
+{
+ TVector<r_8> tr(p);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1586,5 +1586,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::p_vers_tr(Vector const& p,Vector& tr)
+void GeneralFit::p_vers_tr(TVector<r_8> const& p,TVector<r_8>& tr)
 {
  for(int i=0;i<mNPar;i++) {
@@ -1610,7 +1610,7 @@
 
 //////////////////////////////////////////////////////////////////////
-Vector GeneralFit::tr_vers_p(Vector const& tr)
-{
- Vector p(tr);
+TVector<r_8> GeneralFit::tr_vers_p(TVector<r_8> const& tr)
+{
+ TVector<r_8> p(tr);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1621,5 +1621,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::tr_vers_p(Vector const& tr,Vector& p)
+void GeneralFit::tr_vers_p(TVector<r_8> const& tr,TVector<r_8>& p)
 {
  for(int i=0;i<mNPar;i++) {
@@ -1646,7 +1646,7 @@
 
 //////////////////////////////////////////////////////////////////////
-Vector GeneralFit::dp_vers_dtr(Vector const& dp,Vector const& tr)
-{
- Vector dtr(dp);
+TVector<r_8> GeneralFit::dp_vers_dtr(TVector<r_8> const& dp,TVector<r_8> const& tr)
+{
+ TVector<r_8> dtr(dp);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1657,5 +1657,5 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::dp_vers_dtr(Vector const& dp,Vector const& tr,Vector& dtr)
+void GeneralFit::dp_vers_dtr(TVector<r_8> const& dp,TVector<r_8> const& tr,TVector<r_8>& dtr)
 {
  for(int i=0;i<mNPar;i++) {
@@ -1682,7 +1682,7 @@
 
 //////////////////////////////////////////////////////////////////////
-Vector GeneralFit::dtr_vers_dp(Vector const& dtr,Vector const& tr)
-{
- Vector dp(dtr);
+TVector<r_8> GeneralFit::dtr_vers_dp(TVector<r_8> const& dtr,TVector<r_8> const& tr)
+{
+ TVector<r_8> dp(dtr);
  for(int i=0;i<mNPar;i++) {
    if( fixParam[i] || ! boundParam[i] ) continue;
@@ -1694,5 +1694,5 @@
 //////////////////////////////////////////////////////////////////////
 // inline fonction pour aller + vite dans le try()
-//void GeneralFit::dtr_vers_dp(Vector const& dtr,Vector const& tr,Vector& dp)
+//void GeneralFit::dtr_vers_dp(TVector<r_8> const& dtr,TVector<r_8> const& tr,TVector<r_8>& dp)
 
 //////////////////////////////////////////////////////////////////////
@@ -1706,5 +1706,5 @@
   \endverbatim
 */
-int GeneralFit::put_in_limits_for_deriv(Vector const& p,Vector& dp,double dist)
+int GeneralFit::put_in_limits_for_deriv(TVector<r_8> const& p,TVector<r_8>& dp,double dist)
 {
  int nchanged = 0;
Index: trunk/SophyaLib/NTools/generalfit.h
===================================================================
--- trunk/SophyaLib/NTools/generalfit.h	(revision 936)
+++ trunk/SophyaLib/NTools/generalfit.h	(revision 938)
@@ -138,5 +138,5 @@
 
   double          GetParm(int);
-  Vector          GetParm();
+  TVector<r_8>    GetParm();
   double          GetParmErr(int);
   double          GetCoVar(int,int);
@@ -195,11 +195,11 @@
   GeneralFitData*   mData;
 
-  Vector          Param;
-  Vector          errParam;
-  Vector          stepParam;
-  Vector          minParam;
-  Vector          maxParam;
-  Vector          minStepDeriv;
-  Vector          Eps;
+  TVector<r_8>    Param;
+  TVector<r_8>    errParam;
+  TVector<r_8>    stepParam;
+  TVector<r_8>    minParam;
+  TVector<r_8>    maxParam;
+  TVector<r_8>    minStepDeriv;
+  TVector<r_8>    Eps;
   unsigned short int* fixParam;
   unsigned short int* boundParam;
@@ -215,10 +215,10 @@
   FILE            *FileStep;
   
-  Matrix          ATGA;
-  Vector          BETA;
-  Matrix          ATGA_Try;
-  Vector          BETA_Try;
-  Vector          C;
-  Vector          D;
+  TMatrix<r_8>    ATGA;
+  TVector<r_8>    BETA;
+  TMatrix<r_8>    ATGA_Try;
+  TVector<r_8>    BETA_Try;
+  TVector<r_8>    C;
+  TVector<r_8>    D;
   
   double          Chi2;
@@ -229,24 +229,24 @@
   
   // Fonctions privees
-  void       write_in_step(double ci2,Vector& par);
-  void       General_Init(void);
-  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);
-  Vector     p_vers_tr(Vector const& p);
-  void       p_vers_tr(Vector const& p,Vector& 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);
-  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);
-  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)
+  void         write_in_step(double ci2,TVector<r_8>& par);
+  void         General_Init(void);
+  void         TryFunc(TVector<r_8>& par,TVector<r_8>& par_tr);
+  void         TryXi2(TVector<r_8>& par,TVector<r_8>& par_tr);
+  void         CheckSanity();
+  void         Set_Bound_C_D(int i);
+  void         Set_Bound_C_D();
+  double       p_vers_tr(int i,double p);
+  TVector<r_8> p_vers_tr(TVector<r_8> const& p);
+  void         p_vers_tr(TVector<r_8> const& p,TVector<r_8>& tr);
+  double       tr_vers_p(int i,double tr);
+  TVector<r_8> tr_vers_p(TVector<r_8> const& tr);
+  void         tr_vers_p(TVector<r_8> const& tr,TVector<r_8>& p);
+  double       c_dp_vers_dtr(int i,double tr);
+  TVector<r_8> dp_vers_dtr(TVector<r_8> const& dp,TVector<r_8> const& tr);
+  void         dp_vers_dtr(TVector<r_8> const& dp,TVector<r_8> const& tr,TVector<r_8>& dtr);
+  double       c_dtr_vers_dp(int i,double tr);
+  TVector<r_8> dtr_vers_dp(TVector<r_8> const& dtr,TVector<r_8> const& tr);
+  int          put_in_limits_for_deriv(TVector<r_8> const& p,TVector<r_8>& dp,double dist=0.66);
+  inline void dtr_vers_dp(TVector<r_8> const& dtr,TVector<r_8> const& tr,TVector<r_8>& dp)
               {  for(int i=0;i<mNPar;i++)
                    { if( fixParam[i] ) continue;
Index: trunk/SophyaLib/NTools/poly.cc
===================================================================
--- trunk/SophyaLib/NTools/poly.cc	(revision 936)
+++ trunk/SophyaLib/NTools/poly.cc	(revision 938)
@@ -31,5 +31,5 @@
 
 Poly::Poly(int degre)
-: Vector(degre+1), dirty(0), deg(0)
+: TVector<r_8>(degre+1), dirty(0), deg(0)
 {
   END_CONSTRUCTOR
@@ -41,5 +41,5 @@
 //	Constructeur par copie.
 //--
-:Vector(a), dirty(a.dirty), deg(a.deg)
+:TVector<r_8>(a), dirty(a.dirty), deg(a.deg)
 {
   END_CONSTRUCTOR
@@ -111,5 +111,5 @@
 
 //++
-int Poly::Roots(Vector& roots) const
+int Poly::Roots(TVector<r_8>& roots) const
 //
 //	Retourne dans roots les racines réelles, si on sait
@@ -179,5 +179,5 @@
 {
   if (this == &a) return *this;
-  Vector::operator=(a);
+  TVector<r_8>::operator=(a);
 
   UpdateDeg();
@@ -275,5 +275,5 @@
 
 //++
-double Poly::Fit(Vector const& x, Vector const& y, int degre)
+double Poly::Fit(TVector<r_8> const& x, TVector<r_8> const& y, int degre)
 //
 //	Ajustement polynomial par moindre carrés. Un polynôme de
@@ -287,5 +287,5 @@
   Realloc(degre);
 
-  Matrix a(degre+1, n);
+  TMatrix<r_8> a(degre+1, n);
 
   for (int c=0; c<n; c++) {
@@ -297,6 +297,6 @@
   }
 
-  LinFitter lf;
-  double rc = lf.LinFit(a,y,(Vector&)*this);
+  LinFitter<r_8> lf;
+  double rc = lf.LinFit(a,y,(TVector<r_8>&)*this);
   UpdateDeg();
   return rc;
@@ -304,6 +304,6 @@
 
 //++
-double Poly::Fit(Vector const& x, Vector const& y, Vector const& erry2, int degre,
-                 Vector& errCoef)
+double Poly::Fit(TVector<r_8> const& x, TVector<r_8> const& y,
+       TVector<r_8> const& erry2, int degre,TVector<r_8>& errCoef)
 //
 //	Ajustement polynomial par moindre carrés. Un polynôme de
@@ -320,5 +320,5 @@
   errCoef.Realloc(degre+1);
 
-  Matrix a(degre+1, n);
+  TMatrix<r_8> a(degre+1, n);
 
   for (int c=0; c<n; c++) {
@@ -330,6 +330,6 @@
   }
 
-  LinFitter lf;
-  double rc = lf.LinFit(a,y,erry2,(Vector&)*this,errCoef);
+  LinFitter<r_8> lf;
+  double rc = lf.LinFit(a,y,erry2,(TVector<r_8>&)*this,errCoef);
   UpdateDeg();
   return rc;
@@ -371,5 +371,5 @@
 is >> dg;
 dobj->Realloc(dg,true);
-is >> *((Vector *) dobj);
+is >> *((TVector<r_8> *) dobj);
 dobj->UpdateDeg();
 }
@@ -381,5 +381,5 @@
 dobj->Realloc(dobj->deg,true);
 os << dobj->deg;
-os << *((Vector *) dobj);
+os << *((TVector<r_8> *) dobj);
 }
 
@@ -417,5 +417,5 @@
 //	Crée un polynôme de degrés partiels degreX et degreY.
 //--
-:Vector((degreX+1)*(degreY+1)), dirty(0),
+:TVector<r_8>((degreX+1)*(degreY+1)), dirty(0),
  maxDegX(degreX), maxDegY(degreY), degX(0), degY(0), deg(0)
 {
@@ -429,5 +429,5 @@
 //	de deux polynômes à une variable, p2(x,y)=px(x)py(y)
 //--
-:Vector((polX.Degre()+1)*(polY.Degre()+1)), dirty(0),
+:TVector<r_8>((polX.Degre()+1)*(polY.Degre()+1)), dirty(0),
  maxDegX(polX.Degre()), maxDegY(polY.Degre()),
  degX(polX.Degre()), degY(polY.Degre()), deg(degX+degY)
@@ -444,5 +444,5 @@
 //	Constructeur par copie.
 //--
-:Vector(a), dirty(a.dirty),
+:TVector<r_8>(a), dirty(a.dirty),
  maxDegX(a.maxDegX), maxDegY(a.maxDegY),
  degX(a.degX), degY(a.degY), deg(a.deg)
@@ -484,5 +484,5 @@
   UpdateDegIfDirty();
   Poly2 tmp(*this);
-  Vector::Realloc((degreX+1)*(degreY+1));
+  TVector<r_8>::Realloc((degreX+1)*(degreY+1));
   DataBlock().Reset();
   maxDegX = degreX;
@@ -554,6 +554,6 @@
 
 //++
-double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
-                  int degreX, int degreY)
+double Poly2::Fit(TVector<r_8> const& x, TVector<r_8> const& y,
+                 TVector<r_8> const& z, int degreX, int degreY)
 //
 //	Ajustement par moindre carrés z = P(x,y), degrés partiels imposés.
@@ -566,5 +566,5 @@
   Realloc(degreX, degreY);
 
-  Matrix a((degreX+1)*(degreY+1), n);
+  TMatrix<r_8> a((degreX+1)*(degreY+1), n);
 
   for (int c=0; c<n; c++) {
@@ -580,6 +580,6 @@
   }
 
-  LinFitter lf;
-  double rc = lf.LinFit(a,z,(Vector&)*this);
+  LinFitter<r_8> lf;
+  double rc = lf.LinFit(a,z,(TVector<r_8>&)*this);
   UpdateDeg();
   return rc;
@@ -588,7 +588,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(TVector<r_8> const& x, TVector<r_8> const& y, TVector<r_8> const& z,
+                  TVector<r_8> const& errz2, int degreX, int degreY,
+                  TVector<r_8>& errCoef)
 //
 //	Ajustement par moindre carrés z = P(x,y), degrés partiels imposés,
@@ -604,5 +604,5 @@
   errCoef.Realloc((degreX+1)*(degreY+1));
 
-  Matrix a((degreX+1)*(degreY+1), n);
+  TMatrix<r_8> a((degreX+1)*(degreY+1), n);
 
   for (int c=0; c<n; c++) {
@@ -618,6 +618,6 @@
   }
 
-  LinFitter lf;
-  double rc = lf.LinFit(a,z,errz2,(Vector&)*this,errCoef);
+  LinFitter<r_8> lf;
+  double rc = lf.LinFit(a,z,errz2,(TVector<r_8>&)*this,errCoef);
   UpdateDeg();
   return rc;
@@ -625,6 +625,6 @@
 
 //++
-double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
-                  int degre)
+double Poly2::Fit(TVector<r_8> const& x, TVector<r_8> const& y,
+                              TVector<r_8> const& z, int degre)
 //
 //	Ajustement par moindre carrés z = P(x,y), degré total imposé.
@@ -637,6 +637,6 @@
   Realloc(degre, degre);   // certains vaudront 0, impose.
 
-  Matrix a((degre+1)*(degre+2)/2, n);
-  Vector cf((degre+1)*(degre+2)/2);
+  TMatrix<r_8> a((degre+1)*(degre+2)/2, n);
+  TVector<r_8> cf((degre+1)*(degre+2)/2);
 #define C_INDEX(i,j) ((i) + (j)*(2*degre+3-(j))/2)
 
@@ -654,5 +654,5 @@
   }
 
-  LinFitter lf;
+  LinFitter<r_8> lf;
   double rc = lf.LinFit(a,z,cf);
 
@@ -670,7 +670,7 @@
 
 //++
-double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
-                  Vector const& errz2, int degre,
-                  Vector& errCoef)
+double Poly2::Fit(TVector<r_8> const& x, TVector<r_8> const& y,
+               TVector<r_8> const& z,TVector<r_8> const& errz2,
+                              int degre, TVector<r_8>& errCoef)
 //
 //	Ajustement par moindre carrés z = P(x,y), degré total imposé,
@@ -687,7 +687,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);
+  TMatrix<r_8> a((degre+1)*(degre+2)/2, n);
+  TVector<r_8> cf((degre+1)*(degre+2)/2);
+  TVector<r_8> ecf((degre+1)*(degre+2)/2);
 
   for (int c=0; c<n; c++) {
@@ -704,5 +704,5 @@
   }
 
-  LinFitter lf;
+  LinFitter<r_8> lf;
   double rc = lf.LinFit(a,z,errz2,cf,ecf);
 
@@ -875,5 +875,5 @@
 is >> dgx >> dgy;
 dobj->Realloc(dgx,dgy);
-is >> *((Vector *) dobj);
+is >> *((TVector<r_8> *) dobj);
 dobj->UpdateDeg();
 }
@@ -883,5 +883,5 @@
 if(dobj == NULL) return;
 os << dobj->maxDegX << dobj->maxDegY;
-os << *((Vector *) dobj);
+os << *((TVector<r_8> *) dobj);
 }
 
Index: trunk/SophyaLib/NTools/poly.h
===================================================================
--- trunk/SophyaLib/NTools/poly.h	(revision 936)
+++ trunk/SophyaLib/NTools/poly.h	(revision 938)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: poly.h,v 1.6 2000-04-10 12:59:45 ansari Exp $
+// $Id: poly.h,v 1.7 2000-04-14 16:14:31 ansari Exp $
 //
 
@@ -21,5 +21,5 @@
 
 //////////////////////////////////////////////////////////////////////////
-class Poly : public Vector {
+class Poly : public TVector<r_8> {
   friend class ObjFileIO<Poly>;
 public:
@@ -29,5 +29,6 @@
   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)
+                     {TVector<r_8>::Realloc(n+1,force);}
 
   //  Pour compatibilite PEIDA  - Reza 03/2000
@@ -48,5 +49,5 @@
   // Derive le polynome dans un autre
 
-  int    Roots(Vector& roots) const;
+  int    Roots(TVector<r_8>& roots) const;
   // retourne les racines si on peut les calculer...
 
@@ -71,9 +72,9 @@
   void Print(ostream& s, int_4 maxprt=-1, bool si=false) const;
 
-  double Fit(Vector const& x, Vector const& y, int degre);
+  double Fit(TVector<r_8> const& x, TVector<r_8> 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(TVector<r_8> const& x, TVector<r_8> const& y,
+         TVector<r_8> const& erry2, int degre, TVector<r_8>& errCoef);
   // En plus, on fournit les carres des erreurs sur y et on a les erreurs
   // sur les coefficients dans un vecteur.
@@ -115,5 +116,5 @@
 
 //////////////////////////////////////////////////////////////////////////
-class Poly2 : public Vector {
+class Poly2 : public TVector<r_8> {
   friend class ObjFileIO<Poly2>;
 public:
@@ -154,17 +155,17 @@
   // retourne le coefficient de degre (dx,dy)
 
-  double Fit(Vector const& x, Vector const& y, Vector const& z,
+  double Fit(TVector<r_8> const& x, TVector<r_8> const& y, TVector<r_8> 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(TVector<r_8> const& x, TVector<r_8> const& y, TVector<r_8> const& z,
+             TVector<r_8> const& errz2, int degreX, int degreY,
+             TVector<r_8>& errCoef);
   // degres partiels imposes. cf Poly::Fit sinon
 
 
-  double Fit(Vector const& x, Vector const& y, Vector const& z,
+  double Fit(TVector<r_8> const& x, TVector<r_8> const& y, TVector<r_8> const& z,
              int degre);
-  double Fit(Vector const& x, Vector const& y, Vector const& z,
-             Vector const& errz2, int degre,
-             Vector& errCoef);
+  double Fit(TVector<r_8> const& x, TVector<r_8> const& y, TVector<r_8> const& z,
+             TVector<r_8> const& errz2, int degre,
+             TVector<r_8>& errCoef);
   // degre total impose. cf Poly::Fit sinon
 
