Index: trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- trunk/SophyaLib/NTools/generaldata.cc	(revision 514)
+++ trunk/SophyaLib/NTools/generaldata.cc	(revision 914)
@@ -19,32 +19,11 @@
 //================================================================
 
-//++
-// Class	GeneralFitData
-// Lib		Outils++ 
-// include	generaldata.h
-//
-//	Classe de stoquage de donnees a plusieurs variables avec erreur
-//	sur l'ordonnee et sur les abscisses (options).
-//|   {x0(i),Ex0(i), x1(i),Ex1(i), x2(i),Ex2(i) ... ; Y(i),EY(i)}
-//--
-
-// Pour memoire, structure du rangement (n=mNVar):
-// - Valeur des abscisses mXP (idem pour mErrXP):
-//   x0,x1,x2,...,xn   x0,x1,x2,...,xn  ....  x0,x1,x2,....,xn
-//   |  1er point  |   |  2sd point  |  ....  | point mNData |
-//   Donc abscisse J=[0,mNVar[ du point numero I=[0,mNData[: mXP[I*mNVar+J]
-// - Valeur de l'ordonnee mF (idem pour mErr et mOK):
-//          f                f                      f
-//   |  1er point  |  |  2sd point  |  .... | point mNData |
-//   Donc point numero I [0,mNData[ : mF[i]
-
-//////////////////////////////////////////////////////////////////////
-//++
+//////////////////////////////////////////////////////////////////////
+/*!
+  Constructeur. ``nVar'' represente la dimension de l'espace des abscisses,
+  ``ndatalloc'' le nombre maximum de points et ``errx'' si non nul
+  indique que l'on fournit des erreurs sur les ``nVar'' variables en abscisse.
+*/
 GeneralFitData::GeneralFitData(unsigned int nVar, unsigned int ndatalloc, uint_2 errx)
-//
-//	Constructeur. ``nVar'' represente la dimension de l'espace des abscisses,
-//	``ndatalloc'' le nombre maximum de points et ``errx'' si non nul
-//	indique que l'on fournit des erreurs sur les ``nVar'' variables en abscisse.
-//--
   : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
   , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
@@ -59,13 +38,12 @@
 }
 
-//++
+/*!
+  Constructeur par copie. Si ``clean'' est ``true''
+  seules les donnees valides de ``data'' sont copiees.
+  Si ``clean'' est ``false'' (defaut) toutes les donnees
+  sont copiees et la taille totale de ``data'' est allouee
+  meme si elle est plus grande que la taille des donnees stoquees.
+*/
 GeneralFitData::GeneralFitData(const GeneralFitData& data, bool clean)
-//
-//	Constructeur par copie. Si ``clean'' est ``true''
-//	seules les donnees valides de ``data'' sont copiees.
-//	Si ``clean'' est ``false'' (defaut) toutes les donnees
-//	sont copiees et la taille totale de ``data'' est allouee
-//	meme si elle est plus grande que la taille des donnees stoquees.
-//--
   : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
   , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
@@ -98,9 +76,8 @@
 }
 
-//++
+/*!
+  Constructeur par defaut.
+*/
 GeneralFitData::GeneralFitData()
-//
-//	Constructeur par defaut.
-//--
   : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
   , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
@@ -110,9 +87,8 @@
 }
 
-//++
+/*!
+  Destructeur
+*/
 GeneralFitData::~GeneralFitData()
-//
-//	Destructeur
-//--
 {
  Delete();
@@ -120,12 +96,11 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour redefinir la structure de donnees (ou la creer si on a utilise
+  le createur par defaut). Voir les explications des arguments
+  dans les commentaires du constructeur. Si ``errx''\<0 alors
+  la valeur prise est celle definie auparavent.
+*/
 void GeneralFitData::Alloc(unsigned int nVar, unsigned int ndatalloc, int_2 errx)
-//
-//	Pour redefinir la structure de donnees (ou la creer si on a utilise
-//	le createur par defaut). Voir les explications des arguments
-//	dans les commentaires du constructeur. Si ``errx''<0 alors
-//	la valeur prise est celle definie auparavent.
-//--
 {
 ASSERT( nVar>0 && ndatalloc>0 );
@@ -151,4 +126,7 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+   Gestion des des-allocations
+*/
 void GeneralFitData::Delete()
 {
@@ -163,11 +141,10 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Remise a zero de la structure pour nouveau remplissage (pas d'arg)
+  ou remise a la position ``ptr'' (si arg). Les donnees apres ``ptr''
+  sont sur-ecrites.
+*/
 void GeneralFitData::SetDataPtr(int ptr)
-//
-//	Remise a zero de la structure pour nouveau remplissage (pas d'arg)
-//	ou remise a la position ``ptr'' (si arg). Les donnees apres ``ptr''
-//	sont sur-ecrites.
-//--
 {
  ASSERT(ptr >= 0 && ptr < mNDataAlloc);
@@ -179,9 +156,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour tuer un point
+*/
 void GeneralFitData::KillData(int i)
-//
-//	Pour tuer un point
-//--
 {
  ASSERT(i >= 0 && i < mNData);
@@ -192,9 +168,8 @@
 }
 
-//++
+/*!
+  Pour tuer une serie de points
+*/
 void GeneralFitData::KillData(int i1,int i2)
-//
-//	Pour tuer une serie de points
-//--
 {
  ASSERT(i1 >= 0 && i1 < mNData);
@@ -206,9 +181,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour re-valider le point numero i ([0,NData]).
+*/
 void GeneralFitData::ValidData(int i)
-//
-//	Pour re-valider le point numero i ([0,NData]).
-//--
 {
  ASSERT(i >= 0 && i < mNData);
@@ -223,9 +197,8 @@
 }
 
-//++
+/*!
+  Pour re-valider les points numeros i1 a i2.
+*/
 void GeneralFitData::ValidData(int i1,int i2)
-//
-//	Pour re-valider les points numeros i1 a i2.
-//--
 {
  ASSERT(i1 >= 0 && i1 < mNData);
@@ -236,9 +209,8 @@
 }
 
-//++
+/*!
+  Pour re-valider tous les points.
+*/
 void GeneralFitData::ValidData()
-//
-//	Pour re-valider tous les points.
-//--
 {
  for(int i=0;i<mNData;i++) ValidData(i);
@@ -246,21 +218,17 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour redefinir un point a \f$ {x,[errx] ; f,err} \f$
+*/
 void GeneralFitData::RedefineData1(int i,double x,double f,double err,double errx)
-//
-//	Pour redefinir un point a
-//|     {x,[errx] ; f,err}
-//--
 {
  RedefineData(i,&x,f,err,&errx);
 }
 
-//++
+/*!
+  Pour redefinir un point a \f$ {x,[errx], y,[erry] ; f,err} \f$ 
+*/
 void GeneralFitData::RedefineData2(int i,double x,double y,double f
                                   ,double err,double errx,double erry)
-//
-//	Pour redefinir un point a
-//|     {x,[errx], y,[erry] ; f,err}
-//--
 {
  double xp[2] = {x,y};
@@ -269,10 +237,9 @@
 }
 
-//++
+/*!
+  Pour redefinir un point a
+  \f$ {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err} \f$ 
+*/
 void GeneralFitData::RedefineData(int i,double* xp,double f,double err,double* errxp)
-//
-//	Pour redefinir un point a
-//| {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err}
-//--
 {
  ASSERT(i>=0 && i<mNData);
@@ -300,21 +267,17 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour ajouter un point \f$ {x,[errx] ; f,err} \f$
+*/
 void GeneralFitData::AddData1(double x, double f, double err, double errx)
-//
-//	Pour ajouter un point
-//|     {x,[errx] ; f,err}
-//--
 {
  AddData(&x,f,err,&errx);
 }
 
-//++
+/*!
+  Pour ajouter un point \f$ {x,[errx], y,[erry] ; f,err} \f$ 
+*/
 void GeneralFitData::AddData2(double x, double y, double f
                              , double err, double errx, double erry)
-//
-//	Pour ajouter un point
-//|     {x,[errx], y,[erry] ; f,err}
-//--
 {
  double xp[2] = {x,y};
@@ -323,10 +286,9 @@
 }
 
-//++
+/*!
+  Pour ajouter un point
+  \f$ {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err} \f$
+*/
 void GeneralFitData::AddData(double* xp, double f, double err,double* errxp)
-//
-//	Pour ajouter un point
-//| {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err}
-//--
 {
  ASSERT(mNData < mNDataAlloc);
@@ -351,10 +313,9 @@
 }
 
-//++
+/*!
+  Pour ajouter un point
+ \f$ {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err} \f$ 
+*/
 void GeneralFitData::AddData(float* xp, float f, float err, float* errxp)
-//
-//	Pour ajouter un point
-//| {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err}
-//--
 {
  {for(int i=0;i<mNVar;i++) BuffVar[i] = (double) xp[i];}
@@ -364,11 +325,10 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+  \f$ {x(i),[errx(i)] ; f(i),err(i)} \f$
+*/
 void GeneralFitData::SetData1(int nData
             , double* x, double* f, double *err, double *errx)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|     {x(i),[errx(i)] ; f(i),err(i)}
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -381,11 +341,10 @@
 }
 
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+  \f$ {x(i),[errx(i)] ; f(i),err(i)} \f$
+*/
 void GeneralFitData::SetData1(int nData
             , float* x, float* f, float* err, float *errx)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|     {x(i),[errx(i)] ; f(i),err(i)}
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -398,11 +357,10 @@
 }
 
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+  \f$ {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)} \f$
+*/
 void GeneralFitData::SetData2(int nData, double* x, double* y, double* f
                              ,double *err,double *errx,double *erry)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|     {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)}
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -416,11 +374,10 @@
 }
 
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+ \f$ {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)} \f$
+*/
 void GeneralFitData::SetData2(int nData, float* x, float* y, float* f
                              ,float *err,float *errx,float *erry)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|     {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)}
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -434,18 +391,20 @@
 }
 
-//++
+/*!
+  Pour remplir la structure de donnees d'un seul coup avec
+  \f$ {X0(i),[EX0(i)], X1(i),[EX1(i)], X2(i),[EX2(i)], ... ; F(i),Err(i)} \f$
+
+  Attention: si la structure est n'est pas vide, les tableaux sont copies
+  apres les donnees pre-existantes (qui ne sont donc pas detruites). Pour
+  effacer les donnees pre-existantes utiliser SetDataPtr(0).
+  \verbatim
+      Ici **xp est un pointeur sur un tableau de pointeurs tq
+        xp[0] = &X0[0], xp[1] = &X1[0], xp[2] = &X2[0] ...
+      ou X0,X1,X2,... sont les tableaux X0[nData] X1[nData] X2[nData] ...
+      des variables (meme commentaire pour errxp).
+  \endverbatim
+*/
 void GeneralFitData::SetData(int nData,double** xp, double *f
                             , double *err, double** errxp)
-//
-//	Pour remplir la structure de donnees d'un seul coup avec
-//|   {X0(i),[EX0(i)], X1(i),[EX1(i)], X2(i),[EX2(i)], ... ; F(i),Err(i)}
-//	Attention: si la structure est n'est pas vide, les tableaux sont copies
-//	apres les donnees pre-existantes (qui ne sont donc pas detruites). Pour
-//	effacer les donnees pre-existantes utiliser SetDataPtr(0).
-//|   Ici **xp est un pointeur sur un tableau de pointeurs tq
-//|     xp[0] = &X0[0], xp[1] = &X1[0], xp[2] = &X2[0] ...
-//|   ou X0,X1,X2,... sont les tableaux X0[nData] X1[nData] X2[nData] ...
-//|   des variables (meme commentaire pour errxp).
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -461,10 +420,9 @@
 }
 
-//++
+/*!
+  Voir commentaire ci-dessus.
+*/
 void GeneralFitData::SetData(int nData,float** xp, float *f
                             , float *err, float** errxp)
-//
-//	Voir commentaire ci-dessus.
-//--
 {
  ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
@@ -482,9 +440,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Impression de l'etat de la structure de donnees
+*/
 void GeneralFitData::PrintStatus()
-//
-//	Impression de l'etat de la structure de donnees
-//--
 {
   cout<<"GeneralFitData:: "<<endl
@@ -495,9 +452,8 @@
 }
 
-//++
+/*!
+  Impression du point i
+*/
 void GeneralFitData::PrintData(int i)
-//
-//	Impression du point i
-//--
 {
  ASSERT(i>=0 && i<mNData);
@@ -512,9 +468,8 @@
 }
 
-//++
+/*!
+  Impression des points i1 a i2
+*/
 void GeneralFitData::PrintData(int i1,int i2)
-//
-//	Impression des points i1 a i2
-//--
 {
  if(i1<0) i1=0;
@@ -529,9 +484,8 @@
 }
 
-//++
+/*!
+  Impression de tous les points
+*/
 void GeneralFitData::PrintData()
-//
-//	Impression de tous les points
-//--
 {
  ASSERT(mNData>0);
@@ -540,9 +494,8 @@
 }
 
-//++
+/*!
+  Impression de l'etat de la structure de donnees avec bornes sur "s"
+*/
 void GeneralFitData::Show(ostream& os) const
-//
-//	Impression de l'etat de la structure de donnees avec bornes sur "s"
-//--
 {
 double min,max;
@@ -557,16 +510,17 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne les numeros des points de valeurs minimum et maximum
+  de la variable ``var'':
+  \verbatim
+    La variable "var" est de la forme : var = AB avec
+     B = 0 : variable d'ordonnee Y (valeur de A indifferente)
+     B = 1 : erreur variable d'ordonnee EY (valeur de A indifferente)
+     B = 2 : variable d'abscisse X numero A #[0,NVar[
+     B = 3 : erreur variable d'abscisse EX numero A #[0,NVar[
+    - Return NData checked si ok, -1 si probleme.
+  \endverbatim
+*/
 int GeneralFitData::GetMnMx(int var,int& imin,int& imax) const
-//
-//	Retourne les numeros des points de valeurs minimum et maximum
-//	de la variable ``var'':
-//| La variable "var" est de la forme : var = AB avec
-//|  B = 0 : variable d'ordonnee Y (valeur de A indifferente)
-//|  B = 1 : erreur variable d'ordonnee EY (valeur de A indifferente)
-//|  B = 2 : variable d'abscisse X numero A #[0,NVar[
-//|  B = 3 : erreur variable d'abscisse EX numero A #[0,NVar[
-//| - Return NData checked si ok, -1 si probleme.
-//--
 {
 imin = imax = -1;
@@ -592,10 +546,9 @@
 }
 
-//++
+/*!
+  Retourne le minimum et le maximum de la variable ``var''
+  (cf commentaires GetMnMx).
+*/
 int GeneralFitData::GetMnMx(int var,double& min,double& max) const
-//
-//	Retourne le minimum et le maximum de la variable ``var''
-//	(cf commentaires GetMnMx).
-//--
 {
 min = 1.; max = -1.;
@@ -622,13 +575,15 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+//
+  Retourne la moyenne et le sigma de la variable ``var''
+  (cf commentaires GetMnMx).
+  \verbatim
+    - Return : nombre de donnees utilisees, -1 si pb, -2 si sigma<0.
+    - Seuls les points valides de valeur entre min,max sont utilises.
+      Si min>=max pas de coupures sur les valeurs.
+  \endverbatim
+*/
 int GeneralFitData::GetMeanSigma(int var,double& mean,double& sigma,double min,double max)
-//
-//	Retourne la moyenne et le sigma de la variable ``var''
-//	(cf commentaires GetMnMx).
-//| - Return : nombre de donnees utilisees, -1 si pb, -2 si sigma<0.
-//| - Seuls les points valides de valeur entre min,max sont utilises.
-//|   Si min>=max pas de coupures sur les valeurs.
-//--
 {
 mean = sigma = 0.;
@@ -661,17 +616,18 @@
 }
 
-//++
+/*!
+  Retourne le mode de la variable ``var''
+  (cf commentaires GetMnMx).
+  \verbatim
+    - Return : nombre de donnees utilisees, -1 si pb.
+    - Seuls les points valides de valeur entre min,max sont utilises.
+      Si min>=max pas de coupures sur les valeurs.
+    - Le calcul du mode est approximee par la formule:
+        Mode = Median - coeff*(Mean-Median)   (def: coeff=0.8)
+    - Kendall and Stuart donne coeff=2., mais coeff peut etre regle.
+  \endverbatim
+*/
 int GeneralFitData::GetMoMeMed(int var,double& mode,double& mean,double& median,
                                double min,double max,double coeff)
-//
-//	Retourne le mode de la variable ``var''
-//	(cf commentaires GetMnMx).
-//| - Return : nombre de donnees utilisees, -1 si pb.
-//| - Seuls les points valides de valeur entre min,max sont utilises.
-//|   Si min>=max pas de coupures sur les valeurs.
-//| - Le calcul du mode est approximee par la formule:
-//|     Mode = Median - coeff*(Mean-Median)   (def: coeff=0.8)
-//| - Kendall and Stuart donne coeff=2., mais coeff peut etre regle.
-//--
 {
 mode = mean = median = 0.;
@@ -716,9 +672,8 @@
 }
 
-//++
+/*!
+  Cf description ci-dessus ``GetMoMeMed''.
+*/
 int GeneralFitData::GetMode(int var,double& mode,double min,double max,double coeff)
-//
-//	Cf description ci-dessus ``GetMoMeMed''.
-//--
 {
 double mean,median;
@@ -727,19 +682,20 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour fiter un polynome de degre ``degre''. On fite
+  Y=f(X) ou Y=Val et X=Absc(varx). Si ``ey'' est ``true''
+  le fit prend en compte les erreurs stoquees dans EVal,
+  sinon fit sans erreurs. Le resultat du fit est retourne
+  dans le polynome ``pol''.
+  \verbatim
+  Return:
+     -   Res = le residu du fit
+     -   -1 si degre<0
+     -   -2 si probleme sur numero de variable X
+     -   -4 si NDataGood<0
+     -   -5 si nombre de data trouves different de NDataGood
+  \endverbatim
+*/
 double GeneralFitData::PolFit(int varx,Poly& pol,int degre,bool ey)
-//
-//	Pour fiter un polynome de degre ``degre''. On fite
-//	Y=f(X) ou Y=Val et X=Absc(varx). Si ``ey'' est ``true''
-//	le fit prend en compte les erreurs stoquees dans EVal,
-//	sinon fit sans erreurs. Le resultat du fit est retourne
-//	dans le polynome ``pol''.
-//| Return:
-//|  -   Res = le residu du fit
-//|  -   -1 si degre<0
-//|  -   -2 si probleme sur numero de variable X
-//|  -   -4 si NDataGood<0
-//|  -   -5 si nombre de data trouves different de NDataGood
-//--
 {
 if(degre<0) return -1.;
@@ -769,25 +725,25 @@
 }
 
-//++
+/*!
+  Pour fiter un polynome de degre ``degre1''. On fite
+  Z=f(X,Y) ou Z=Val et X=Absc(varx) et Y=Absc(vary).
+  Si ``ey'' est ``true'' le fit prend en compte les erreurs
+  stoquees dans EVal, sinon fit sans erreurs. Si ``degre2''
+  negatif, le fit determine un polynome en X,Y de degre
+  total ``degre`''. Si ``degre2'' positif ou nul, le fit
+  demande un fit de ``degre1'' pour la variable X et de degre
+  ``degre2'' sur la variable Y. Le resultat du fit est retourne
+  dans le polynome ``pol''.
+  \verbatim
+    Return:
+     -   Res = le residu du fit
+     -   -1 si degre<0
+     -   -2 si probleme sur numero de variable X
+     -   -3 si probleme sur numero de variable Y
+     -   -4 si NDataGood<0
+     -   -5 si nombre de data trouves different de NDataGood
+  \endverbatim
+*/
 double GeneralFitData::PolFit(int varx,int vary,Poly2& pol,int degre1,int degre2,bool ez)
-//
-//
-//	Pour fiter un polynome de degre ``degre1''. On fite
-//	Z=f(X,Y) ou Z=Val et X=Absc(varx) et Y=Absc(vary).
-//	Si ``ey'' est ``true'' le fit prend en compte les erreurs
-//	stoquees dans EVal, sinon fit sans erreurs. Si ``degre2''
-//	negatif, le fit determine un polynome en X,Y de degre
-//	total ``degre`''. Si ``degre2'' positif ou nul, le fit
-//	demande un fit de ``degre1'' pour la variable X et de degre
-//	``degre2'' sur la variable Y. Le resultat du fit est retourne
-//	dans le polynome ``pol''.
-//| Return:
-//|  -   Res = le residu du fit
-//|  -   -1 si degre<0
-//|  -   -2 si probleme sur numero de variable X
-//|  -   -3 si probleme sur numero de variable Y
-//|  -   -4 si NDataGood<0
-//|  -   -5 si nombre de data trouves different de NDataGood
-//--
 {
 if(degre1<0) return -1.;
@@ -823,9 +779,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne une classe contenant les residus du fit ``gfit''.
+*/
 GeneralFitData GeneralFitData::FitResidus(GeneralFit& gfit)
-//
-//	Retourne une classe contenant les residus du fit ``gfit''.
-//--
 {
 if(gfit.GetNVar()!=mNVar)
@@ -834,9 +789,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant la function du fit ``gfit''.
+*/
 GeneralFitData GeneralFitData::FitFunction(GeneralFit& gfit)
-//
-//	Retourne une classe contenant la function du fit ``gfit''.
-//--
 {
 if(gfit.GetNVar()!=mNVar)
@@ -846,14 +800,16 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+//
+  Retourne la donnee `n' dans le vecteur de double `ret'.
+  \verbatim
+    Par defaut, ret=NULL et le buffer interne de la classe est retourne
+    - Les donnees sont rangees dans l'ordre:
+       x0,x1,x2,... ; ex0,ex1,ex2,...  ; y ; ey ; ok(0/1)
+       |<- NVar ->| + |<-   NVar   ->| + 1 +  1 +  1
+      Le vecteur ret a la taille 2*NVar+2+1
+  \endverbatim
+*/
 r_8* GeneralFitData::GetVec(int n, r_8* ret)   const
-//
-//	Retourne la donnee `n' dans le vecteur de double `ret'.
-//| Par defaut, ret=NULL et le buffer interne de la classe est retourne
-//| - Les donnees sont rangees dans l'ordre:
-//|    x0,x1,x2,... ; ex0,ex1,ex2,...  ; y ; ey ; ok(0/1)
-//|    |<- NVar ->| + |<-   NVar   ->| + 1 +  1 +  1
-//|   Le vecteur ret a la taille 2*NVar+2+1
-//--
 {
 int i;
@@ -870,10 +826,9 @@
 }
 
-//++
+/*!
+  Retourne la donnee `n' dans le vecteur de float `ret'
+  (meme commentaires que pour GetVec).
+*/
 r_4* GeneralFitData::GetVecR4(int n, r_4* ret)   const
-//
-//	Retourne la donnee `n' dans le vecteur de float `ret'
-//	(meme commentaires que pour GetVec).
-//--
 {
 if (ret == NULL) ret = BuffVarR4;
@@ -886,87 +841,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
-// int inline int GetSpaceFree() const
-//	Retourne la place restante dans la structure (nombre de
-//	donnees que l'on peut encore stoquer).
-//--
-//++
-// inline int  NVar()       const
-//	Retourne le nombre de variables Xi
-//--
-//++
-// inline int  NData()
-//	Retourne le nombre de donnees
-//--
-//++
-// inline int  NDataGood()  const
-//	Retourne le nombre de bonnes donnees (utilisees pour le fit)
-//--
-//++
-// inline int  NDataAlloc() const
-//	Retourne la place maximale allouee pour les donnees
-//--
-//++
-// inline unsigned short int IsValid(int i) const
-//	Retourne 1 si point valide, sinon 0
-//--
-//++
-// inline bool HasXErrors()
-//	Retourne ``true'' si il y a des erreurs sur les variables
-//	d'abscisse, ``false'' sinon.
-//--
-//++
-// inline double X1(int i) const
-//	Retourne l'abscisse pour 1 dimension (y=f(x)) donnee I
-//--
-//++
-// inline double X(int i) const
-//	Retourne la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double Y(int i) const
-//	Retourne la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double Z(int i) const
-//	Retourne la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double Absc(int j,int i) const
-//	Retourne la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
-//--
-//++
-// inline double Val(int i) const
-//	Retourne la valeur de la Ieme donnee
-//--
-//++
-// inline double EX1(int i) const
-//	Retourne l'erreur (dx) sur l'abscisse pour 1 dimension (y=f(x)) donnee I
-//--
-//++
-// inline double EX(int i) const
-//	Retourne l'erreur (dx) sur la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double EY(int i) const
-//	Retourne l'erreur (dy) sur la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double EZ(int i) const
-//	Retourne l'erreur (dz) sur la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double EAbsc(int j,int i) const
-//	Retourne l'erreur (dxj) sur la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
-//--
-//++
-// inline double EVal(int i) const {return mErr[i];}
-//	Retourne l'erreur de la Ieme donnee
-//--
-
-
-//////////////////////////////////////////////////////////////////////
 // ------- Implementation de  l interface NTuple  ---------
 
+/*!
+  Retourne le nombre de ligne = NData() (pour interface NTuple)
+*/
 uint_4 GeneralFitData::NbLines() const
 {
@@ -974,19 +851,22 @@
 }
 
-//++
+/*!
+  Retourne le nombre de colonnes du ntuple equivalent:
+  \verbatim
+    Exemple: on a une fonction sur un espace a 4 dimensions:
+    "x0,x1,x2,x3    , ex0,ex1,ex2,ex3    , y,   ey ,    ok"
+      0  1  2  3        4   5   6   7      8     9      10
+      |        |        |           |      |     |       |        
+      0       nv-1     nv         2*nv-1  2*nv  2*nv+1  2*nv+2
+    soit 2*nvar+3 variables/colonnes.
+  \endverbatim
+  (pour interface NTuple)
+*/
 uint_4 GeneralFitData::NbColumns() const
-//
-//	Retourne le nombre de colonnes du ntuple equivalent:
-//| Exemple: on a une fonction sur un espace a 4 dimensions:
-//| "x0,x1,x2,x3    , ex0,ex1,ex2,ex3    , y,   ey ,    ok"
-//|   0  1  2  3        4   5   6   7      8     9      10
-//|   |        |        |           |      |     |       |        
-//|   0       nv-1     nv         2*nv-1  2*nv  2*nv+1  2*nv+2
-//| soit 2*nvar+3 variables/colonnes.
-//--
 {
 return(2*NVar()+3);
 }
 
+//! Pour interface NTuple
 r_8 * GeneralFitData::GetLineD(int n) const
 {
@@ -994,4 +874,5 @@
 }
 
+//! Pour interface NTuple
 r_8 GeneralFitData::GetCell(int n, int k) const
 {
@@ -1001,4 +882,5 @@
 }
 
+//! Pour interface NTuple
 r_8 GeneralFitData::GetCell(int n, string const & nom) const
 {
@@ -1007,9 +889,8 @@
 }
 
-//++
+/*!
+  Retourne le minimum et le maximum de la variable `k' (pour interface NTuple).
+*/
 void GeneralFitData::GetMinMax(int k, double& min, double& max)  const
-//
-//	Retourne le minimum et le maximum de la variable `k'.
-//--
 {
 int var;
@@ -1024,4 +905,5 @@
 }
 
+//! Pour interface NTuple
 void GeneralFitData::GetMinMax(string const & nom, double& min, double& max)   const
 {
@@ -1030,4 +912,5 @@
 }
 
+//! Pour interface NTuple
 int GeneralFitData::ColumnIndex(string const & nom)  const
 {
@@ -1043,4 +926,5 @@
 }
 
+//! Pour interface NTuple
 string GeneralFitData::ColumnName(int k) const
 {
@@ -1056,11 +940,10 @@
 }
 
-//++
+/*!
+  Retourne une chaine de caracteres avec la declaration des noms de 
+  variables. si "nomx!=NULL" , des instructions d'affectation
+  a partir d'un tableau "nomx[i]" sont ajoutees (pour interface NTuple).
+*/
 string GeneralFitData::VarList_C(const char* nomx)  const
-//
-//	Retourne une chaine de caracteres avec la declaration des noms de 
-//	variables. si "nomx!=NULL" , des instructions d'affectation
-//	a partir d'un tableau "nomx[i]" sont ajoutees. 
-//--
 {
 char buff[256];
