Changeset 938 in Sophya for trunk/SophyaLib/NTools

Timestamp:

Apr 14, 2000, 6:14:31 PM (25 years ago)

Author:

ansari

Message:

Vector,Matrix -> TVector,TMatrix<r_8> cmv 14/4/00

Location:

trunk/SophyaLib/NTools

Files:

• generaldata.cc (modified) (4 diffs)
• generalfit.cc (modified) (14 diffs)
• generalfit.h (modified) (4 diffs)
• poly.cc (modified) (30 diffs)
• poly.h (modified) (7 diffs)

trunk/SophyaLib/NTools/generaldata.cc

@@ -722 +722 @@
 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 +737 @@
 double res = 0.;
 if(ey) {
-  Vector errcoef(1);
+  TVector<r_8> errcoef(1);
   res = pol.Fit(x,y,ey2,degre,errcoef);
 } else {
@@ -771 +771 @@
 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 +788 @@
 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);

trunk/SophyaLib/NTools/generalfit.cc

@@ -797 +797 @@
   Retourne les valeurs des parametres dans un vecteur.
 */
-Vector GeneralFit::GetParm()
+TVector<r_8> GeneralFit::GetParm()
 {
 return Param;
@@ -1003 +1003 @@
 {
  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 +1418 @@
 
 //////////////////////////////////////////////////////////////////////
-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 +1427 @@
 
 //////////////////////////////////////////////////////////////////////
-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 +1467 @@
 
 //////////////////////////////////////////////////////////////////////
-void GeneralFit::TryXi2(Vector& par,Vector& par_tr)
+void GeneralFit::TryXi2(TVector<r_8>& par,TVector<r_8>& par_tr)
 {
   double c, *parloc;
@@ -1575 +1575 @@
 
 //////////////////////////////////////////////////////////////////////
-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 +1586 @@
 
 //////////////////////////////////////////////////////////////////////
-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 +1610 @@
 
 //////////////////////////////////////////////////////////////////////
-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 +1621 @@
 
 //////////////////////////////////////////////////////////////////////
-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 +1646 @@
 
 //////////////////////////////////////////////////////////////////////
-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 +1657 @@
 
 //////////////////////////////////////////////////////////////////////
-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 +1682 @@
 
 //////////////////////////////////////////////////////////////////////
-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 +1694 @@
 //////////////////////////////////////////////////////////////////////
 // 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 +1706 @@
   \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;

trunk/SophyaLib/NTools/generalfit.h

@@ -138 +138 @@
 
   double          GetParm(int);
-  Vector          GetParm();
+  TVector<r_8>    GetParm();
   double          GetParmErr(int);
   double          GetCoVar(int,int);
@@ -195 +195 @@
   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 +215 @@
   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 +229 @@
   
   // 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;

trunk/SophyaLib/NTools/poly.cc

@@ -31 +31 @@
 
 Poly::Poly(int degre)
-: Vector(degre+1), dirty(0), deg(0)
+: TVector<r_8>(degre+1), dirty(0), deg(0)
 {
   END_CONSTRUCTOR
@@ -41 +41 @@
 //      Constructeur par copie.
 //--
-:Vector(a), dirty(a.dirty), deg(a.deg)
+:TVector<r_8>(a), dirty(a.dirty), deg(a.deg)
 {
   END_CONSTRUCTOR
@@ -111 +111 @@
 
 //++
-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 +179 @@
 {
   if (this == &a) return *this;
-  Vector::operator=(a);
+  TVector<r_8>::operator=(a);
 
   UpdateDeg();
@@ -275 +275 @@
 
 //++
-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 +287 @@
   Realloc(degre);
 
-  Matrix a(degre+1, n);
+  TMatrix<r_8> a(degre+1, n);
 
   for (int c=0; c<n; c++) {
@@ -297 +297 @@
   }
 
-  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 +304 @@
 
 //++
-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 +320 @@
   errCoef.Realloc(degre+1);
 
-  Matrix a(degre+1, n);
+  TMatrix<r_8> a(degre+1, n);
 
   for (int c=0; c<n; c++) {
@@ -330 +330 @@
   }
 
-  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 +371 @@
 is >> dg;
 dobj->Realloc(dg,true);
-is >> *((Vector *) dobj);
+is >> *((TVector<r_8> *) dobj);
 dobj->UpdateDeg();
 }
@@ -381 +381 @@
 dobj->Realloc(dobj->deg,true);
 os << dobj->deg;
-os << *((Vector *) dobj);
+os << *((TVector<r_8> *) dobj);
 }
 
@@ -417 +417 @@
 //      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 +429 @@
 //      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 +444 @@
 //      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 +484 @@
   UpdateDegIfDirty();
   Poly2 tmp(*this);
-  Vector::Realloc((degreX+1)*(degreY+1));
+  TVector<r_8>::Realloc((degreX+1)*(degreY+1));
   DataBlock().Reset();
   maxDegX = degreX;
@@ -554 +554 @@
 
 //++
-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 +566 @@
   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 +580 @@
   }
 
-  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 +588 @@
 
 //++
-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 +604 @@
   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 +618 @@
   }
 
-  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 +625 @@
 
 //++
-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 +637 @@
   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 +654 @@
   }
 
-  LinFitter lf;
+  LinFitter<r_8> lf;
   double rc = lf.LinFit(a,z,cf);
 
@@ -670 +670 @@
 
 //++
-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 +687 @@
 #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 +704 @@
   }
 
-  LinFitter lf;
+  LinFitter<r_8> lf;
   double rc = lf.LinFit(a,z,errz2,cf,ecf);
 
@@ -875 +875 @@
 is >> dgx >> dgy;
 dobj->Realloc(dgx,dgy);
-is >> *((Vector *) dobj);
+is >> *((TVector<r_8> *) dobj);
 dobj->UpdateDeg();
 }
@@ -883 +883 @@
 if(dobj == NULL) return;
 os << dobj->maxDegX << dobj->maxDegY;
-os << *((Vector *) dobj);
+os << *((TVector<r_8> *) dobj);
 }
 

trunk/SophyaLib/NTools/poly.h

@@ -1 +1 @@
 // 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 +21 @@
 
 //////////////////////////////////////////////////////////////////////////
-class Poly : public Vector {
+class Poly : public TVector<r_8> {
   friend class ObjFileIO<Poly>;
 public:
@@ -29 +29 @@
   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 +49 @@
   // 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 +72 @@
   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 +116 @@
 
 //////////////////////////////////////////////////////////////////////////
-class Poly2 : public Vector {
+class Poly2 : public TVector<r_8> {
   friend class ObjFileIO<Poly2>;
 public:
@@ -154 +155 @@
   // 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