Index: trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- trunk/SophyaLib/NTools/generaldata.cc	(revision 938)
+++ trunk/SophyaLib/NTools/generaldata.cc	(revision 958)
@@ -549,13 +549,13 @@
 if(var<0 || var>3) return -1;
 if(var>=2 && (ix<0 || ix>=mNVar) ) return -1;
-double min, max;
+double min=1., max=-1.;
 int ntest = 0;
 for(int i=0;i<mNData;i++) {
   if( ! IsValid(i) ) continue;
   double v;
-  if(var==0)      v = Val(i);
-  else if(var==1) v = EVal(i);
-  else if(var==2) v = Absc(ix,i);
-  else if(var==3) v = EAbsc(ix,i);
+  if(var==1)          v = EVal(i);
+    else if(var==2)   v = Absc(ix,i);
+      else if(var==3) v = EAbsc(ix,i);
+        else          v = Val(i);
   if(ntest==0) {min = max = v; imin = imax = i;}
   if(v<min) {min = v; imin = i;}
@@ -616,8 +616,8 @@
   if( ! IsValid(i) ) continue;
   double v;
-  if(var==0)      v = Val(i);
-  else if(var==1) v = EVal(i);
-  else if(var==2) v = Absc(ix,i);
-  else if(var==3) v = EAbsc(ix,i);
+  if(var==1)          v = EVal(i);
+    else if(var==2)   v = Absc(ix,i);
+      else if(var==3) v = EAbsc(ix,i);
+        else          v = Val(i);
   if(min<max && (v<min || max<v)) continue;
   mean += v;
@@ -662,8 +662,8 @@
   if( ! IsValid(i) ) continue;
   double v;
-  if(var==0)      v = Val(i);
-  else if(var==1) v = EVal(i);
-  else if(var==2) v = Absc(ix,i);
-  else if(var==3) v = EAbsc(ix,i);
+  if(var==1)          v = EVal(i);
+    else if(var==2)   v = Absc(ix,i);
+      else if(var==3) v = EAbsc(ix,i);
+        else          v = Val(i);
   if(min<max && (v<min || max<v)) continue;
   buff[ntest] = v;
Index: trunk/SophyaLib/NTools/generaldata.h
===================================================================
--- trunk/SophyaLib/NTools/generaldata.h	(revision 938)
+++ trunk/SophyaLib/NTools/generaldata.h	(revision 958)
@@ -158,9 +158,9 @@
   void Delete();
 
-  int_4   mNVar;
-  int_4   mNDataAlloc;
-  int_4   mNData;
-  int_4   mNDataGood;
-  uint_2  mOk_EXP;
+  int_4   mNVar;        //!< number of variables
+  int_4   mNDataAlloc;  //!< space allocated for datas
+  int_4   mNData;       //!< number of datas
+  int_4   mNDataGood;   //!< number of good datas (not killed)
+  uint_2  mOk_EXP;      //!< true if errors on variables X,Y,..
   r_8* mXP;             //!< x0 y0 z0, x1 y1 z1, ..., xn yn zn 
   r_8* mErrXP;          //!< Ex0 Ey0 Ez0, Ex1 Ey1 Ez1, ..., Exn Eyn Ezn 
@@ -168,6 +168,6 @@
   r_8* mErr;            //!< EF0, EF1, ...., EFn
   uint_2* mOK;          //!< 1 si pt valid, 0 sinon
-  r_8* BuffVar;
-  r_4* BuffVarR4;
+  r_8* BuffVar;         //!< dummy buffer
+  r_4* BuffVarR4;       //!< dummy buffer
 };
 
@@ -178,6 +178,8 @@
 // Classe pour la gestion de persistance
 
+//! For persistance management
 inline POutPersist& operator << (POutPersist& os, GeneralFitData & obj)
 { ObjFileIO<GeneralFitData> fio(&obj);  fio.Write(os);  return(os); }
+//! For persistance management
 inline PInPersist& operator >> (PInPersist& is, GeneralFitData & obj)
 { ObjFileIO<GeneralFitData> fio(&obj);  fio.Read(is);  return(is); }
Index: trunk/SophyaLib/NTools/poly.cc
===================================================================
--- trunk/SophyaLib/NTools/poly.cc	(revision 938)
+++ trunk/SophyaLib/NTools/poly.cc	(revision 958)
@@ -4,30 +4,17 @@
 #include "fioarr.h"
 
-//++
-// Class	Poly
-// Lib  	Outils++ 
-// include	poly.h
-//
-//	Classe de calcul sur polynômes à une variable.
-//--
-
-//++
-// Links	Parents
-// Vector
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-
-//////////////////////////////////////////////////////////////////////////
-//++
-// Poly::Poly(int degre=0)
-//
-//	Crée un nouveau polynôme, en allouant de la place pour 
-//	le degré spécifié. 
-//--
-
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+/*!
+  \class SOPHYA::Poly
+  \ingroup NTools
+  One dimensional polynomials class.
+*/
+
+//! Constructor
+/*! Create a 1D polynomial of degre \b degre */
 Poly::Poly(int degre)
 : TVector<r_8>(degre+1), dirty(0), deg(0)
@@ -36,9 +23,6 @@
 }
 
-//++
+//! Constructor by copy
 Poly::Poly(Poly const& a)
-//
-//	Constructeur par copie.
-//--
 :TVector<r_8>(a), dirty(a.dirty), deg(a.deg)
 {
@@ -46,5 +30,6 @@
 }
 
-
+//! update degre
+/*! update degre (that could be changed after operations) */
 void Poly::UpdateDeg() const
 {
@@ -56,19 +41,6 @@
 }
 
-//++
-// Titre	Méthodes
-//--
-
-//++
-// double& Poly::operator[](int i)
-//	Permet d'accéder au coefficient de degré i (avec version 
-//	const).
-//--
-
-//++
+//! compute value P(\b x)
 double Poly::operator()(double x) const
-//
-//	Calcule la valeur du polynôme au point x.
-//--
 {
   UpdateDegIfDirty();
@@ -81,9 +53,6 @@
 }
 
-//++
+//! Replace p(x) by its derivate
 void Poly::Derivate()
-//
-//	Remplace le polynôme par le polynôme dérivé.
-//--
 {
   UpdateDegIfDirty();
@@ -96,9 +65,6 @@
 
 
-//++
+//! Return the derivate in \b der(x)
 void Poly::Derivate(Poly& der) const
-//
-//	Retourne dans der le polynôme dérivé.
-//--
 {
   UpdateDegIfDirty();
@@ -110,10 +76,10 @@
 
 
-//++
+//! Return the roots of the polynomial into \b roots
+/*!
+  This works until degre 2
+  \return the number of roots
+*/
 int Poly::Roots(TVector<r_8>& roots) const
-//
-//	Retourne dans roots les racines réelles, si on sait
-//	les calculer. Retourne le nombre de racines.
-//--
 {
   UpdateDegIfDirty();
@@ -135,10 +101,7 @@
 
 
-//++
+//! Return root \b r for a degre 1 polynomial
+/*! \return return 1 if succes, 0 if not */
 int Poly::Root1(double& r) const
-//
-//	Seulement si le polynôme est de degré 1: retourne
-//	la racine dans "r". Retourne 1 (nombre de racines).
-//--
 {
   UpdateDegIfDirty();
@@ -150,11 +113,7 @@
 }
 
-//++
+//! Return roots \b r1 and \b r2 for a degre 2 polynomial
+/*! \return return the number of roots found */
 int Poly::Root2(double& r1, double& r2) const
-//
-//	Seulement si le polynôme est de degre 2: retourne
-//	les racines dans "r1" et "r2". Retourne 0, 1 ou 2
-//	(nombre de racines).
-//--
 {
   UpdateDegIfDirty();
@@ -172,9 +131,6 @@
 }
 
-//++
+//! Operator P(x) = a(x)
 Poly& Poly::operator = (Poly const& a)
-//
-//	Opérateur d'affectation.
-//--
 {
   if (this == &a) return *this;
@@ -185,12 +141,6 @@
 }
 
-//++
-// Titres	Opérations sur polynômes
-//--
-
-//++
+//! Perform P(x) += b(x)
 Poly& Poly::operator += (Poly const& b)
-//
-//--
 {
   UpdateDegIfDirty();
@@ -206,8 +156,6 @@
 }
 
-//++
+//! Perform P(x) -= b(x)
 Poly& Poly::operator -= (Poly const& b)
-//
-//--
 {
   UpdateDegIfDirty();
@@ -223,8 +171,6 @@
 }
 
-//++
+//! Perform P(x) *= b(x)
 Poly& Poly::operator *= (double a)
-//
-//--
 {
   UpdateDegIfDirty();
@@ -233,8 +179,6 @@
 }
 
-//++
+//! Return P(x) = *this(x) * b(x)
 Poly Poly::Mult(Poly const& b) const
-//
-//--
 {
 Poly c(deg + b.deg);
@@ -254,9 +198,6 @@
 }
 
-//++
+//! Print on stream \b s
 void Poly::Print(ostream& s, int_4 , bool ) const
-//
-//	Impresssion.
-//--
 {
   UpdateDegIfDirty();
@@ -274,11 +215,14 @@
 }
 
-//++
+//! Fit datas by a polynomial
+/*!
+  Fit y(x) by a polynimial P(x)
+  \param x : x datas
+  \param y : y datas
+  \param degre : degre of the polynomial P(x) to be fitted
+  \warning result is stored in the current object
+  \return return chisquare
+*/
 double Poly::Fit(TVector<r_8> const& x, TVector<r_8> const& y, int degre)
-//
-//	Ajustement polynomial par moindre carrés. Un polynôme de
-//	degré "degre" est ajusté sur les données "x" et "y", et stocké dans
-//	l'objet courant. Retourne le chi2.
-//--
 {
   int n = x.NElts();
@@ -303,13 +247,17 @@
 }
 
-//++
+//! Fit datas with errors by a polynomial
+/*!
+  Fit y(x) by a polynimial P(x)
+  \param x : x datas
+  \param y : y datas
+  \param erry2 : errors squared on y
+  \param degre : degre of the polynomial P(x) to be fitted
+  \warning result is stored in the current object
+  \return \b errcoeff : errors on the coefficients
+  \return return chisquare
+*/
 double Poly::Fit(TVector<r_8> const& x, TVector<r_8> const& y,
        TVector<r_8> const& erry2, int degre,TVector<r_8>& errCoef)
-//
-//	Ajustement polynomial par moindre carrés. Un polynôme de
-//	degré est ajusté sur les données x et y, et stocké dans
-//	l'objet courant. erry2 contient le carre des erreurs sur y. 
-//	Retourne le chi2.
-//--
 {
   int n = x.NElts();
@@ -337,10 +285,5 @@
 
 
-//++
-// Poly Poly::power(int n) const
-//
-//	Retourne le polynôme à la puissance n
-//--
-
+//! Return the polynomial at power \b n : ( \f$ P(x)^n \f$ )
 Poly Poly::power(int n) const // a accelerer !!!
 {
@@ -351,9 +294,6 @@
 }
 
-//++
+//! Substitue polynomial and return P\f$ (b(x)) \f$
 Poly Poly::operator() (Poly const& b) const
-//
-//	Substitution d'un polynôme dans un autre.
-//--
 {
   Poly c(b.Degre()*Degre());
@@ -365,4 +305,5 @@
 
 //////////////////////////////////////////////////////////////////////////
+//! For persistance management
 void ObjFileIO<Poly>::ReadSelf(PInPersist& is)
 {
@@ -375,4 +316,5 @@
 }
 
+//! For persistance management
 void ObjFileIO<Poly>::WriteSelf(POutPersist& os) const
 {
@@ -385,4 +327,8 @@
 
 //////////////////////////////////////////////////////////////////////////
+/*! \ingroup NTools
+  \fn binomial(int,int)
+  Return the binomial coefficient \f$ {C_n}^p \f$.
+*/
 int binomial(int n, int p)
 {
@@ -393,28 +339,18 @@
 }
 
-//////////////////////////////////////////////////////////////////////////
-// ******************* POLY 2 VARIABLES ******************
-//++
-// Class	Poly2
-// Lib  	Outils++ 
-// include	poly.h
-//
-//	Classe de calcul sur polynômes à deux variables.
-//--
-
-//++
-// Links	Parents
-// Vector
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-//++
+
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+/*!
+  \class SOPHYA::Poly2
+  \ingroup NTools
+  Two dimensional polynomials class.
+*/
+
+//! Constructor of 2D polynomial of degres \b degreX \b degreY
 Poly2::Poly2(int degreX, int degreY)
-//
-//	Crée un polynôme de degrés partiels degreX et degreY.
-//--
 :TVector<r_8>((degreX+1)*(degreY+1)), dirty(0),
  maxDegX(degreX), maxDegY(degreY), degX(0), degY(0), deg(0)
@@ -423,10 +359,6 @@
 }
 
-//++
+//! Constructor of 2D polynomial \f$ P(x,y) = px(x) * py(y) \f$
 Poly2::Poly2(Poly const& polX, Poly const& polY)
-//
-//	Crée un polynôme à deux variables comme produit
-//	de deux polynômes à une variable, p2(x,y)=px(x)py(y)
-//--
 :TVector<r_8>((polX.Degre()+1)*(polY.Degre()+1)), dirty(0),
  maxDegX(polX.Degre()), maxDegY(polY.Degre()),
@@ -439,9 +371,6 @@
 }
 
-//++
+//! Constructor by copy
 Poly2::Poly2(Poly2 const& a)
-//
-//	Constructeur par copie.
-//--
 :TVector<r_8>(a), dirty(a.dirty),
  maxDegX(a.maxDegX), maxDegY(a.maxDegY),
@@ -451,14 +380,6 @@
 }
 
-
-//++
-// Titre	Méthodes
-//--
-
-//++
+//! Operator P(x) = a(x)
 Poly2& Poly2::operator = (Poly2 const& a)
-//
-//	Opérateur d'affectation.
-//--
 {
   if (this == &a) return *this;
@@ -475,10 +396,6 @@
 }
 
-//++
+//! Re-allocate space for 2D polynomial with partial degres \b degreX \b degreY
 void Poly2::Realloc(int degreX, int degreY)
-//
-//	Redimensionne le polynôme comme etant un 
-//	polynôme de degrés partiels degreX et degreY.
-//--
 {
   UpdateDegIfDirty();
@@ -499,4 +416,6 @@
 
 
+//! update degres
+/*! update degres (that could be changed after operations) */
 void Poly2::UpdateDeg() const
 {
@@ -514,28 +433,6 @@
 }
 
-//++
-// int Poly2::DegX() const
-//	Degré partiel en X.
-// int Poly2::DegY() const
-//	Degré partiel en Y
-// int Poly2::MaxDegX() const
-//	Degré partiel maximum (alloué) en X
-// int Poly2::MaxDegY() const
-//	Degré partiel maximum (alloué) en Y
-// int Poly2::Deg()  const
-//	Degré total.
-//--
-
-//++
-// double& Poly2::Coef(int dx, int dy)
-//	Retourne le coefficient de x^dx y^dy
-//	(avec aussi version const).
-//--
-
-//++
+//! Return P(\b x, \b y)
 double Poly2::operator()(double x, double y) const
-//
-//	Retourne la valeur en (x,y).
-//--
 {
   UpdateDegIfDirty();
@@ -553,10 +450,17 @@
 }
 
-//++
+//! Fit datas by a polynomial
+/*!
+  Fit z(x,y) by a polynimial P(x,y)
+  \param x : x datas
+  \param y : y datas
+  \param z : z datas
+  \param degreX : partial degre on X
+  \param degreY : partial degre on Y
+  \warning result is stored in the current object
+  \return return chisquare
+*/
 double Poly2::Fit(TVector<r_8> const& x, TVector<r_8> const& y,
                  TVector<r_8> const& z, int degreX, int degreY)
-//
-//	Ajustement par moindre carrés z = P(x,y), degrés partiels imposés.
-//--
 {
   int n = x.NElts();
@@ -586,13 +490,20 @@
 }
 
-
-//++
+//! Fit datas with errors by a polynomial
+/*!
+  Fit z(x,y) by a polynimial P(x,y)
+  \param x : x datas
+  \param y : y datas
+  \param z : z datas
+  \param errz2 : errors squared on z
+  \param degreX : partial degre on X
+  \param degreY : partial degre on Y
+  \warning result is stored in the current object
+  \return \b errcoeff : errors on the coefficients
+  \return return chisquare
+*/
 double Poly2::Fit(TVector<r_8> const& x, TVector<r_8> const& y, TVector<r_8> const& z,
                   TVector<r_8> const& errz2, int degreX, int degreY,
                   TVector<r_8>& errCoef)
-//
-//	Ajustement par moindre carrés z = P(x,y), degrés partiels imposés,
-//	et erreurs^2 sur z dans errz2.
-//--
 {
   int n = x.NElts();
@@ -624,10 +535,16 @@
 }
 
-//++
+//! Fit datas by a polynomial
+/*!
+  Fit z(x,y) by a polynimial P(x,y)
+  \param x : x datas
+  \param y : y datas
+  \param z : z datas
+  \param degre : total degre
+  \warning result is stored in the current object
+  \return return chisquare
+*/
 double Poly2::Fit(TVector<r_8> const& x, TVector<r_8> const& y,
                               TVector<r_8> const& z, int degre)
-//
-//	Ajustement par moindre carrés z = P(x,y), degré total imposé.
-//--
 {
   int n = x.NElts();
@@ -668,13 +585,19 @@
 }
 
-
-//++
+//! Fit datas with errors by a polynomial
+/*!
+  Fit z(x,y) by a polynimial P(x,y)
+  \param x : x datas
+  \param y : y datas
+  \param z : z datas
+  \param errz2 : errors squared on z
+  \param degre : total degre
+  \warning result is stored in the current object
+  \return \b errcoeff : errors on the coefficients
+  \return return chisquare
+*/
 double Poly2::Fit(TVector<r_8> const& x, TVector<r_8> const& y,
                TVector<r_8> const& z,TVector<r_8> const& errz2,
                               int degre, TVector<r_8>& errCoef)
-//
-//	Ajustement par moindre carrés z = P(x,y), degré total imposé,
-//	et erreurs^2 sur z dans errz2.
-//--
 {
   int n = x.NElts();
@@ -721,9 +644,6 @@
 }
 
-//++
+//! Print on stream \b s
 void Poly2::Print(ostream& s, int_4 , bool ) const
-//
-//	Impression sur stream s.
-//--
 {
   UpdateDegIfDirty();
@@ -750,12 +670,6 @@
 }
 
-//++
-// Titre	Opérations
-//--
-
-//++
+//! Operator: return P(x) = *this(x) + b(x)
 Poly2& Poly2::operator += (Poly2 const& b)
-//
-//--
 {
   if (maxDegX < b.DegX() || maxDegY < b.DegY())
@@ -774,8 +688,6 @@
 }
 
-//++
+//! Operator: return P(x) = *this(x) - b(x)
 Poly2& Poly2::operator -= (Poly2 const& b)
-//
-//--
 {
   if (maxDegX < b.DegX() || maxDegY < b.DegY())
@@ -794,8 +706,6 @@
 }
 
-//++
+//! Operator: return P(x) = *this(x) * a
 Poly2& Poly2::operator *= (double a)
-//
-//--
 {
   for (int i=0; i<NElts(); i++)
@@ -805,8 +715,6 @@
 }
 
-//++
+//! Operator: return P(x) = *this(x) * b(x)
 Poly2 Poly2::Mult(Poly2 const& b) const
-//
-//--
 {
   Poly2 c(DegX() + b.DegX(), DegY() + b.DegY());
@@ -822,9 +730,6 @@
 }
 
-//++
+//! Return \f$ P(x,y)^n \f$
 Poly2 Poly2::power(int n) const
-//
-//	Calcule le polynôme P(x,y)^n
-//--
 {
   if (n < 0) THROW(rangeCheckErr);
@@ -835,10 +740,6 @@
 
 
-//++
+//! substitute and return \f$ P(a(x),b(x)) \f$
 Poly2 Poly2::operator() (Poly const& a, Poly const& b) const
-//
-//	Substitution de deux polynômes en X et Y,
-//	P2(pa(x), pb(y)).
-//--
 {
   UpdateDegIfDirty();
@@ -854,10 +755,6 @@
 }
 
-//++
+//! substitute and return 2D polynomial \f$ P(a(x,y)) \f$, P is a 1D polynomial
 Poly2 Poly::operator() (Poly2 const& a) const
-//
-//	Substitution d'un polynôme à deux variables dans
-//	un polynôme à une variable, P(P2(x,y)).
-//--
 {
   Poly2 c(a.MaxDegX()*Degre(), a.MaxDegY()*Degre());
@@ -869,4 +766,5 @@
 
 //////////////////////////////////////////////////////////////////////////
+//! For persistance management
 void ObjFileIO<Poly2>::ReadSelf(PInPersist& is)
 {
@@ -879,4 +777,5 @@
 }
 
+//! For persistance management
 void ObjFileIO<Poly2>::WriteSelf(POutPersist& os) const
 {
Index: trunk/SophyaLib/NTools/poly.h
===================================================================
--- trunk/SophyaLib/NTools/poly.h	(revision 938)
+++ trunk/SophyaLib/NTools/poly.h	(revision 958)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: poly.h,v 1.7 2000-04-14 16:14:31 ansari Exp $
+// $Id: poly.h,v 1.8 2000-04-18 13:38:36 ansari Exp $
 //
 
@@ -21,4 +21,5 @@
 
 //////////////////////////////////////////////////////////////////////////
+//! Class of 1 dimension polynomials P(x)
 class Poly : public TVector<r_8> {
   friend class ObjFileIO<Poly>;
@@ -27,14 +28,26 @@
   Poly(Poly const& a);
 
+  //! Return degre of polynomials
   inline int Degre() const {UpdateDegIfDirty(); return deg;}
 
+  //! Return space for a \b n degre polynomial
+  /*!
+    \param \b n : degre of new polynomial
+    \param \b force : force re-allocation if true,\
+                 if not allocation occurs only
+                 if space needed is greater than the old one
+  */
   inline void Realloc(int n, bool force=false)
                      {TVector<r_8>::Realloc(n+1,force);}
 
   //  Pour compatibilite PEIDA  - Reza 03/2000
+  //! Return coefficient of degre \b i
   inline double Element(int i) const { return Elem(i,0,0,0,0); } 
+  //! Return coefficient of degre \b i
   inline double & Element(int i)  { return Elem(i,0,0,0,0); } 
 
+  //! Return coefficient of degre \b i
   inline double operator[](int i) const {return Elem(i,0,0,0,0);}
+  //! Return coefficient of degre \b i
   inline double& operator[](int i) {dirty = 1; return Elem(i,0,0,0,0);}
   // Retourne le coefficient de degre i
@@ -87,24 +100,38 @@
 };
 
+/*! \ingroup NTools \fn operator*(Poly const&,Poly const&)
+  \brief perform and return P(X) = a(x) * b(x) */
 inline Poly operator* (Poly const& a, Poly const& b)
   { return a.Mult(b); }
 
+/*! \ingroup NTools \fn operator+(Poly const&,Poly const&)
+  \brief perform and return P(X) = a(x) + b(x) */
 inline Poly operator+ (Poly const& a, Poly const& b)
  { Poly c((a.Degre() > b.Degre())?(a.Degre()+1):(b.Degre()+1));
    c = a; c += b; return c; }
 
+/*! \ingroup NTools \fn operator-(Poly const&,Poly const&)
+  \brief perform and return P(X) = a(x) - b(x) */
 inline Poly operator- (Poly const& a, Poly const& b)
   { Poly c((a.Degre() > b.Degre())?(a.Degre()+1):(b.Degre()+1));
     c = a; c -= b; return c; }
 
+/*! \ingroup NTools \fn operator*(double,Poly const&)
+  \brief perform and return P(X) = a * b(x) */
 inline Poly operator* (double a, Poly const& b)
   { Poly c(b); c *= a; return c; }
 
+/*! \ingroup NTools \fn operator<<(ostream&,const Poly&)
+  \brief Print a(x) on stream \b s */
 inline ostream& operator << (ostream& s, const Poly& a)
   { a.Print(s); return s; }
 
 //////////////////////////////////////////////////////////////////////////
+/*! \ingroup NTools \fn operator<<(POutPersist&,Poly&)
+  \brief For persistance management */
 inline POutPersist& operator << (POutPersist& os, Poly & obj)
   { ObjFileIO<Poly> fio(&obj);  fio.Write(os);  return(os); }
+/*! \ingroup NTools \fn operator<<(PInPersist&,,Poly&)
+  \brief For persistance management */
 inline PInPersist& operator >> (PInPersist& is, Poly & obj)
   { ObjFileIO<Poly> fio(&obj);  fio.Read(is);  return(is); }
@@ -116,4 +143,5 @@
 
 //////////////////////////////////////////////////////////////////////////
+//! Class of 2 dimensions polynomials P(x,y)
 class Poly2 : public TVector<r_8> {
   friend class ObjFileIO<Poly2>;
@@ -124,13 +152,20 @@
   Poly2(Poly2 const& a);
 
+  //! Return polynomial partial degre for X
   inline int DegX() const {UpdateDegIfDirty(); return degX;}
+  //! Return polynomial partial degre for Y
   inline int DegY() const {UpdateDegIfDirty(); return degY;}
+  //! Return polynomial maximum partial degre for X
   inline int MaxDegX() const {return maxDegX;}
+  //! Return polynomial maximum partial degre for Y
   inline int MaxDegY() const {return maxDegY;}
+  //! Return polynomial total degre for X
   inline int Deg()  const {UpdateDegIfDirty(); return deg;}
   // les degres partiels en x et y, et totaux.
 
   //  Pour compatibilite PEIDA  - Reza 03/2000
+  //! Return coefficient of degre \b i
   inline double Element(int i) const { return Elem(i,0,0,0,0); } 
+  //! Return coefficient of degre \b i
   inline double & Element(int i)  { return Elem(i,0,0,0,0); } 
 
@@ -138,4 +173,5 @@
   // retourne la valeur en (x,y)
 
+  //! Return index of coefficient of X^dx * Y^dy in the vector
   inline int IndCoef(int dx, int dy) const {
     if (dx>maxDegX || dy>maxDegY) THROW(rangeCheckErr);
@@ -146,7 +182,9 @@
   // d'un fit...
 
+  //! Return coefficient of X^dx * Y^dy
   inline double Coef(int dx, int dy) const {
     return (dx>maxDegX || dy>maxDegY) ? 0 : Element(IndCoef(dx,dy));
   }
+  //! Return coefficient of X^dx * Y^dy
   inline double& Coef(int dx, int dy) {
     if (dx>maxDegX || dy>maxDegY) THROW(rangeCheckErr);
@@ -199,22 +237,36 @@
 };
 
+/*! \ingroup NTools \fn operator*(Poly2 const&,Poly2 const&)
+  \brief Perform P(x,y) = a(x,y) * b(x,y) */
 inline Poly2 operator* (Poly2 const& a, Poly2 const& b)
   { return a.Mult(b); }
 
+/*! \ingroup NTools \fn operator+(Poly2 const&,Poly2 const&)
+  \brief Perform P(x,y) = a(x,y) + b(x,y) */
 inline Poly2 operator+ (Poly2 const& a, Poly2 const& b)
   { Poly2 c(a); c += b; return c; }
 
+/*! \ingroup NTools \fn operator-(Poly2 const&,Poly2 const&)
+  \brief Perform P(x,y) = a(x,y) - b(x,y) */
 inline Poly2 operator- (Poly2 const& a, Poly2 const& b)
   { Poly2 c(a); c -= b; return c; }
 
+/*! \ingroup NTools \fn operator-(double,Poly2 const&)
+  \brief Perform P(x,y) = a * b(x,y) */
 inline Poly2 operator * (double a, Poly2 const& b)
   { Poly2 c(b); c *= a; return c; }
 
+/*! \ingroup NTools \fn operator<<(ostream&,const Poly2&)
+  \brief Print a(x,y) on stream \b s */
 inline ostream& operator << (ostream& s, const Poly2& a)
   { a.Print(s); return s; }
 
 //////////////////////////////////////////////////////////////////////////
+/*! \ingroup NTools \fn operator<<(POutPersist&,Poly2&)
+  \brief For persistance management */
 inline POutPersist& operator << (POutPersist& os, Poly2 & obj)
   { ObjFileIO<Poly2> fio(&obj);  fio.Write(os);  return(os); }
+/*! \ingroup NTools \fn operator<<(POutPersist&,Poly2&)
+  \brief For persistance management */
 inline PInPersist& operator >> (PInPersist& is, Poly2 & obj)
   { ObjFileIO<Poly2> fio(&obj);  fio.Read(is);  return(is); }
