Index: trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- trunk/SophyaLib/NTools/generaldata.cc	(revision 896)
+++ 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];
Index: trunk/SophyaLib/NTools/generaldata.h
===================================================================
--- trunk/SophyaLib/NTools/generaldata.h	(revision 896)
+++ trunk/SophyaLib/NTools/generaldata.h	(revision 914)
@@ -19,9 +19,31 @@
 //================================================================
 
+/*!
+  Classe de stoquage de donnees a plusieurs variables avec erreur
+  sur l'ordonnee et sur les abscisses (options) :
+
+  \f$ {x0(i),Ex0(i), x1(i),Ex1(i), x2(i),Ex2(i) ... ; Y(i),EY(i)} \f$
+  \verbatim
+   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]
+  \endverbatim
+*/
+
 class GeneralFitData : public AnyDataObj , public NTupleInterface {
   friend class GeneralFit;
   friend class ObjFileIO<GeneralFitData>;
 public:
-  enum {Def_ErrF = 1, Def_ErrX = 0};
+  //! Valeurs par defaut pour l'utilisation des erreurs
+  enum {
+    Def_ErrF = 1, //!< erreurs sur F par defaut
+    Def_ErrX = 0  //!< pas d'erreurs sur les variables X,Y,... par defaut
+    };
 
   GeneralFitData(unsigned int nVar, unsigned int nDataAlloc, uint_2 errx=0);
@@ -67,40 +89,59 @@
   inline void Show() const {Show(cout);}
 
+  //! Retourne la place restante dans la structure (nombre de donnees que l'on peut encore stoquer).
   inline int GetSpaceFree() const { return mNDataAlloc - mNData; }
+  //! Retourne le nombre de variables Xi
   inline int NVar()       const {return mNVar;}
+  //! Retourne le nombre de donnees
   inline int NData()      const {return mNData;}
+  //! Retourne le nombre de bonnes donnees (utilisees pour le fit)
   inline int NDataGood()  const {return mNDataGood;}
+  //! Retourne la place maximale allouee pour les donnees
   inline int NDataAlloc() const {return mNDataAlloc;}
 
+  //! Retourne 1 si point valide, sinon 0
   inline unsigned short int IsValid(int i) const
                 {if(i>=0 && i<mNData) return mOK[i]; else return 0;}
+  //! Retourne ``true'' si il y a des erreurs sur les variables d'abscisse, ``false'' sinon.
   inline bool HasXErrors() {if(mErrXP) return true; else return false;}
 
+  //! Retourne l'abscisse pour 1 dimension (y=f(x)) donnee I
   inline double X1(int i) const
                 {if(i>=0 && i<mNData) return mXP[i]; else return 0.;}
+  //! Retourne la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
   inline double X(int i) const
                 {if(i>=0 && i<mNData) return mXP[i*mNVar]; else return 0.;}
+  //! Retourne la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
   inline double Y(int i) const
                 {if(i>=0 && i<mNData && 1<mNVar) return mXP[i*mNVar+1]; else return 0.;}
+  //! etourne la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
   inline double Z(int i) const
                 {if(i>=0 && i<mNData && 2<mNVar) return mXP[i*mNVar+2]; else return 0.;}
+  //! Retourne la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
   inline double Absc(int j,int i) const
                 {if(i>=0 && i<mNData && j<mNVar)return mXP[i*mNVar+j]; else return 0.;}
+  //! Retourne la valeur de la Ieme donnee
   inline double Val(int i) const
                 {if(i>=0 && i<mNData) return mF[i]; else return 0.;}
 
+  //! Retourne l'erreur (dx) sur l'abscisse pour 1 dimension (y=f(x)) donnee I
   inline double EX1(int i) const
                 {if(mErrXP && i>=0 && i<mNData) return mErrXP[i]; else return 0.;}
+  //! Retourne l'erreur (dx) sur la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
   inline double EX(int i) const
                 {if(mErrXP && i>=0 && i<mNData) return mErrXP[i*mNVar]; else return 0.;}
+  //! Retourne l'erreur (dy) sur la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
   inline double EY(int i) const
                 {if(mErrXP && i>=0 && i<mNData && 1<mNVar) return mErrXP[i*mNVar+1];
                  else return 0.;}
+  //! Retourne l'erreur (dz) sur la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
   inline double EZ(int i) const
                 {if(mErrXP && i>=0 && i<mNData && 2<mNVar) return mErrXP[i*mNVar+2];
                  else return 0.;}
+  //! Retourne l'erreur (dxj) sur la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
   inline double EAbsc(int j,int i) const
                 {if(mErrXP && i>=0 && i<mNData && j<mNVar) return mErrXP[i*mNVar+j];
                  else return 0.;}
+  //! Retourne l'erreur de la Ieme donnee
   inline double EVal(int i) const
                 {if(i>=0 && i<mNData) return mErr[i]; else return 0.;}
@@ -139,9 +180,9 @@
   int_4   mNDataGood;
   uint_2  mOk_EXP;
-  r_8* mXP;             // x0 y0 z0, x1 y1 z1, ..., xn yn zn 
-  r_8* mErrXP;          // Ex0 Ey0 Ez0, Ex1 Ey1 Ez1, ..., Exn Eyn Ezn 
-  r_8* mF;              // F0, F1, ...., Fn
-  r_8* mErr;            // EF0, EF1, ...., EFn
-  uint_2* mOK; // 1 si pt valid, 0 sinon
+  r_8* mXP;             //!< x0 y0 z0, x1 y1 z1, ..., xn yn zn 
+  r_8* mErrXP;          //!< Ex0 Ey0 Ez0, Ex1 Ey1 Ez1, ..., Exn Eyn Ezn 
+  r_8* mF;              //!< F0, F1, ...., Fn
+  r_8* mErr;            //!< EF0, EF1, ...., EFn
+  uint_2* mOK;          //!< 1 si pt valid, 0 sinon
   r_8* BuffVar;
   r_4* BuffVarR4;
Index: trunk/SophyaLib/NTools/generalfit.cc
===================================================================
--- trunk/SophyaLib/NTools/generalfit.cc	(revision 896)
+++ trunk/SophyaLib/NTools/generalfit.cc	(revision 914)
@@ -21,20 +21,10 @@
 //================================================================
 
-//++
-// Class	GeneralFunction
-// Lib	Outils++ 
-// include	generalfit.h
-//
-//	Classe de fonctions parametrees a plusieurs variables.
-//|           F[x1,x2,x3,...:a1,a2,a3,...]
-//--
-
-//////////////////////////////////////////////////////////////////////
-//++
+//////////////////////////////////////////////////////////////////////
+/*!
+ Creation d'une fonction de `nVar' variables et `nPar' parametres:
+ \f$ F[x(1),x(2),x(3),...x(nVar) : a(1),a(2),a(3),...,a(nPar)] \f$
+*/
 GeneralFunction::GeneralFunction(unsigned int nVar, unsigned int nPar)
-//
-//	Creation d'une fonction de `nVar' variables et `nPar' parametres.
-//|  F[x(1),x(2),x(3),...x(nVar) : a(1),a(2),a(3),...,a(nPar)]
-//--
   : mNVar(nVar), mNPar(nPar)
 {
@@ -45,8 +35,5 @@
 }
 
-//++
 GeneralFunction::~GeneralFunction()
-//
-//--
 {
  delete[] deltaParm;
@@ -55,10 +42,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Valeur et Derivees de la fonction (fct virtuelle par defaut).
+*/
 double GeneralFunction::Val_Der(double const xp[], double const* parm
                                , double *DgDpar)
-//
-//	Valeur et Derivees de la fonction (fct virtuelle par defaut).
-//--
 {
  for(int i=0;i<mNPar;i++) tmpParm[i] = parm[i];
@@ -77,10 +63,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition de la variation du parametre numPar
+  pour calculer la derivee automatiquement.
+*/
 void GeneralFunction::SetDeltaParm(int numPar, double d)
-//
-//	Definition de la variation du parametre numPar
-//	pour calculer la derivee automatiquement.
-//--
 {
  ASSERT(numPar >= 0 && numPar < mNPar);
@@ -88,27 +73,12 @@
 }
 
-//++
+
+/*!
+  Idem precedente fonction mais pour tous les parametres
+*/
 void GeneralFunction::SetDeltaParm(double const* dparam)
-//
-//	Idem precedente fonction mais pour tous les parametres
-//--
 {
  for(int i=0;i<mNPar;i++) deltaParm[i] = dparam[i];
 }
-
-//////////////////////////////////////////////////////////////////////
-// Rappel des inline functions pour commentaires
-//++
-// virtual double Value(double const xp[], double const* parm)=0;
-//	Valeur de la fonction a definir par l'utilisateur (fct virtuelle pure)
-//--
-//++
-// inline int     NVar() const
-//	Retourne le nombre de variables Xi
-//--
-//++
-// inline int     NPar() const
-//	Retourne le nombre de parametres Ai
-//--
 
 //================================================================
@@ -116,71 +86,56 @@
 //================================================================
 
-//++
-// Class	GeneralFunc
-// Lib	Outils++ 
-// include	generalfit.h
-//
-//	Classe de fonctions parametrees a plusieurs variables
-//	derivant de ``GeneralFunction''. Permet de definir
-//	une fonction a fiter sans passer par une classe derivee
-//	en utilisant l'ecriture courante du C. La fonction
-//	retournant les derivees par rapport aux parametres du fit
-//	peut etre egalement fournie (optionnel).
-//--
-
 /////////////////////////////////////////////////////////////////
-//++
-GeneralFunc::GeneralFunc(unsigned int nvar, unsigned int npar, double (*fun) (double const*, double const*)
-                        , double (*funder) (double const*, double const*, double*) )
-//
-//	Createur, on passe le nom ``fun'' de la fonction a la mode C.
-//	On peut optionellement egalement passer le nom de la fonction
-//	``funder'' qui retourne les valeurs des derivees par rapport
-//	aux parametres du fit.
-//--
-//++
-//| ----------------------
-//| Exemple d'utilisation:
-//| ----------------------
-//| include "generalfit.h"
-//| ...
-//| double   gaussc(double const* x,double const* p);
-//| double d_gaussc(double const* x,double const* p,double* dp);
-//| ...
-//| main {
-//|  ...
-//|  // Fit SANS calcul automatique des derivees
-//|  GeneralFunc      myfunc(2,7,gaussc);
-//|  GeneralFit       myfit(&myfunc);
-//|  ...
-//|  myfit.Fit();
-//|  ...
-//|  // Fit AVEC calcul automatique des derivees
-//|  GeneralFunc      myfunc(2,7,gaussc,d_gaussc);
-//|  GeneralFit       myfit(&myfunc);
-//|  ...
-//|  myfit.Fit();
-//| }
-//--
-//++
-//| // Definition de la fonction a fitter a la mode C
-//| double gaussc(double const* x,double const* p)
-//| // Fonction: X=(x[0]-p[1])/p[3], Y=(x[1]-p[2])/p[4],
-//| //  f = p[0]*exp{-0.5*[X^2+Y^2-2*p[5]*X*Y]} + p[6]
-//| {
-//|  double X = (x[0]-p[1])/p[3];
-//|  double Y = (x[1]-p[2])/p[4];
-//|  return p[0]*exp(-(X*X+Y*Y-2*p[5]*X*Y)/2)+p[6];
-//| }
-//| // Definition de la fonction des derivees / parametres
-//| // Cette fonction retourne aussi la valeur de la fonction a fitter.
-//| double d_gaussc(double const* x,double const* p,double* dp)
-//| {
-//|  dp[0] = derivee de gaussc par rapport au parametre p[0]
-//|  ...
-//|  dp[6] = derivee de gaussc par rapport au parametre p[6]
-//|  return gaussc(x,p);
-//| }
-//--
+/*!
+  Createur, on passe le nom ``fun'' de la fonction a la mode C.
+  On peut optionellement egalement passer le nom de la fonction
+  ``funder'' qui retourne les valeurs des derivees par rapport
+  aux parametres du fit.
+  \verbatim
+    ----------------------
+    Exemple d'utilisation:
+    ----------------------
+    include "generalfit.h"
+    ...
+    double   gaussc(double const* x,double const* p);
+    double d_gaussc(double const* x,double const* p,double* dp);
+    ...
+    main {
+     ...
+     // Fit SANS calcul automatique des derivees
+     GeneralFunc      myfunc(2,7,gaussc);
+     GeneralFit       myfit(&myfunc);
+     ...
+     myfit.Fit();
+     ...
+     // Fit AVEC calcul automatique des derivees
+     GeneralFunc      myfunc(2,7,gaussc,d_gaussc);
+     GeneralFit       myfit(&myfunc);
+     ...
+     myfit.Fit();
+    }
+    // Definition de la fonction a fitter a la mode C
+    double gaussc(double const* x,double const* p)
+    // Fonction: X=(x[0]-p[1])/p[3], Y=(x[1]-p[2])/p[4],
+    //  f = p[0]*exp{-0.5*[X^2+Y^2-2*p[5]*X*Y]} + p[6]
+    {
+     double X = (x[0]-p[1])/p[3];
+     double Y = (x[1]-p[2])/p[4];
+     return p[0]*exp(-(X*X+Y*Y-2*p[5]*X*Y)/2)+p[6];
+    }
+    // Definition de la fonction des derivees / parametres
+    // Cette fonction retourne aussi la valeur de la fonction a fitter.
+    double d_gaussc(double const* x,double const* p,double* dp)
+    {
+     dp[0] = derivee de gaussc par rapport au parametre p[0]
+     ...
+     dp[6] = derivee de gaussc par rapport au parametre p[6]
+     return gaussc(x,p);
+    }
+  \endverbatim
+*/
+GeneralFunc::GeneralFunc(unsigned int nvar, unsigned int npar
+             , double (*fun) (double const*, double const*)
+             , double (*funder) (double const*, double const*, double*) )
 : GeneralFunction(nvar,npar), tmpFun(fun), tmpFunDer(funder)
 {
@@ -206,20 +161,11 @@
 //================================================================
 
-//++
-// Class	GeneralXi2
-// Lib	Outils++ 
-// include	generalfit.h
+//////////////////////////////////////////////////////////////////////
+/*!
 //
-//	Classe de Xi2 a plusieurs parametres.
-//|           Xi2[a1,a2,a3,...]
-//--
-
-//////////////////////////////////////////////////////////////////////
-//++
+  Creation d'un Xi2 de `nPar' parametres.
+  \f$ Xi2[a(1),a(2),a(3),...,a(nPar)] \f$
+*/
 GeneralXi2::GeneralXi2(unsigned int nPar)
-//
-//	Creation d'un Xi2 de `nPar' parametres.
-//|  Xi2[a(1),a(2),a(3),...,a(nPar)]
-//--
   : mNPar(nPar)
 { 
@@ -229,8 +175,5 @@
 }
 
-//++
 GeneralXi2::~GeneralXi2()
-//
-//--
 {
  delete[] deltaParm;
@@ -238,10 +181,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Derivee du Xi2 par rapport au parametre `i'
+  pour les valeurs `parm' des parametres.
+*/
 double GeneralXi2::Derivee(GeneralFitData& data, int i, double* parm)
-//
-//	Derivee du Xi2 par rapport au parametre `i'
-//	pour les valeurs `parm' des parametres.
-//--
 {
  int dum;
@@ -255,35 +197,34 @@
 }
 
-//++
+/*!
+  Derivee seconde du Xi2 par rapport aux parametres `i' et `j'
+  pour les valeurs `parm' des parametres. Attention, cette fonction
+  calcule d/di(dC2/dj), valeur qui est numeriquement differente
+  de d/dj(dC2/di).
+  \verbatim
+   
+    **** Remarque: Derivee2 = dXi2/dPi.dPj represente le Hessien.
+    Derivee2(k,l)= dXi2/dPk.dPl
+                 = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]
+                          + [yi-f(xi;P)] * df(xi;P)/dPk.dPl }
+    ou (xi,yi) sont les points de mesure. "Si" l'erreur sur le point i
+       SUMi represente la somme sur les points de mesure
+       f(x;P) represente le modele parametrique a fitter
+       "P" represente l'ensemble des parametres et "Pi" le ieme parametre
+    Les composantes du Hessien dependent des derivees 1ere et 2sd du modele
+    a fitter f(x;P) selon les parametres "Pi". La prise en compte des derivees
+    secondes est un facteur destabilisant. De plus le facteur [yi-f(xi;P)]
+    devant la derivee 2sd est seulement l'erreur de mesure aleatoire qui
+    n'est pas correlee avec le modele. Le terme avec la derivee 2sd
+    tend donc a s'annuler et peut donc etre omis.
+    (cf. Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
+     Calculation of the Gradient and Hessian p682,683)
+   
+    **** Conseil: Il est conseille a l'utilisateur de sur-ecrire
+    la fonction virtuelle Derivee2 et de la remplacer par:
+    Derivee2(k,l) = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]}
+  \endverbatim
+*/
 double GeneralXi2::Derivee2(GeneralFitData& data, int i, int j, double* parm)
-//
-//	Derivee seconde du Xi2 par rapport aux parametres `i' et `j'
-//	pour les valeurs `parm' des parametres. Attention, cette fonction
-//	calcule d/di(dC2/dj), valeur qui est numeriquement differente
-//	de d/dj(dC2/di).
-//--
-//++
-//|
-//| **** Remarque: Derivee2 = dXi2/dPi.dPj represente le Hessien.
-//| Derivee2(k,l)= dXi2/dPk.dPl
-//|              = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]
-//|                       + [yi-f(xi;P)] * df(xi;P)/dPk.dPl }
-//| ou (xi,yi) sont les points de mesure. "Si" l'erreur sur le point i
-//|    SUMi represente la somme sur les points de mesure
-//|    f(x;P) represente le modele parametrique a fitter
-//|    "P" represente l'ensemble des parametres et "Pi" le ieme parametre
-//| Les composantes du Hessien dependent des derivees 1ere et 2sd du modele
-//| a fitter f(x;P) selon les parametres "Pi". La prise en compte des derivees
-//| secondes est un facteur destabilisant. De plus le facteur [yi-f(xi;P)]
-//| devant la derivee 2sd est seulement l'erreur de mesure aleatoire qui
-//| n'est pas correlee avec le modele. Le terme avec la derivee 2sd
-//| tend donc a s'annuler et peut donc etre omis.
-//| (cf. Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
-//|  Calculation of the Gradient and Hessian p682,683)
-//|
-//| **** Conseil: Il est conseille a l'utilisateur de sur-ecrire
-//| la fonction virtuelle Derivee2 et de la remplacer par:
-//| Derivee2(k,l) = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]}
-//--
 {
  double d = deltaParm[i];
@@ -298,10 +239,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition de la variation 'd' du parametre 'numPar'
+  pour calculer la derivee automatiquement.
+*/
 void GeneralXi2::SetDeltaParm(int numPar, double d)
-//
-//	Definition de la variation du parametre numPar
-//	pour calculer la derivee automatiquement.
-//--
 {
  ASSERT(numPar >= 0 && numPar < mNPar);
@@ -310,26 +250,11 @@
 }
 
-//++
+/*!
+  Idem precedente fonction mais pour tous les parametres.
+*/
 void GeneralXi2::SetDeltaParm(double const* dparam)
-//
-//	Idem precedente fonction mais pour tous les parametres.
-//--
 {
  for(int i=0;i<mNPar;i++) deltaParm[i] = dparam[i];
 }
-
-//////////////////////////////////////////////////////////////////////
-// Rappel des inline functions pour commentaires
-//++
-// virtual double Value(GeneralFitData& data, double const* parm, int& ndataused)=0;
-//	Valeur du Xi2 a definir par l'utilisateur (fct virtuelle pure)
-//	a partir des donnees de `data'. l'utilisateur doit egalement
-//	retourner le nombre de points de mesure utilises dans le calcul
-//	du Xi2 (`ndataused').
-//--
-//++
-// inline int     NPar() const
-//	Retourne le nombre de parametres Ai.
-//--
 
 //================================================================
@@ -338,19 +263,9 @@
 //                                Christophe 8/11/93 La Silla
 //                                re-codage C++ 16/01/96 Saclay
-
-//++
-// Class	GeneralFit
-// Lib		Outils++
-// include	generalfit.h
-//
-//	Classe de fit d'une GeneralFunction sur une GeneralFitData
-//--
-
-//////////////////////////////////////////////////////////////////////
-//++
+//////////////////////////////////////////////////////////////////////
+/*!
+  Creation d'une classe de fit pour la `GeneralFunction f'.
+*/
 GeneralFit::GeneralFit(GeneralFunction* f)
-//
-//	Creation d'une classe de fit pour la `GeneralFunction f'.
-//--
   : mNVar         (f->NVar()),
     mNPar         (f->NPar()),
@@ -385,15 +300,14 @@
 }
 
-//++
+/*!
+  Creation d'une classe de fit pour le `GeneralXi2 f'.
+  L'emploi de cette methode n'est pas conseillee car elle
+  calcule automatiquement la derivee 2sd du Xi2 par rapport
+  aux parametres, ce qui entraine un manque de robustesse
+  et qui ne garanti pas que la matrice de covariance soit
+  definie positive (il est possible de surecrire
+  la methode virtuelle Derivee2 pour palier ce probleme).
+*/
 GeneralFit::GeneralFit(GeneralXi2* f)
-//
-//	Creation d'une classe de fit pour le `GeneralXi2 f'.
-//	L'emploi de cette methode n'est pas conseillee car elle
-//	calcule automatiquement la derivee 2sd du Xi2 par rapport
-//	aux parametres, ce qui entraine un manque de robustesse
-//	et qui ne garanti pas que la matrice de covariance soit
-//	definie positive (il est possible de surecrire
-//	la methode virtuelle Derivee2 pour palier ce probleme).
-//--
   : mNVar         (0),
     mNPar         (f->NPar()),
@@ -485,8 +399,5 @@
 }
 
-//++
 GeneralFit::~GeneralFit()
-//
-//--
 {
  delete[] fixParam;
@@ -497,9 +408,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour ecrire les iterations dans le fichier filename
+*/
 void GeneralFit::WriteStep(char *filename)
-//
-//	Pour ecrire les iterations dans le fichier filename
-//--
 {
 
@@ -513,10 +423,9 @@
 }
 
-//++
+/*!
+  Niveau de debug
+  (voir aussi la variable d'environnement PDEBUG_GENERALFIT).
+*/
 void GeneralFit::SetDebug(int level)
-//
-//	Niveau de debug
-//	(voir aussi la variable d'environnement PDEBUG_GENERALFIT).
-//--
 {
  debugLevel = ( level < 0 ) ? 0: level;
@@ -524,9 +433,8 @@
 }
 
-//++
+/*!
+  Nombre maximum d'iterations permis.
+*/
 void GeneralFit::SetMaxStep(int n)
-//
-//	Nombre maximum d'iterations permis.
-//--
 {
  maxStep = ( n <= 1 ) ? 100: n;
@@ -534,19 +442,17 @@
 }
 
-//++
+/*!
+  Facteur de multiplication/division de Lambda selon
+  que le Chi2 a augmente ou diminue.
+*/
 void GeneralFit::SetLambda_Fac(double fac)
-//
-//	Facteur de multiplication/division de Lambda selon
-//	que le Chi2 a augmente ou diminue.
-//--
 {
   Lambda_Fac = (fac>1.) ? fac : 10.;
 }
 
-//++
+/*!
+  Critere de convergence sur le Chi2.
+*/
 void GeneralFit::SetStopChi2(double s)
-//
-//	Critere de convergence sur le Chi2.
-//--
 {
  stopChi2 = ( s <= 0. ) ? 0.01: s;
@@ -554,9 +460,8 @@
 }
 
-//++
+/*!
+  Precision des calculs (cf \ref GeneralFit_Fit "descriptif general").
+*/
 void GeneralFit::SetEps(double ep)
-//
-//	Precision des calculs (cf descriptif general).
-//--
 {
  ep = (ep<=0.) ? EPS_FIT_MIN: ep;
@@ -565,9 +470,8 @@
 }
 
-//++
+/*!
+  Precision des calculs pour le parametre n.
+*/
 void GeneralFit::SetEps(int n,double ep)
-//
-//	Precision des calculs pour le parametre n.
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -576,14 +480,15 @@
 }
 
-//++
+/*!
+  Critere de convergence sur le nombre de stop en chi2
+  dans le cas ou le chi2 augmente de moins de stopchi2
+  (cf \ref GeneralFit_Fit "descriptif general").
+
+  Si nstopmx<=0, alors ce critere de convergence n'est pas applique.
+
+  Si stopchi2<=0, alors la valeur generale mise par SetStopChi2()
+  est utilisee.
+*/
 void GeneralFit::SetStopMx(int nstopmx,double stopchi2)
-//
-//	Critere de convergence sur le nombre de stop en chi2
-//	dans le cas ou le chi2 augmente de moins de stopchi2
-//	(cf descriptif general).
-//	Si nstopmx<=0, alors ce critere de convergence n'est pas applique.
-//	Si stopchi2<=0, alors la valeur generale mise par SetStopChi2()
-//	est utilisee.
-//--
 {
  nStopMx = (nstopmx>0) ? nstopmx : 0;
@@ -593,11 +498,11 @@
 }
 
-//++
+/*!
+  Critere de convergence sur le nombre de stop en chi2
+  dans le cas ou le chi2 diminue (cf \ref GeneralFit_Fit "descriptif general").
+
+  Si nstopl<=0, alors ce critere de convergence n'est pas applique.
+*/
 void GeneralFit::SetStopLent(int nstoplent)
-//
-//	Critere de convergence sur le nombre de stop en chi2
-//	dans le cas ou le chi2 diminue (cf descriptif general).
-//	Si nstopl<=0, alors ce critere de convergence n'est pas applique.
-//--
 {
  nStopLent = (nstoplent>0) ? nstoplent : 0;
@@ -606,11 +511,10 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour changer la fonction a fitter en cours de route
+  (On ne peut passer d'un fit sur une GeneralFunction
+  a un fit sur un GeneralXi2 sans recreer la classe).
+*/
 void GeneralFit::SetFunction(GeneralFunction* f)
-//
-//	Pour changer la fonction a fitter en cours de route
-//	(On ne peut passer d'un fit sur une GeneralFunction
-//	a un fit sur un GeneralXi2 sans recreer la classe).
-//--
 {
  ASSERT( mFuncXi2  == NULL );
@@ -622,11 +526,10 @@
 }
 
-//++
+/*!
+  Pour changer le Xi2 a fitter en cours de route
+  (On ne peut passer d'un fit sur une GeneralFunction
+  a un fit sur un GeneralXi2 sans recreer la classe).
+*/
 void GeneralFit::SetFuncXi2(GeneralXi2* f)
-//
-//	Pour changer le Xi2 a fitter en cours de route
-//	(On ne peut passer d'un fit sur une GeneralFunction
-//	a un fit sur un GeneralXi2 sans recreer la classe).
-//--
 {
  ASSERT( mFunction == NULL );
@@ -638,9 +541,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour connecter une structure de donnees.
+*/
 void GeneralFit::SetData(GeneralFitData* data)
-//
-//	Pour connecter une structure de donnees.
-//--
 {
  ASSERT( data->NVar()==mNVar );
@@ -652,10 +554,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition du parametre "n" a fitter.
+*/
 void GeneralFit::SetParam(int n,double value,double step
                          ,double min,double max)
-//
-//	Definition du parametre "n" a fitter.
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -679,10 +580,9 @@
 }
 
-//++
+/*!
+  Definition du parametre "n" a fitter
+*/
 void GeneralFit::SetParam(int n, string const& name
                         ,double value,double step,double min,double max)
-//
-//	Definition du parametre "n" a fitter
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -692,9 +592,8 @@
 }
 
-//++
+/*!
+  Definition du parametre "n" a fitter
+*/
 void GeneralFit::SetParam(int n,double value)
-//
-//	Definition du parametre "n" a fitter
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -704,10 +603,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition du pas de depart du parametre "n"
+  Si negatif ou nul, parametre fixe.
+*/
 void GeneralFit::SetStep(int n,double step)
-//
-//	Definition du pas de depart du parametre "n"
-//	Si negatif ou nul, parametre fixe.
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -721,14 +619,13 @@
 }
 
-//++
+/*!
+  Definition du pas minimum `val' pour le parametre `i'
+  pouvant etre utilise dans le calcul automatique des derivees
+  (soit de la fonction, soit du Xi2 selon les parametres du fit).
+  Si nul pas de limite, si negatif alors `EPS(i)' (cf SetEps).
+  Inutile dans le cas ou les derivees sont donnees
+  par l'utilisateur.
+*/
 void GeneralFit::SetMinStepDeriv(int i,double val)
-//
-//	Definition du pas minimum `val' pour le parametre `i'
-//	pouvant etre utilise dans le calcul automatique des derivees
-//	(soit de la fonction, soit du Xi2 selon les parametres du fit).
-//	Si nul pas de limite, si negatif alors `EPS(i)' (cf SetEps).
-//	Inutile dans le cas ou les derivees sont donnees
-//	par l'utilisateur.
-//--
 {
  ASSERT(i>=0 && i<mNPar);
@@ -738,10 +635,9 @@
 }
 
-//++
+/*!
+  Definition du pas minimum `val' pour tout les parametres
+  (voir description SetMinStepDeriv ci-dessus).
+*/
 void GeneralFit::SetMinStepDeriv(double val)
-//
-//	Definition du pas minimum `val' pour tout les parametres
-//	(voir description SetMinStepDeriv ci-dessus).
-//--
 {
  if(debugLevel>0) cout<<"SetMinStepDeriv "<<val<<endl;
@@ -750,10 +646,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Definition des bornes du parametre "n"
+  Si max<=min, parametre non-borne.
+*/
 void GeneralFit::SetBound(int n, double min, double max)
-//
-//	Definition des bornes du parametre "n"
-//	Si max<=min, parametre non-borne.
-//--
 {
  ASSERT(n>=0 && n<mNPar && max>min);
@@ -770,9 +665,8 @@
 }
 
-//++
+/*!
+  Pour re-borner le parametre "n" aux bornes par defaut
+*/
 void GeneralFit::SetBound(int n)
-//
-//	Pour re-borner le parametre "n" aux bornes par defaut
-//--
 {
  ASSERT(n>=0 && n<mNPar && maxParam(n)>minParam(n));
@@ -780,9 +674,8 @@
 }
 
-//++
+/*!
+  Pour ne plus borner le parametre "n"
+*/
 void GeneralFit::SetUnBound(int n)
-//
-//	Pour ne plus borner le parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -796,9 +689,8 @@
 }
 
-//++
+/*!
+  Pour ne plus borner tous les parametres
+*/
 void GeneralFit::SetUnBound()
-//
-//	Pour ne plus borner tous les parametres
-//--
 {
  for(int i=0;i<mNPar;i++) SetUnBound(i);
@@ -806,9 +698,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour fixer le parametre "n" a la valeur "v"
+*/
 void GeneralFit::SetFix(int n,double v)
-//
-//	Pour fixer le parametre "n" a la valeur "v"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -825,9 +716,8 @@
 }
 
-//++
+/*!
+  Pour fixer le parametre "n" a la valeur par defaut
+*/
 void GeneralFit::SetFix(int n)
-//
-//	Pour fixer le parametre "n" a la valeur par defaut
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -835,9 +725,8 @@
 }
 
-//++
+/*!
+  Pour liberer le parametre "n"
+*/
 void GeneralFit::SetFree(int n)
-//
-//	Pour liberer le parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -855,9 +744,8 @@
 }
 
-//++
+/*!
+  Pour liberer tous les parametres
+*/
 void GeneralFit::SetFree()
-//
-//	Pour liberer tous les parametres
-//--
 {
  for(int i=0;i<mNPar;i++) SetFree(i);
@@ -865,9 +753,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne la valeur du parametre "n"
+*/
 double GeneralFit::GetParm(int n)
-//
-//	Retourne la valeur du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -875,18 +762,16 @@
 }
 
-//++
+/*!
+  Retourne les valeurs des parametres dans un vecteur.
+*/
 Vector GeneralFit::GetParm()
-//
-//	Retourne les valeurs des parametres dans un vecteur.
-//--
 {
 return Param;
 }
 
-//++
+/*!
+  Retourne la valeur de l'erreur du parametre "n"
+*/
 double GeneralFit::GetParmErr(int n)
-//
-//	Retourne la valeur de l'erreur du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -894,9 +779,8 @@
 }
 
-//++
+/*!
+  Retourne la covariance pour les parametre `i' et `j'
+*/
 double GeneralFit::GetCoVar(int i,int j)
-//
-//	Retourne la covariance pour les parametre `i' et `j'
-//--
 {
  ASSERT(i>=0 && i<mNPar && j>=0 && j<mNPar);
@@ -905,9 +789,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne la valeur du pas du parametre "n"
+*/
 double GeneralFit::GetStep(int n)
-//
-//	Retourne la valeur du pas du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -915,9 +798,8 @@
 }
 
-//++
+/*!
+  Retourne la valeur de la borne superieure du parametre "n"
+*/
 double GeneralFit::GetMax(int n)
-//
-//	Retourne la valeur de la borne superieure du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -925,9 +807,8 @@
 }
 
-//++
+/*!
+  Retourne la valeur de la borne inferieure du parametre "n"
+*/
 double GeneralFit::GetMin(int n)
-//
-//	Retourne la valeur de la borne inferieure du parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -936,9 +817,8 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Impression du status du fit
+*/
 void GeneralFit::PrintStatus()
-//
-//	Impression du status du fit
-//--
 {
  cout<<"GeneralFit::PrintStatus"
@@ -962,9 +842,8 @@
 }
 
-//++
+/*!
+  Impression des resultats du fit
+*/
 void GeneralFit::PrintFit()
-//
-//	Impression des resultats du fit
-//--
 {
  cout<<"PrintFit: Chi2="<<Chi2
@@ -978,9 +857,8 @@
 }
 
-//++
+/*!
+  Impression des informations relatives au parametre "n"
+*/
 void GeneralFit::PrintParm(int n)
-//
-//	Impression des informations relatives au parametre "n"
-//--
 {
  ASSERT(n>=0 && n<mNPar);
@@ -999,9 +877,8 @@
 }
 
-//++
+/*!
+  Impression des informations relatives a tous les parametres
+*/
 void GeneralFit::PrintParm()
-//
-//	Impression des informations relatives a tous les parametres
-//--
 {
  cout<<"*** Parametres : fix bnd : par err : step min max : eps dmin\n";
@@ -1011,89 +888,85 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Methode de fit.
+  \anchor GeneralFit_Fit
+  \verbatim
+     Fonction de fit de la fonction f(x,y,z,...:p1,p2,...,pn)
+             sur les donnees x[i],y[i],z[i],...,F[i],ErrF[i]
+     - Methode:   fit des moindres carres dans le cas non lineaire
+     - Reference: Statistical and Computational Methods in Data Analysis
+                 Siegmund Brandt, North-Holland 1970  p 204-206.
+                 Introduction des limites pour la variation des parametres (cmv).
+                 Increment des parametres selon la methode de Levenberg-Marquardt
+     (Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
+      Levenberg-Marquardt Method p683)
+     - Gestion des parametres bornes:
+        si p est un parametre borne entre pmin et pmax, le parametre fitte est q
+        tel que     q = tang((p-C)/D)    ....   p = C + D*atan(q)
+        ou   C = (pmin+pmax)/2.  et   D = (pmax-pmin)/Pi
+        On a  dq = (1+q**2)/D * dp    ....   dp = D/(1+q**2) * dq
+        et    dF/dq = dF/dp * dp/dq = D/(1+q**2) * dF/dp
+              dF/dp = dF/dq * dq/dp = (1+q**2)/D * dF/dp
+                                      ^ q
+                      |               |              *| "tang()"
+                      |               |              *|
+                      |               |              *|
+                      |               |             * |
+                      |               |            *  |
+                      |               |          *    |
+                      |               |       *       |
+                  Pmin|              C|   *           |Pmax
+        --------------|---------------*---------------|--------------> p
+                 -Pi/2|           *   |0              |Pi/2
+                      |       *       |               |
+                      |    *          |               |
+                      |  *            |               |
+                      | *             |               |
+                      |*              |               |
+                      |*              |               |
+                      |*              |               |
+                      <------------------- D --------->
+   
+     - Criteres de convergence, arrets standards:
+       - SOIT: le Chi2 est descendu de moins de stopChi2
+               entre l'iteration n et n+1
+               (stopChi2 est change par SetStopChi2)
+       - SOIT: 1. le chi2 est remonte de moins de stopChi2SMx et
+               2. les parametres libres ont varie de moins de Eps(i)
+                  pendant les nStopmx dernieres iterations
+               Si nStopmx<=0, alors ce critere n'est pas applique (def=3).
+               (nStopmx,stopChi2SMx sont changes par SetStopMx, Eps par SetEps)
+   
+     - Criteres de convergence, arrets par non-convergence:
+       - plus de "maxStep" iterations.
+   
+     - Criteres de convergence, arrets speciaux:
+       - Si l'utilisateur a demande explicitement la methode d'arret
+         "SetStopLent()", arret si :
+           1. le Chi2 est descendu et
+           2. les parametres libres ont varies de moins de Eps
+              pendant les nStopLent dernieres iterations.
+              (nStopLent est change par SetStopLent, Eps par SetEps)
+   
+     - Remarques diverses:
+        Les points avec erreurs <=0 ne sont pas utilises dans le fit.
+        Les bornes des parametres ne peuvent etre atteintes
+     - entrees:
+        la fonction est definie par une classe GeneralFunction
+        les donnees sont passees par une classe GeneralFitData
+        le nombre de parametres et le nombre de variables doivent etre
+           coherents entre GeneralFunction GeneralFitData GeneralFit
+     - Return: 
+          la function elle meme retourne le nombre d'iterations  du fit si succes
+          -1  : si le nombre de degre de liberte est <0
+          -10 : si l'inversion de la matrice des erreurs n'a pas ete possible
+          -11 : si un element diagonal de la matrice des covariances est <=0
+          -20 : si le fit n'a pas converge (nstep>nNstepMX)
+          -100-N : si le parametre "N" est initialise hors limites
+          -200-N : si le parametre "N" atteint sa limite inferieure
+          -300-N : si le parametre "N" atteint sa limite superieure
+  \endverbatim
+*/
 int GeneralFit::Fit()
-//
-//--
-//++
-//|  Fonction de fit de la fonction f(x,y,z,...:p1,p2,...,pn)
-//|          sur les donnees x[i],y[i],z[i],...,F[i],ErrF[i]
-//|  - Methode:   fit des moindres carres dans le cas non lineaire
-//|  - Reference: Statistical and Computational Methods in Data Analysis
-//|              Siegmund Brandt, North-Holland 1970  p 204-206.
-//|              Introduction des limites pour la variation des parametres (cmv).
-//|              Increment des parametres selon la methode de Levenberg-Marquardt
-//|  (Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
-//|   Levenberg-Marquardt Method p683)
-//--
-//++
-//|  - Gestion des parametres bornes:
-//|     si p est un parametre borne entre pmin et pmax, le parametre fitte est q
-//|     tel que     q = tang((p-C)/D)    ....   p = C + D*atan(q)
-//|     ou   C = (pmin+pmax)/2.  et   D = (pmax-pmin)/Pi
-//|     On a  dq = (1+q**2)/D * dp    ....   dp = D/(1+q**2) * dq
-//|     et    dF/dq = dF/dp * dp/dq = D/(1+q**2) * dF/dp
-//|           dF/dp = dF/dq * dq/dp = (1+q**2)/D * dF/dp
-//|                                   ^ q
-//|                   |               |              *| "tang()"
-//|                   |               |              *|
-//|                   |               |              *|
-//|                   |               |             * |
-//|                   |               |            *  |
-//|                   |               |          *    |
-//|                   |               |       *       |
-//|               Pmin|              C|   *           |Pmax
-//|     --------------|---------------*---------------|--------------> p
-//|              -Pi/2|           *   |0              |Pi/2
-//|                   |       *       |               |
-//|                   |    *          |               |
-//|                   |  *            |               |
-//|                   | *             |               |
-//|                   |*              |               |
-//|                   |*              |               |
-//|                   |*              |               |
-//|                   <------------------- D --------->
-//--
-//++
-//|  - Criteres de convergence, arrets standards:
-//|    - SOIT: le Chi2 est descendu de moins de stopChi2
-//|            entre l'iteration n et n+1
-//|            (stopChi2 est change par SetStopChi2)
-//|    - SOIT: 1. le chi2 est remonte de moins de stopChi2SMx et
-//|            2. les parametres libres ont varie de moins de Eps(i)
-//|               pendant les nStopmx dernieres iterations
-//|            Si nStopmx<=0, alors ce critere n'est pas applique (def=3).
-//|            (nStopmx,stopChi2SMx sont changes par SetStopMx, Eps par SetEps)
-//|
-//|  - Criteres de convergence, arrets par non-convergence:
-//|    - plus de "maxStep" iterations.
-//|
-//|  - Criteres de convergence, arrets speciaux:
-//|    - Si l'utilisateur a demande explicitement la methode d'arret
-//|      "SetStopLent()", arret si :
-//|        1. le Chi2 est descendu et
-//|        2. les parametres libres ont varies de moins de Eps
-//|           pendant les nStopLent dernieres iterations.
-//|           (nStopLent est change par SetStopLent, Eps par SetEps)
-//|
-//--
-//++
-//|  - Remarques diverses:
-//|     Les points avec erreurs <=0 ne sont pas utilises dans le fit.
-//|     Les bornes des parametres ne peuvent etre atteintes
-//|  - entrees:
-//|     la fonction est definie par une classe GeneralFunction
-//|     les donnees sont passees par une classe GeneralFitData
-//|     le nombre de parametres et le nombre de variables doivent etre
-//|        coherents entre GeneralFunction GeneralFitData GeneralFit
-//|  - Return: 
-//|       la function elle meme retourne le nombre d'iterations  du fit si succes
-//|       -1  : si le nombre de degre de liberte est <0
-//|       -10 : si l'inversion de la matrice des erreurs n'a pas ete possible
-//|       -11 : si un element diagonal de la matrice des covariances est <=0
-//|       -20 : si le fit n'a pas converge (nstep>nNstepMX)
-//|       -100-N : si le parametre "N" est initialise hors limites
-//|       -200-N : si le parametre "N" atteint sa limite inferieure
-//|       -300-N : si le parametre "N" atteint sa limite superieure
-//--
 {
  volatile double oldChi2;
@@ -1385,12 +1258,11 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Recalcul du Chi2 a partir des parametres courants (`par==NULL')
+  ou a partir du tableau de parametres `par'.
+  Retourne le chi2 et le nombre de degres de liberte.
+  Si nddl<0 probleme.
+*/
 double GeneralFit::ReCalChi2(int& nddl, double *par)
-//
-//	Recalcul du Chi2 a partir des parametres courants (`par==NULL')
-//	ou a partir du tableau de parametres `par'.
-//	Retourne le chi2 et le nombre de degres de liberte.
-//	Si nddl<0 probleme.
-//--
 {
 double c2 = -1.;
@@ -1430,15 +1302,14 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne une structure ``GeneralFitData'' contenant
+  les residus du fit (val-func) pour les points du fit.
+  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 GeneralFit::DataResidus(bool clean)
-//
-//	Retourne une structure ``GeneralFitData'' contenant
-//	les residus du fit (val-func) pour les points du fit.
-//	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.
-//--
 {
 if(!mData || !mFunction)
@@ -1451,11 +1322,10 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne une structure ``GeneralFitData'' contenant
+  les valeurs de la fonction fittee pour les points du fit.
+  (voir commentaires pour ``clean'' dans ``DataResidus'')
+*/
 GeneralFitData GeneralFit::DataFunction(bool clean)
-//
-//	Retourne une structure ``GeneralFitData'' contenant
-//	les valeurs de la fonction fittee pour les points du fit.
-//	(voir commentaires pour ``clean'' dans ``DataResidus'')
-//--
 {
 if(!mData || !mFunction)
@@ -1468,10 +1338,9 @@
 
 //////////////////////////////////////////////////////////////////////
-//++
+/*!
+  Imprime le commentaire lie a l'erreur rc retournee par Fit()
+  (voir le commentaire de la methode `Fit()')
+*/
 void GeneralFit::PrintFitErr(int rc)
-//
-//	Imprime le commentaire lie a l'erreur rc retournee par Fit()
-//	(voir le commentaire de la methode `Fit()')
-//--
 {
 int n;
@@ -1632,7 +1501,11 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  C = (min+max)/2
+  D = (max-min)/Pi
+  \endverbatim
+*/
 void GeneralFit::Set_Bound_C_D(int i)
-// C = (min+max)/2
-// D = (max-min)/Pi
 {
   // ASSERT(i>=0 && i<mNPar);
@@ -1656,6 +1529,10 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  tr = tan( (p-C)/D )
+  \endverbatim
+*/
 double GeneralFit::p_vers_tr(int i,double p)
-// tr = tan( (p-C)/D )
 {
  // ASSERT(i>=0 && i<mNPar);
@@ -1687,6 +1564,10 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  p = C+D*atan(tr)
+  \endverbatim
+*/
 double GeneralFit::tr_vers_p(int i,double tr)
-// p = C+D*atan(tr)
 {
  // ASSERT(i>=0 && i<mNPar);
@@ -1718,7 +1599,11 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  dtr = (1+tr**2)/D * dp = (1+tan( (p-C)/D )**2)/D * dp = coeff * dp
+  attention: df/dp = (1+tr**2)/D * dF/dtr = coeff * dF/dtr
+  \endverbatim
+*/
 double GeneralFit::c_dp_vers_dtr(int i,double tr)
-// dtr = (1+tr**2)/D * dp = (1+tan( (p-C)/D )**2)/D * dp = coeff * dp
-// attention: df/dp = (1+tr**2)/D * dF/dtr = coeff * dF/dtr
 {
  // ASSERT(i>=0 && i<mNPar);
@@ -1750,7 +1635,11 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  dp = D/(1+tr**2) * dtr = coeff * dtr
+  attention: df/dtr = D/(1+tr**2) * dF/dp = coeff * dF/dp
+  \endverbatim
+*/
 double GeneralFit::c_dtr_vers_dp(int i,double tr)
-// dp = D/(1+tr**2) * dtr = coeff * dtr
-// attention: df/dtr = D/(1+tr**2) * dF/dp = coeff * dF/dp
 {
   // ASSERT(i>=0 && i<mNPar);
@@ -1776,10 +1665,14 @@
 
 //////////////////////////////////////////////////////////////////////
+/*!
+  \verbatim
+  1-/ Redefinit dp pour qu'il soit superieur a minStepDeriv
+  2-/ Redefinit dp pour que p+/-dp reste dans les limites (parametre borne)
+  Si hors limites alors:
+      p-dp <= min_p : dp = (p-min_p)*dist
+      p+dp >= max_p : dp = (max_p-p)*dist
+  \endverbatim
+*/
 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)
-// Si hors limites alors:
-//     p-dp <= min_p : dp = (p-min_p)*dist
-//     p+dp >= max_p : dp = (max_p-p)*dist
 {
  int nchanged = 0;
@@ -1826,57 +1719,2 @@
 }
 
-
-//////////////////////////////////////////////////////////////////////
-// Rappel des inline functions pour commentaires
-//++
-// inline double   GetChi2()
-//	Retourne le Chi2
-//--
-//++
-// inline double   GetChi2Red() const
-//	Retourne le Chi2 reduit
-//--
-//++
-// inline int      GetNddl()    const
-//	Retourne le nombre de degres de liberte
-//--
-//++
-// inline int      GetNStep()   const
-//	Retourne le nombre d'iterations
-//--
-//++
-// inline int      GetNVar()    const
-//	Retourne le nombre de variables
-//--
-//++
-// inline int      GetNPar()    const
-//	Retourne le nombre de parametres
-//--
-//++
-// inline int      GetNFree()   const
-//	Retourne le nombre de parametres libres
-//--
-//++
-// inline int      GetNBound()  const
-//	Retourne le nombre de parametres bornes
-//--
-//++
-// inline int      GetNStop()   const
-//	Retourne le nstop de convergence
-//--
-//++
-// inline int      GetNStopLent()   const
-//	Retourne le nstop de convergence lente.
-//--
-//++
-// inline double   GetEps(int i)
-//	Retourne la precision de convergence pour le parametre i.
-//--
-//++
-// inline GeneralFunction*  GetFunction()
-//	Retourne le pointeur sur la GeneralFunction utilisee.
-//--
-//++
-// inline GeneralFitData*   GetGData()
-//	Retourne le pointeur sur la GeneralFitData utilisee.
-//--
Index: trunk/SophyaLib/NTools/generalfit.h
===================================================================
--- trunk/SophyaLib/NTools/generalfit.h	(revision 896)
+++ trunk/SophyaLib/NTools/generalfit.h	(revision 914)
@@ -13,4 +13,9 @@
 //================================================================
 
+
+/*!
+  Classe de fonctions parametrees a plusieurs variables:
+  \f$ F[x1,x2,x3,...:a1,a2,a3,...] \f$
+*/
 class GeneralFunction {
 public:
@@ -18,4 +23,5 @@
   virtual ~GeneralFunction();
 
+  //! Valeur de la fonction a definir par l'utilisateur (fct virtuelle pure)
   virtual double Value(double const xp[], double const* parm)=0;
   virtual double Val_Der(double const xp[], double const* parm
@@ -25,10 +31,12 @@
   void SetDeltaParm(double const* dparam);
 
+  //! Retourne le nombre de variables Xi
   inline int     NVar() const {return mNVar;}
+  //! Retourne le nombre de parametres Ai
   inline int     NPar() const {return mNPar;}
 
 protected:
-  const int mNVar;  // nombre de variables f(x,y,z,...)
-  const int mNPar;  // nombre de parametres
+  const int mNVar;  //!< nombre de variables f(x,y,z,...)
+  const int mNPar;  //!< nombre de parametres
 
   double *deltaParm;
@@ -40,4 +48,12 @@
 //================================================================
 
+/*!
+  Classe de fonctions parametrees a plusieurs variables
+  derivant de ``GeneralFunction''. Permet de definir
+  une fonction a fiter sans passer par une classe derivee
+  en utilisant l'ecriture courante du C. La fonction
+  retournant les derivees par rapport aux parametres du fit
+  peut etre egalement fournie (optionnel).
+*/
 class GeneralFunc : public GeneralFunction {
 public:
@@ -62,4 +78,8 @@
 class GeneralFitData;
 
+/*!
+  Classe de Xi2 a plusieurs parametres :
+  \f$ Xi2[a1,a2,a3,...] \f$
+*/
 class GeneralXi2 {
 public:
@@ -67,4 +87,10 @@
   virtual ~GeneralXi2();
 
+  /*!
+  Valeur du Xi2 a definir par l'utilisateur (fct virtuelle pure)
+  a partir des donnees de `data'. l'utilisateur doit egalement
+  retourner le nombre de points de mesure utilises dans le calcul
+  du Xi2 (`ndataused').
+  */
   virtual double Value(GeneralFitData& data, double* parm, int& ndataused)=0;
   virtual double Derivee(GeneralFitData& data, int i, double* parm);
@@ -74,8 +100,9 @@
   void SetDeltaParm(double const* dparam);
 
+  //! Retourne le nombre de parametres Ai.
   inline int     NPar() const {return mNPar;}
 
 protected:
-  const int mNPar;  // nombre de parametres
+  const int mNPar;  //!< nombre de parametres
 
   double *deltaParm;
@@ -86,4 +113,5 @@
 //================================================================
 
+//! Classe de fit d'une GeneralFunction sur une GeneralFitData
 class GeneralFit {
 public:
@@ -129,19 +157,32 @@
   double          GetMax(int n);
   double          GetMin(int n);
+  //! Retourne le Chi2
   inline double   GetChi2()    const {return Chi2;};
+  //! Retourne le Chi2 reduit
   inline double   GetChi2Red() const {
                         if(mNddl<=0) return (double) mNddl;
                         return Chi2/(double) mNddl;
                                      };
+  //! Retourne la precision de convergence pour le parametre i.
   inline double   GetEps(int i) const {return Eps(i);};
+  //! Retourne le nombre de degres de liberte
   inline int      GetNddl()    const {return mNddl;};
+  //! Retourne le nombre d'iterations
   inline int      GetNStep()   const {return nStep;};
+  //! Retourne le nombre de variables
   inline int      GetNVar()    const {return mNVar;};
+  //! Retourne le nombre de parametres
   inline int      GetNPar()    const {return mNPar;};
+  //! Retourne le nombre de parametres libres
   inline int      GetNFree()   const {return mNParFree;};
+  //! Retourne le nombre de parametres bornes
   inline int      GetNBound()  const {return mNParBound;};
+  //! Retourne le nstop de convergence
   inline int      GetNStop()   const {return nStop;};
+  //! Retourne le nstop de convergence lente.
   inline int      GetNStopLent()   const {return nStopLent;};
+  //! Retourne le pointeur sur la GeneralFunction utilisee.
   inline GeneralFunction*  GetFunction() const {return mFunction;};
+  //! Retourne le pointeur sur la GeneralFitData utilisee.
   inline GeneralFitData*   GetGData() const {return mData;};
 
@@ -158,9 +199,9 @@
 
 protected:
-  int             mNtry;       // numero d'appel de la routine de fit.
-  int             mNVar;       // nombre de variables f(x,y,z,...)
-  int             mNPar;       // nombre de parametres
-  int             mNParFree;   // nombre de parametres libres
-  int             mNParBound;  // nombre de parametres bornes
+  int             mNtry;       //!< numero d'appel de la routine de fit.
+  int             mNVar;       //!< nombre de variables f(x,y,z,...)
+  int             mNPar;       //!< nombre de parametres
+  int             mNParFree;   //!< nombre de parametres libres
+  int             mNParBound;  //!< nombre de parametres bornes
   GeneralFunction*  mFunction;
   GeneralXi2*       mFuncXi2;
