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
 {
