Index: trunk/SophyaLib/HiStats/histos.cc
===================================================================
--- trunk/SophyaLib/HiStats/histos.cc	(revision 763)
+++ trunk/SophyaLib/HiStats/histos.cc	(revision 914)
@@ -1,4 +1,4 @@
 //
-// $Id: histos.cc,v 1.1.1.1 2000-03-02 16:51:32 ansari Exp $
+// $Id: histos.cc,v 1.2 2000-04-13 16:04:11 ansari Exp $
 //
 
@@ -13,21 +13,7 @@
 #include "generalfit.h"
 
-//++
-// Class	Histo
-// Lib	Outils++ 
-// include	histos.h
-//
-//	Classe d'histogrammes 1D
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-/********* Methode *********/
-//++
+/********* Methode *********/
+/*! Constructeur par defaut */
 Histo::Histo()
-//
-//--
 : data(NULL), err2(NULL),
   under(0), over(0), nHist(0), nEntries(0),
@@ -39,8 +25,6 @@
 
 /********* Methode *********/
-//++
+/*! Constructeur d'un histo de nBin bins allant de xMin a xMax */
 Histo::Histo(float xMin, float xMax, int nBin)
-//
-//--
 : data(new float[nBin]), err2(NULL),
   under(0), over(0), nHist(0), nEntries(0),
@@ -53,8 +37,6 @@
 
 /********* Methode *********/
-//++
+/*! Constructeur par copie */
 Histo::Histo(const Histo& H)
-//
-//--
 : data(new float[H.bins]), err2(NULL),
   under(H.under), over(H.over), nHist(H.nHist), nEntries(H.nEntries),
@@ -71,4 +53,5 @@
 
 /********* Methode *********/
+/*! Gestion de la des-allocation */
 void Histo::Delete()
 {
@@ -81,4 +64,5 @@
 
 /********* Methode *********/
+/*! Destructeur */
 Histo::~Histo()
 {
@@ -86,14 +70,9 @@
 }
 
-//++
-// Titre	Methodes
-//--
-
-/********* Methode *********/
-//++
+/********* Methode *********/
+/*!
+  Remise a zero
+*/
 void Histo::Zero()
-//
-//	Remise a zero
-//--
 {
   memset(data, 0, bins*sizeof(float));
@@ -105,9 +84,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Pour avoir le calcul des erreurs
+*/
 void Histo::Errors()
-//
-//	Pour avoir le calcul des erreurs
-//--
 {
  if( bins > 0 ) {
@@ -118,8 +96,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur egal
+*/
 Histo& Histo::operator = (const Histo& h)
-//
-//--
 {
   if(this == &h) return *this;
@@ -145,8 +123,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur de multiplication par une constante
+*/
 Histo& Histo::operator *= (double b)
-//
-//--
 {
 double b2 = b*b;
@@ -162,8 +140,8 @@
 }
 
-//++
+/*!
+  Operateur de division par une constante
+*/
 Histo& Histo::operator /= (double b)
-//
-//--
 {
 if (b==0.) THROW(inconsistentErr);
@@ -180,8 +158,8 @@
 }
 
-//++
+/*!
+  Operateur d'addition d'une constante
+*/
 Histo& Histo::operator += (double b)
-//
-//--
 {
 for(int i=0;i<bins;i++) data[i] += b;
@@ -193,8 +171,8 @@
 }
 
-//++
+/*!
+  Operateur de soustraction d'une constante
+*/
 Histo& Histo::operator -= (double b)
-//
-//--
 {
 for(int i=0;i<bins;i++) data[i] -= b;
@@ -207,8 +185,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur H2 = H1 * b
+*/
 Histo operator * (const Histo& a, double b)
-//
-//--
 {
   Histo result(a);
@@ -216,8 +194,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b * H1
+*/
 Histo operator * (double b, const Histo& a)
-//
-//--
 {
   Histo result(a);
@@ -225,8 +203,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 / b
+*/
 Histo operator / (const Histo& a, double b)
-//
-//--
 {
   Histo result(a);
@@ -234,8 +212,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 + b
+*/
 Histo operator + (const Histo& a, double b)
-//
-//--
 {
   Histo result(a);
@@ -243,8 +221,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b + H1
+*/
 Histo operator + (double b, const Histo& a)
-//
-//--
 {
   Histo result(a);
@@ -252,8 +230,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 - b
+*/
 Histo operator - (const Histo& a, double b)
-//
-//--
 {
   Histo result(a);
@@ -261,8 +239,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b - H1
+*/
 Histo operator - (double b, const Histo& a)
-//
-//--
 {
   Histo result(a);
@@ -272,8 +250,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur H += H1
+*/
 Histo& Histo::operator += (const Histo& a)
-//
-//--
 {
 if(bins!=a.bins) THROW(sizeMismatchErr);
@@ -291,8 +269,8 @@
 }
 
-//++
+/*!
+  Operateur H -= H1
+*/
 Histo& Histo::operator -= (const Histo& a)
-//
-//--
 {
 if(bins!=a.bins) THROW(sizeMismatchErr);
@@ -310,8 +288,8 @@
 }
 
-//++
+/*!
+  Operateur H *= H1
+*/
 Histo& Histo::operator *= (const Histo& a)
-//
-//--
 {
 if(bins!=a.bins) THROW(sizeMismatchErr);
@@ -331,8 +309,8 @@
 }
 
-//++
+/*!
+  Operateur H /= H1
+*/
 Histo& Histo::operator /= (const Histo& a)
-//
-//--
 {
 if(bins!=a.bins) THROW(sizeMismatchErr);
@@ -359,8 +337,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Operateur H = H1 + H2
+*/
 Histo operator + (const Histo& a, const Histo& b)
-//
-//--
 {
 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
@@ -369,8 +347,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 - H2
+*/
 Histo operator - (const Histo& a, const Histo& b)
-//
-//--
 {
 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
@@ -379,8 +357,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 * H2
+*/
 Histo operator * (const Histo& a, const Histo& b)
-//
-//--
 {
 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
@@ -389,8 +367,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 / H2
+*/
 Histo operator / (const Histo& a, const Histo& b)
-//
-//--
 {
 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
@@ -400,9 +378,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage d'un tableau avec la valeur des abscisses
+*/
 void Histo::GetAbsc(Vector &v)
-//
-//	Remplissage d'un tableau avec la valeur des abscisses
-//--
 {
 v.Realloc(bins);
@@ -411,9 +388,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec la valeur du contenu
+*/
 void Histo::GetValue(Vector &v)
-//
-//	Remplissage d'un tableau avec la valeur du contenu
-//--
 {
 v.Realloc(bins);
@@ -422,9 +398,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec la valeur des erreurs au carre
+*/
 void Histo::GetError2(Vector &v)
-//
-//	Remplissage d'un tableau avec la valeur des erreurs au carre
-//--
 {
 v.Realloc(bins);
@@ -434,9 +409,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec la valeur des erreurs
+*/
 void Histo::GetError(Vector &v)
-//
-//	Remplissage d'un tableau avec la valeur des erreurs
-//--
 {
 v.Realloc(bins);
@@ -447,9 +421,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage du contenu de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutValue(Vector &v, int ierr)
-//
-//	Remplissage du contenu de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -461,9 +434,8 @@
 }
 
-//++
+/*!
+  Addition du contenu de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutValueAdd(Vector &v, int ierr)
-//
-//	Addition du contenu de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -475,9 +447,8 @@
 }
 
-//++
+/*!
+  Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutError2(Vector &v)
-//
-//	Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -487,9 +458,8 @@
 }
 
-//++
+/*!
+  Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutError2Add(Vector &v)
-//
-//	Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -499,9 +469,8 @@
 }
 
-//++
+/*!
+  Remplissage des erreurs de l'histo avec les valeurs d'un vecteur
+*/
 void Histo::PutError(Vector &v)
-//
-//	Remplissage des erreurs de l'histo avec les valeurs d'un vecteur
-//--
 {
 if(v.NElts()<bins) THROW(sizeMismatchErr);
@@ -513,9 +482,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Addition du contenu de l'histo pour abscisse x poids w
+*/
 void Histo::Add(float x, float w)
-//
-//	Addition du contenu de l'histo pour abscisse x poids w
-//--
 {
   int numBin = FindBin(x);
@@ -531,9 +499,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Addition du contenu de l'histo bin numBin poids w
+*/
 void Histo::AddBin(int numBin, float w)
-//
-//	Addition du contenu de l'histo bin numBin poids w
-//--
 {
   if (numBin<0) under += w;
@@ -548,9 +515,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage du contenu de l'histo pour abscisse x poids w
+*/
 void Histo::SetBin(float x, float w)
-//
-//	Remplissage du contenu de l'histo pour abscisse x poids w
-//--
 {
   int numBin = FindBin(x);
@@ -559,9 +525,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage du contenu de l'histo pour numBin poids w
+*/
 void Histo::SetBin(int numBin, float w)
-//
-//	Remplissage du contenu de l'histo pour numBin poids w
-//--
 {
   if (numBin<0) under = w;
@@ -575,9 +540,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage des erreurs au carre pour abscisse x
+*/
 void Histo::SetErr2(float x, double e2)
-//
-//	Remplissage des erreurs au carre pour abscisse x
-//--
 {
   int numBin = FindBin(x);
@@ -586,9 +550,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage des erreurs au carre pour numBin poids
+*/
 void Histo::SetErr2(int numBin, double e2)
-//
-//	Remplissage des erreurs au carre pour numBin poids
-//--
 {
   if( err2==NULL) return;
@@ -598,9 +561,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage des erreurs pour abscisse x
+*/
 void Histo::SetErr(float x, float e)
-//
-//	Remplissage des erreurs pour abscisse x
-//--
 {
 SetErr2(x, (double) e*e);
@@ -608,9 +570,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplissage des erreurs pour numBin
+*/
 void Histo::SetErr(int numBin, float e)
-//
-//	Remplissage des erreurs pour numBin
-//--
 {
 SetErr2(numBin, (double) e*e);
@@ -618,9 +579,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Numero du bin ayant le contenu maximum
+*/
 int Histo::IMax() const
-//
-//	Numero du bin ayant le contenu maximum
-//--
 {
   int imx=0;
@@ -633,9 +593,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Numero du bin ayant le contenu minimum
+*/
 int Histo::IMin() const
-//
-//	Numero du bin ayant le contenu minimum
-//--
 {
   int imx=0;
@@ -648,9 +607,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur le contenu maximum
+*/
 float Histo::VMax() const
-//
-//	Valeur le contenu maximum
-//--
 {
   float mx=data[0];
@@ -661,9 +619,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur le contenu minimum
+*/
 float Histo::VMin() const
-//
-//	Valeur le contenu minimum
-//--
 {
   float mx=data[0];
@@ -674,9 +631,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur moyenne
+*/
 float Histo::Mean() const
-//
-//	Valeur moyenne
-//--
 {
   double n = 0;
@@ -691,9 +647,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur du sigma
+*/
 float Histo::Sigma() const
-//
-//	Valeur du sigma
-//--
 {
   double n = 0;
@@ -714,9 +669,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne calculee entre les bin il et ih
+*/
 float Histo::MeanLH(int il,int ih) const
-//
-//	Valeur de la moyenne calculee entre les bin il et ih
-//--
 {
   if( ih < il ) { il = 0; ih = bins-1; }
@@ -734,9 +688,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne calculee entre les bin il et ih
+*/
 float Histo::SigmaLH(int il,int ih) const
-//
-//	Valeur de la moyenne calculee entre les bin il et ih
-//--
 {
   if( ih < il ) { il = 0; ih = bins - 1; }
@@ -759,9 +712,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne calculee entre x0-dx et x0+dx
+*/
 float Histo::Mean(float x0, float dx) const
-//
-//	Valeur de la moyenne calculee entre x0-dx et x0+dx
-//--
 {
   double sdata = 0;
@@ -780,9 +732,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur du sigma calcule entre x0-dx et x0+dx
+*/
 float Histo::Sigma(float x0, float dx) const
-//
-//	Valeur du sigma calcule entre x0-dx et x0+dx
-//--
 {
   double sx = 0;
@@ -804,9 +755,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne et du sigma nettoyes
+*/
 float Histo::CleanedMean(float& sigma) const
-//
-//	Valeur de la moyenne et du sigma nettoyes
-//--
 {
   if (!nHist) return 0;
@@ -825,9 +775,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Valeur de la moyenne nettoyee
+*/
 float Histo::CleanedMean() const
-//
-//	Valeur de la moyenne nettoyee
-//--
 {
   if (!nHist) return 0;
@@ -837,9 +786,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Retourne le nombre de bins non-nul
+*/
 int Histo::BinNonNul() const
-//
-//	Retourne le nombre de bins non-nul
-//--
 {
 int non=0;
@@ -849,9 +797,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Retourne le nombre de bins ayant une erreur non-nulle
+*/
 int Histo::ErrNonNul() const
-//
-//	Retourne le nombre de bins ayant une erreur non-nulle
-//--
 {
 if(err2==NULL) return -1;
@@ -862,10 +809,9 @@
 
 /********* Methode *********/
-//++
+/*!
+  Renvoie le numero de bin tel que il y ait "per" pourcent entrees
+  entre le bin 0 et ce bin (y compris le contenu de ce bin).
+*/
 int Histo::BinPercent(float per) const
-//
-//	Renvoie le numero de bin tel que il y ait "per" pourcent entrees
-//	entre le bin 0 et ce bin (y compris le contenu de ce bin).
-//--
 {
 double n = nHist*per;
@@ -881,16 +827,17 @@
 
 /********* Methode *********/
-//++
+/*!
+  Renvoie les numeros de bins imin,imax (0=<i<bins) tels que:
+  \verbatim
+       notons I = bin contenant l'abscisse x
+              N1 = nombre d'entrees entre bin 0 et I compris
+              N2 = nombre d'entrees entre bin I et bins-1 compris
+       imin = bin tel que nombre d'entrees entre imin et I = N1 * per
+       imax = bin tel que nombre d'entrees entre I et imax = N2 * per
+     Return: <0 si echec
+             min(I-imin,imax-I) si ok
+  \endverbatim
+*/
 int Histo::BinPercent(float x,float per,int& imin,int& imax)
-//
-//	Renvoie les numeros de bins imin,imax (0=<i<bins) tels que:
-//|    notons I = bin contenant l'abscisse x
-//|           N1 = nombre d'entrees entre bin 0 et I compris
-//|           N2 = nombre d'entrees entre bin I et bins-1 compris
-//|    imin = bin tel que nombre d'entrees entre imin et I = N1 * per
-//|    imax = bin tel que nombre d'entrees entre I et imax = N2 * per
-//|  Return: <0 si echec
-//|          min(I-imin,imax-I) si ok
-//--
 {
 imin = imax = -1;
@@ -917,9 +864,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Idem precedent mais renvoie xmin et xmax
+*/
 int Histo::BinPercent(float x,float per,float& xmin,float& xmax)
-//
-//	Idem precedent mais renvoie xmin et xmax
-//--
 {
 xmin = xmax = 0.;
@@ -931,10 +877,9 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplace l'histogramme par son integrale normalise a norm:
+  si norm <= 0 : pas de normalisation, integration seule
+*/
 void Histo::HInteg(float norm)
-//
-//	Remplace l'histogramme par son integrale normalise a norm:
-//	si norm <= 0 : pas de normalisation, integration seule
-//--
 {
 if(bins>1)
@@ -952,9 +897,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Remplace l'histogramme par sa derivee
+*/
 void Histo::HDeriv()
-//
-//	Remplace l'histogramme par sa derivee
-//--
 {
 if( bins <= 1 ) return;
@@ -970,9 +914,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Pour rebinner l'histogramme sur nbinew bins
+*/
 void Histo::HRebin(int nbinew)
-//
-//	Pour rebinner l'histogramme sur nbinew bins
-//--
 {
   if( nbinew <= 0 ) return;
@@ -1023,13 +966,12 @@
 
 /********* Methode *********/
-//++
+/*!
+  Retourne le nombre de maxima locaux, la valeur du maximum (maxi)
+  et sa position (imax), ainsi que la valeur du second maximum
+  local (maxn) et sa position (imaxn).
+  Attention: si un maximum a la meme valeur sur plusieurs bins
+  consecutifs, le bin le plus a droite est pris.
+*/
 int Histo::MaxiLocal(float& maxi,int& imax,float& maxn,int& imaxn)
-//
-//	Retourne le nombre de maxima locaux, la valeur du maximum (maxi)
-//	et sa position (imax), ainsi que la valeur du second maximum
-//	local (maxn) et sa position (imaxn).
-//	Attention: si un maximum a la meme valeur sur plusieurs bins
-//	consecutifs, le bin le plus a droite est pris.
-//--
 {
 int nml = 0;
@@ -1064,11 +1006,10 @@
 
 /********* Methode *********/
-//++
+/*!
+  Fit de la position du maximum de l'histo par un polynome
+  de degre `degree' a `frac' pourcent du maximum.
+  L'histo est suppose etre remplit de valeurs positives
+*/
 float Histo::FitMax(int degree, float frac, int debug) const
-//
-//	Fit de la position du maximum de l'histo par un polynome
-//	de degre `degree' a `frac' pourcent du maximum.
-//	L'histo est suppose etre remplit de valeurs positives
-//--
 {
   if (degree < 2 || degree > 3) degree = 3;
@@ -1200,11 +1141,10 @@
 
 /********* Methode *********/
-//++
+/*!
+  Calcul de la largeur a frac pourcent du maximum
+  autour du bin du maximum.
+  L'histo est suppose etre remplit de valeurs positives
+*/
 float Histo::FindWidth(float frac, int debug) const
-//
-//	Calcul de la largeur a frac pourcent du maximum
-//	autour du bin du maximum.
-//	L'histo est suppose etre remplit de valeurs positives
-//--
 {
   float xmax = BinCenter( IMax() );
@@ -1213,10 +1153,9 @@
 
 /********* Methode *********/
-//++
+/*!
+  Calcul de la largeur a frac pourcent de la valeur du bin xmax.
+  L'histo est suppose etre remplit de valeurs positives
+*/
 float Histo::FindWidth(float xmax,float frac, int debug) const
-//
-//	Calcul de la largeur a frac pourcent de la valeur du bin xmax.
-//	L'histo est suppose etre remplit de valeurs positives
-//--
 {
   if (frac <= 0 || frac >= 1.) frac = 0.5;
@@ -1292,9 +1231,8 @@
 
 /********* Methode *********/
-//++
+/*!
+  Cf suivant mais im est le bin du maximum de l'histo
+*/
 int Histo::EstimeMax(float& xm,int SzPav)
-//
-//	Cf suivant mais im est le bin du maximum de l'histo
-//--
 {
 int im = IMax();
@@ -1303,15 +1241,16 @@
 
 /********* Methode *********/
-//++
+/*!
+  Determine l'abscisses du maximum donne par im
+  en moyennant dans un pave SzPav  autour du maximum
+  \verbatim
+     Return:
+        0 = si fit maximum reussi avec SzPav pixels
+        1 = si fit maximum reussi avec moins que SzPav pixels
+        2 = si fit maximum echoue et renvoit BinCenter()
+       -1 = si echec: SzPav <= 0 ou im hors limites
+  \endverbatim
+*/
 int Histo::EstimeMax(int& im,float& xm,int SzPav)
-//
-//	Determine l'abscisses du maximum donne par im
-//	en moyennant dans un pave SzPav  autour du maximum
-//|  Return:
-//|     0 = si fit maximum reussi avec SzPav pixels
-//|     1 = si fit maximum reussi avec moins que SzPav pixels
-//|     2 = si fit maximum echoue et renvoit BinCenter()
-//|    -1 = si echec: SzPav <= 0 ou im hors limites
-//--
 {
 xm = 0;
@@ -1341,10 +1280,9 @@
 
 /********* Methode *********/
-//++
+/*!
+  Determine la largeur a frac% du maximum a gauche (widthG)
+  et a droite (widthD)
+*/
 void Histo::EstimeWidthS(float frac,float& widthG,float& widthD)
-//
-//	Determine la largeur a frac% du maximum a gauche (widthG)
-//	et a droite (widthD)
-//--
 {
 int i;
@@ -1385,24 +1323,25 @@
 
 //////////////////////////////////////////////////////////
-//++
+/*!
+  Fit de l'histogramme par ``gfit''.
+  \verbatim
+    typ_err = 0 :
+       - erreur attachee au bin si elle existe
+       - sinon 1
+    typ_err = 1 :
+       - erreur attachee au bin si elle existe
+       - sinon max( sqrt(abs(bin) ,1 )
+    typ_err = 2 :
+       - erreur forcee a 1
+    typ_err = 3 :
+       - erreur forcee a max( sqrt(abs(bin) ,1 )
+    typ_err = 4 :
+       - erreur forcee a 1, nulle si bin a zero.
+    typ_err = 5 :
+       - erreur forcee a max( sqrt(abs(bin) ,1 ),
+         nulle si bin a zero.
+  \endverbatim
+*/
 int  Histo::Fit(GeneralFit& gfit,unsigned short typ_err)
-//
-//	Fit de l'histogramme par ``gfit''.
-//| typ_err = 0 :
-//|    - erreur attachee au bin si elle existe
-//|    - sinon 1
-//| typ_err = 1 :
-//|    - erreur attachee au bin si elle existe
-//|    - sinon max( sqrt(abs(bin) ,1 )
-//| typ_err = 2 :
-//|    - erreur forcee a 1
-//| typ_err = 3 :
-//|    - erreur forcee a max( sqrt(abs(bin) ,1 )
-//| typ_err = 4 :
-//|    - erreur forcee a 1, nulle si bin a zero.
-//| typ_err = 5 :
-//|    - erreur forcee a max( sqrt(abs(bin) ,1 ),
-//|      nulle si bin a zero.
-//--
 {
 if(NBins()<=0) return -1000;
@@ -1430,9 +1369,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant les residus du fit ``gfit''.
+*/
 Histo Histo::FitResidus(GeneralFit& gfit)
-//
-//	Retourne une classe contenant les residus du fit ``gfit''.
-//--
 {
 if(NBins()<=0)
@@ -1450,9 +1388,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant la fonction du fit ``gfit''.
+*/
 Histo Histo::FitFunction(GeneralFit& gfit)
-//
-//	Retourne une classe contenant la fonction du fit ``gfit''.
-//--
 {
 if(NBins()<=0)
@@ -1471,22 +1408,23 @@
 
 /********* Methode *********/
-//++
+/*!
+  Impression de l'histogramme dans le fichier fp
+  \verbatim
+      hdyn = nombre de colonnes pour imprimer les etoiles
+          si =0 alors defaut(100),
+          si <0 pas de print histo seulement infos
+      hmin = minimum de la dynamique
+      hmax = maximum de la dynamique
+          si hmax<=hmin           : hmin=VMin() hmax=VMax()
+          si hmax<=hmin et hmin=0 : hmin=0 hmax=VMax()
+          sinon : hmin hmax
+      pflag < 0 : on imprime les informations (nbin,min,...) sans l'histogramme
+            = 0 : on imprime  "BinCenter(i) data[i]"  (note "... ...")
+            bit 0 on : (v=1): numero_bin "... ..."
+            bit 1 on : (v=2): "... ..." erreur
+  \endverbatim
+*/
 void Histo::PrintF(FILE * fp, int hdyn,float hmin, float hmax,int pflag,
 	      int il, int ih)
-//
-//	Impression de l'histogramme dans le fichier fp
-//|   hdyn = nombre de colonnes pour imprimer les etoiles
-//|       si =0 alors defaut(100),
-//|       si <0 pas de print histo seulement infos
-//|   hmin = minimum de la dynamique
-//|   hmax = maximum de la dynamique
-//|       si hmax<=hmin           : hmin=VMin() hmax=VMax()
-//|       si hmax<=hmin et hmin=0 : hmin=0 hmax=VMax()
-//|       sinon : hmin hmax
-//|   pflag < 0 : on imprime les informations (nbin,min,...) sans l'histogramme
-//|         = 0 : on imprime  "BinCenter(i) data[i]"  (note "... ...")
-//|         bit 0 on : (v=1): numero_bin "... ..."
-//|         bit 1 on : (v=2): "... ..." erreur
-//--
 {
 
@@ -1642,88 +1580,12 @@
 
 /********* Methode *********/
-//++
+/*!
+  Impression de l'histogramme sur stdout
+*/
 void Histo::Print(int hdyn,float hmin, float hmax,int pflag,
 	     int il, int ih)
-//
-//	Impression de l'histogramme sur stdout
-//--
 {
  Histo::PrintF(stdout, hdyn, hmin, hmax, pflag, il, ih);
 }
-
-
-// Rappel des inlines functions pour commentaires
-//++
-// inline float          XMin() const
-//	Retourne l'abscisse minimum
-//--
-//++
-// inline float          XMax() const
-//	Retourne l'abscisse maximum
-//--
-//++
-// inline int            NBins() const
-//	Retourne le nombre de bins
-//--
-//++
-// inline float          BinWidth() const
-//	Retourne la largeur du bin
-//--
-//++
-// inline float*         Bins() const
-//	Retourne le pointeur sur le tableaux des contenus
-//--
-//++
-// inline float          operator()(int i) const
-//	Retourne le contenu du bin i
-//--
-//++
-// inline float&         operator()(int i)
-//	Remplit le contenu du bin i
-//--
-//++
-// inline float          Error(int i) const
-//	Retourne l'erreur du bin i
-//--
-//++
-// inline double         Error2(int i) const
-//	Retourne l'erreur au carre du bin i
-//--
-//++
-// inline double&        Error2(int i)
-//	Remplit l'erreur au carre du bin i
-//--
-//++
-// inline float          NData() const
-//	Retourne la somme ponderee
-//--
-//++
-// inline float          NEntries()
-//	Retourne le nombre d'entrees
-//--
-//++
-// inline float          NOver() const
-//	Retourne le nombre d'overflow
-//--
-//++
-// inline float          NUnder() const
-//	Retourne le nombre d'underflow
-//--
-//++
-// inline float          BinLowEdge(int i)  const
-//	Retourne l'abscisse du bord inferieur du bin i
-//--
-//++
-// inline float          BinCenter(int i)   const
-//	Retourne l'abscisse du centre du bin i
-//--
-//++
-// inline float          BinHighEdge(int i) const
-//	Retourne l'abscisse du bord superieur du bin i
-//--
-//++
-// inline int            FindBin(float x) const   
-//	Retourne le numero du bin contenant l'abscisse x
-//--
 
 
