Index: trunk/SophyaLib/HiStats/hisprof.h
===================================================================
--- trunk/SophyaLib/HiStats/hisprof.h	(revision 956)
+++ trunk/SophyaLib/HiStats/hisprof.h	(revision 958)
@@ -83,6 +83,10 @@
 
 
+/*! \ingroup HiStats \fn operator<<(POuttPersist&, HProf)
+  \brief Persistance management */
 inline POutPersist& operator << (POutPersist& os, HProf & obj)
 { ObjFileIO<HProf> fio(&obj);  fio.Write(os);  return(os); }
+/*! \ingroup HiStats \fn operator>>(PInPersist&, HProf)
+  \brief Persistance management */
 inline PInPersist& operator >> (PInPersist& is, HProf & obj)
 { ObjFileIO<HProf> fio(&obj);  fio.Read(is);  return(is); }
Index: trunk/SophyaLib/HiStats/histos.cc
===================================================================
--- trunk/SophyaLib/HiStats/histos.cc	(revision 956)
+++ trunk/SophyaLib/HiStats/histos.cc	(revision 958)
@@ -1,4 +1,4 @@
 //
-// $Id: histos.cc,v 1.4 2000-04-15 11:06:27 ansari Exp $
+// $Id: histos.cc,v 1.5 2000-04-18 13:38:16 ansari Exp $
 //
 
@@ -432,5 +432,5 @@
 void Histo::PutValue(TVector<r_8> &v, int ierr)
 {
-if(v.NElts()<bins) THROW(sizeMismatchErr);
+if(v.NElts()<(uint_4) bins) THROW(sizeMismatchErr);
 for(int i=0;i<bins;i++) {
   data[i] = v(i);
@@ -445,5 +445,5 @@
 void Histo::PutValueAdd(TVector<r_8> &v, int ierr)
 {
-if(v.NElts()<bins) THROW(sizeMismatchErr);
+if(v.NElts()<(uint_4) bins) THROW(sizeMismatchErr);
 for(int i=0;i<bins;i++) {
   data[i] += v(i);
@@ -458,5 +458,5 @@
 void Histo::PutError2(TVector<r_8> &v)
 {
-if(v.NElts()<bins) THROW(sizeMismatchErr);
+if(v.NElts()<(uint_4) bins) THROW(sizeMismatchErr);
 if(!err2) Errors();
 for(int i=0;i<bins;i++) err2[i] = v(i);
@@ -469,5 +469,5 @@
 void Histo::PutError2Add(TVector<r_8> &v)
 {
-if(v.NElts()<bins) THROW(sizeMismatchErr);
+if(v.NElts()<(uint_4) bins) THROW(sizeMismatchErr);
 if(!err2) Errors();
 for(int i=0;i<bins;i++) if(v(i)>0.) err2[i] += v(i);
@@ -480,5 +480,5 @@
 void Histo::PutError(TVector<r_8> &v)
 {
-if(v.NElts()<bins) THROW(sizeMismatchErr);
+if(v.NElts()<(uint_4) bins) THROW(sizeMismatchErr);
 if(!err2) Errors();
 for(int i=0;i<bins;i++)
@@ -1360,5 +1360,5 @@
   double f = (double) (*this)(i);
   double saf = sqrt(fabs((double) f)); if(saf<1.) saf=1.;
-  double e;
+  double e=0.;
   if(typ_err==0)      {if(HasErrors()) e=Error(i); else e=1.;}
   else if(typ_err==1) {if(HasErrors()) e=Error(i); else e=saf;}
Index: trunk/SophyaLib/HiStats/histos.h
===================================================================
--- trunk/SophyaLib/HiStats/histos.h	(revision 956)
+++ trunk/SophyaLib/HiStats/histos.h	(revision 958)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: histos.h,v 1.5 2000-04-15 11:06:28 ansari Exp $
+// $Id: histos.h,v 1.6 2000-04-18 13:38:17 ansari Exp $
 //
 
@@ -179,6 +179,10 @@
 
 
+/*! \ingroup HiStats \fn operator<<(POuttPersist&,Histo)
+  \brief Persistance management */
 inline POutPersist& operator << (POutPersist& os, Histo & obj)
 { ObjFileIO<Histo> fio(&obj);  fio.Write(os);  return(os); }
+/*! \ingroup HiStats \fn operator<<(POuttPersist&,Histo)
+  \brief Persistance management */
 inline PInPersist& operator >> (PInPersist& is, Histo & obj)
 { ObjFileIO<Histo> fio(&obj);  fio.Read(is);  return(is); }
Index: trunk/SophyaLib/HiStats/histos2.cc
===================================================================
--- trunk/SophyaLib/HiStats/histos2.cc	(revision 956)
+++ trunk/SophyaLib/HiStats/histos2.cc	(revision 958)
@@ -666,5 +666,5 @@
 {
 int i,j;
-if(v.NRows()!=nx || v.NCol()!=ny) THROW(sizeMismatchErr);
+if(v.NRows()!=(uint_4)nx || v.NCol()!=(uint_4)ny) THROW(sizeMismatchErr);
 for(i=0;i<nx;i++) for(j=0;j<ny;j++) {
   (*this)(i,j) = v(i,j);
@@ -680,5 +680,5 @@
 {
 int i,j;
-if(v.NRows()!=nx || v.NCol()!=ny) THROW(sizeMismatchErr);
+if(v.NRows()!=(uint_4)nx || v.NCol()!=(uint_4)ny) THROW(sizeMismatchErr);
 for(i=0;i<nx;i++) for(j=0;j<ny;j++) {
   (*this)(i,j) += v(i,j);
@@ -695,5 +695,5 @@
 {
 int i,j;
-if(v.NRows()!=nx || v.NCol()!=ny) THROW(sizeMismatchErr);
+if(v.NRows()!=(uint_4)nx || v.NCol()!=(uint_4)ny) THROW(sizeMismatchErr);
 if(!err2) Errors();
 for(i=0;i<nx;i++) for(j=0;j<ny;j++) Error2(i,j) = v(i,j);
@@ -708,5 +708,5 @@
 {
 int i,j;
-if(v.NRows()!=nx || v.NCol()!=ny) THROW(sizeMismatchErr);
+if(v.NRows()!=(uint_4)nx || v.NCol()!=(uint_4)ny) THROW(sizeMismatchErr);
 if(!err2) Errors();
 for(i=0;i<nx;i++) for(j=0;j<ny;j++)
@@ -721,5 +721,5 @@
 {
 int i,j;
-if(v.NRows()!=nx || v.NCol()!=ny) THROW(sizeMismatchErr);
+if(v.NRows()!=(uint_4)nx || v.NCol()!=(uint_4)ny) THROW(sizeMismatchErr);
 if(!err2) Errors();
 for(i=0;i<nx;i++) for(j=0;j<ny;j++)
@@ -1046,5 +1046,5 @@
   double f = (double) (*this)(i,j);
   double saf = sqrt(fabs(f)); if(saf<1.) saf=1.;
-  double e;
+  double e=0.;
   if(typ_err==0)      {if(HasErrors()) e=Error(i,j); else e=1.;}
   else if(typ_err==1) {if(HasErrors()) e=Error(i,j); else e=saf;}
Index: trunk/SophyaLib/HiStats/histos2.h
===================================================================
--- trunk/SophyaLib/HiStats/histos2.h	(revision 956)
+++ trunk/SophyaLib/HiStats/histos2.h	(revision 958)
@@ -249,6 +249,10 @@
 // Classe pour la gestion de persistance
 
+/*! \ingroup HiStats \fn operator<<(POuttPersist&,Histo2D)
+  \brief Persistance management */
 inline POutPersist& operator << (POutPersist& os, Histo2D & obj)
 { ObjFileIO<Histo2D> fio(&obj);  fio.Write(os);  return(os); }
+/*! \ingroup HiStats \fn operator<<(POuttPersist&,Histo2D)
+  \brief Persistance management */
 inline PInPersist& operator >> (PInPersist& is, Histo2D & obj)
 { ObjFileIO<Histo2D> fio(&obj);  fio.Read(is);  return(is); }
Index: trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- trunk/SophyaLib/NTools/generaldata.cc	(revision 956)
+++ 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 956)
+++ 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 956)
+++ 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 956)
+++ 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); }
Index: trunk/SophyaLib/TArray/basarr.cc
===================================================================
--- trunk/SophyaLib/TArray/basarr.cc	(revision 956)
+++ trunk/SophyaLib/TArray/basarr.cc	(revision 958)
@@ -61,5 +61,5 @@
 {
   uint_8 rs = step;
-  for(int k=0; k<ndim; k++) rs *= siz[k];
+  for(uint_4 k=0; k<ndim; k++) rs *= siz[k];
   return(rs+offset);
 }
@@ -285,5 +285,5 @@
 {
   if (ndim_ != a.ndim_)  return(false);
-  for(int k=0; k<ndim_; k++) 
+  for(uint_4 k=0; k<ndim_; k++) 
     if (size_[k] != a.size_[k])  return(false);
   //  $CHECK$   Reza doit-on verifier ca 
@@ -301,5 +301,5 @@
   uint_4 size[BASEARRAY_MAXNDIMS];
   uint_4 step[BASEARRAY_MAXNDIMS];
-  for(int k=0; k<ndim_; k++) {
+  for(uint_4 k=0; k<ndim_; k++) {
     if (size_[k] < 2)  continue;
     size[ndim] = size_[k];
@@ -324,5 +324,5 @@
   uint_4 size[BASEARRAY_MAXNDIMS];
   uint_4 step[BASEARRAY_MAXNDIMS];
-  for(int k=0; k<ndim_; k++) {
+  for(uint_4 k=0; k<ndim_; k++) {
     size[ndim] = size_[k];
     step[ndim] = step_[k];
@@ -338,5 +338,5 @@
 uint_4 BaseArray::MinStepKA() const
 {
-  for(int ka=0; ka<ndim_; ka++)
+  for(uint_4 ka=0; ka<ndim_; ka++)
     if (step_[ka] == minstep_) return(ka);
   return(0);
@@ -348,5 +348,5 @@
   uint_4 ka = 0;
   uint_4 mx = size_[0];
-  for(int k=0; k<ndim_; k++)  
+  for(uint_4 k=0; k<ndim_; k++)  
     if (size_[k] > mx) {  ka = k;  mx = size_[k];  }
   return(ka);
@@ -370,5 +370,5 @@
   //#endif
   uint_4 idx[BASEARRAY_MAXNDIMS];
-  int k;
+  uint_4 k;
   uint_8 rest = i;
   idx[ka] = 0;
@@ -392,5 +392,5 @@
 
   uint_4 idx[BASEARRAY_MAXNDIMS];
-  int k;
+  uint_4 k;
   uint_8 rest = ip;
   for(k=0; k<ndim_; k++) {
@@ -424,5 +424,5 @@
   os << "\n--- " << InfoString() ; 
   os << " ND=" << ndim_ << " SizeX*Y*...= " ;
-  for(int k=0; k<ndim_; k++) { 
+  for(uint_4 k=0; k<ndim_; k++) { 
     os << size_[k];
     if (k<ndim_-1)  os << "x";
@@ -431,5 +431,5 @@
   if (prt_lev_ > 0) {
     os <<  " TotSize= " << totsize_ << " Step(X Y ...)="  ;
-    for(int k=0; k<ndim_; k++)     os << step_[k] << "  " ;
+    for(uint_4 k=0; k<ndim_; k++)     os << step_[k] << "  " ;
     os << " Offset= " << offset_  << endl;
   }
@@ -483,5 +483,5 @@
 
   totsize_ = 1;
-  int k;
+  uint_4 k;
   for(k=0; k<BASEARRAY_MAXNDIMS; k++) {
     size_[k] = 1;
@@ -530,5 +530,5 @@
 
   totsize_ = 1;
-  int k;
+  uint_4 k;
   for(k=0; k<BASEARRAY_MAXNDIMS; k++) {
     size_[k] = 1;
@@ -584,5 +584,5 @@
 
   totsize_ = 1;
-  int k;
+  uint_4 k;
   for(k=0; k<BASEARRAY_MAXNDIMS; k++) {
     size_[k] = 1;
@@ -629,5 +629,5 @@
   if ( (ndim > ndim_) || (ndim < 1) ) 
     throw(SzMismatchError("BaseArray::UpdateSubArraySizes( ... ) NDim Error") );
-  int k;
+  uint_4 k;
   for(k=0; k<ndim; k++) 
     if ( (siz[k]*step[k]+pos[k]) > size_[k] )  
Index: trunk/SophyaLib/TArray/fioarr.h
===================================================================
--- trunk/SophyaLib/TArray/fioarr.h	(revision 956)
+++ trunk/SophyaLib/TArray/fioarr.h	(revision 958)
@@ -34,10 +34,12 @@
 };
 
-//! Write TArray \b obj into POutPersist stream \b os
+/*! \ingroup TArray \fn operator<<(POutPersist&,TArray<T>&)
+  \brief Write TArray \b obj into POutPersist stream \b os */
 template <class T>
 inline POutPersist& operator << (POutPersist& os, TArray<T> & obj)
 { FIO_TArray<T> fio(&obj);  fio.Write(os);  return(os); }
 
-//! Read TArray \b obj from PInPersist stream \b os
+/*! \ingroup TArray \fn operator>>(PInPersist&,TArray<T>&)
+  \brief Read TArray \b obj from PInPersist stream \b os */
 template <class T>
 inline PInPersist& operator >> (PInPersist& is, TArray<T> & obj)
Index: trunk/SophyaLib/TArray/matharr.h
===================================================================
--- trunk/SophyaLib/TArray/matharr.h	(revision 956)
+++ trunk/SophyaLib/TArray/matharr.h	(revision 958)
@@ -33,44 +33,66 @@
 #if !defined(__GNUG__)
 // see below for g++   
+/*! \ingroup TArray \fn fabs(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> fabs(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, fabs) ); }
 
+/*! \ingroup TArray \fn sqrt(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> sqrt(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, sqrt) ); }
 
+/*! \ingroup TArray \fn sin(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> sin(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, sin) ); }
 
+/*! \ingroup TArray \fn cos(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> cos(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, cos) ); }
 
+/*! \ingroup TArray \fn tan(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> tan(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, tan) ); }
 
+/*! \ingroup TArray \fn asin(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> asin(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, asin) ); }
 
+/*! \ingroup TArray \fn acos(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> acos(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, acos) ); }
 
+/*! \ingroup TArray \fn atan(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> atan(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, atan) ); }
 
+/*! \ingroup TArray \fn exp(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> exp(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, exp) ); }
 
+/*! \ingroup TArray \fn lof(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> log(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, log) ); }
 
+/*! \ingroup TArray \fn log10(const TArray<T>& a)
+  \brief computation on TArray */
 template <class T>
 inline TArray<T> log10(const TArray<T>& a)
@@ -83,10 +105,12 @@
 #endif
 
-//! Return \b mean and \b sigma of elements of array \b a
+/*! \ingroup TArray \fn MeanSigma(const TArray<T>&,double&,double&)
+  \brief Return \b mean and \b sigma of elements of array \b a */
 template <class T>
 inline double MeanSigma(const TArray<T>& a, double & mean, double & sig)
   { MathArray<T> ma;   return( ma.MeanSigma(a, mean, sig) ); }
 
-//! Return \b mean of elements of array \b a
+/*! \ingroup TArray \fn Mean(const TArray<T>&)
+  \brief Return \b mean of elements of array \b a */
 template <class T>
 inline double Mean(const TArray<T>& a)
Index: trunk/SophyaLib/TArray/sopemtx.h
===================================================================
--- trunk/SophyaLib/TArray/sopemtx.h	(revision 956)
+++ trunk/SophyaLib/TArray/sopemtx.h	(revision 958)
@@ -48,6 +48,5 @@
 //------------------------------------------------------------
 
-/*! \ingroup TArray 
-    \fn LinSolveInPlace(TMatrix<r_4>&, TVector<r_4>&)
+/*! \ingroup TArray \fn LinSolveInPlace(TMatrix<r_4>&,TVector<r_4>&)
     \brief  Solve A*C = B for C in place and return determinant
 */
@@ -59,6 +58,5 @@
 }
 
-/*! \ingroup TArray 
-    \fn LinSolveInPlace (TMatrix<r_8>&, TVector<r_8>&)
+/*! \ingroup TArray \fn LinSolveInPlace(TMatrix<r_8>&,TVector<r_8>&)
     \brief  Solve A*X = B in place and return determinant 
 */
Index: trunk/SophyaLib/TArray/tarray.cc
===================================================================
--- trunk/SophyaLib/TArray/tarray.cc	(revision 956)
+++ trunk/SophyaLib/TArray/tarray.cc	(revision 958)
@@ -334,5 +334,5 @@
     uint_8 step = AvgStep();
     pe = Data();
-    for(k=0; k<totsize_; k++ )  pe[k*step] = seq(k);
+    for(k=0; k<totsize_; k++ )  pe[k*step] = (T) seq(k);
   }
   else {    // Non regular data spacing ...
@@ -344,5 +344,5 @@
     for(j=0; j<naxa; j++)  {
       pe = mNDBlock.Begin()+Offset(ka,j);
-      for(k=0; k<gpas; k++)  pe[k*step] = seq(j*gpas+k);
+      for(k=0; k<gpas; k++)  pe[k*step] = (T) seq(j*gpas+k);
     }
   }
@@ -807,5 +807,5 @@
 {
   if (maxprt < 0)  maxprt = max_nprt_;
-  int_4 npr = 0;
+  uint_4 npr = 0;
   Show(os, si);
   if (ndim_ < 1) return;
@@ -822,5 +822,5 @@
             if(k0 > 0) os << ", ";  
             os << Elem(k0, k1, k2, k3, k4);     npr++;
-	    if (npr >= maxprt) {
+	    if (npr >= (uint_4) maxprt) {
 	      if (npr < totsize_)  os << "\n     .... " << endl; return;
 	    }
Index: trunk/SophyaLib/TArray/tarray.h
===================================================================
--- trunk/SophyaLib/TArray/tarray.h	(revision 956)
+++ trunk/SophyaLib/TArray/tarray.h	(revision 958)
@@ -165,29 +165,36 @@
 // Surcharge d'operateurs A (+,-,*,/) (T) x
 
-//! Operator TArray = TArray + constant
+/*! \ingroup TArray \fn operator+(const TArray<T>&,T)
+  \brief Operator TArray = TArray + constant */
 template <class T> inline TArray<T> operator + (const TArray<T>& a, T b)
     {TArray<T> result(a); result.SetTemp(true); result.Add(b); return result;}
 
-//! Operator TArray = constant + TArray
+/*! \ingroup TArray \fn operator+(T,const TArray<T>&)
+  \brief Operator TArray = constant + TArray */
 template <class T> inline TArray<T> operator + (T b,const TArray<T>& a)
     {TArray<T> result(a); result.SetTemp(true); result.Add(b); return result;}
 
-//! Operator TArray = TArray - constant
+/*! \ingroup TArray \fn operator-(const TArray<T>&,T)
+  \brief Operator TArray = TArray - constant */
 template <class T> inline TArray<T> operator - (const TArray<T>& a, T b)
     {TArray<T> result(a); result.SetTemp(true); result.Sub(b); return result;}
 
-//! Operator TArray = constant - TArray
+/*! \ingroup TArray \fn operator-(T,const TArray<T>&)
+  \brief Operator TArray = constant - TArray */
 template <class T> inline TArray<T> operator - (T b,const TArray<T>& a)
     {TArray<T> result(a); result.SetTemp(true); result.SubInv(b); return result;}
 
-//! Operator TArray = TArray * constant
+/*! \ingroup TArray \fn operator*(const TArray<T>&,T)
+  \brief Operator TArray = TArray * constant */
 template <class T> inline TArray<T> operator * (const TArray<T>& a, T b)
     {TArray<T> result(a); result.SetTemp(true); result.Mul(b); return result;}
 
-//! Operator TArray = constant * TArray
+/*! \ingroup TArray \fn operator*(T,const TArray<T>&)
+  \brief Operator TArray = constant * TArray */
 template <class T> inline TArray<T> operator * (T b,const TArray<T>& a)
     {TArray<T> result(a); result.SetTemp(true); result.Mul(b); return result;}
 
-//! Operator TArray = TArray / constant
+/*! \ingroup TArray \fn operator/(const TArray<T>&,T)
+  \brief Operator TArray = TArray / constant */
 template <class T> inline TArray<T> operator / (const TArray<T>& a, T b)
     {TArray<T> result(a); result.SetTemp(true); result.DivInv(b); return result;}
@@ -196,10 +203,12 @@
 // Surcharge d'operateurs C = A (+,-) B
 
-//! Operator TArray = TArray + TArray
+/*! \ingroup TArray \fn operator+(const TArray<T>&,const TArray<T>&)
+  \brief Operator TArray = TArray + TArray */
 template <class T>
 inline TArray<T> operator + (const TArray<T>& a,const TArray<T>& b)
     {TArray<T> result(a); result.SetTemp(true); result.AddElt(b); return result;}
 
-//! Operator TArray = TArray - TArray
+/*! \ingroup TArray \fn operator-(const TArray<T>&,const TArray<T>&)
+  \brief Operator TArray = TArray - TArray */
 template <class T>
 inline TArray<T> operator - (const TArray<T>& a,const TArray<T>& b)
Index: trunk/SophyaLib/TArray/tmatrix.cc
===================================================================
--- trunk/SophyaLib/TArray/tmatrix.cc	(revision 956)
+++ trunk/SophyaLib/TArray/tmatrix.cc	(revision 958)
@@ -1,3 +1,3 @@
-// $Id: tmatrix.cc,v 1.7 2000-04-13 18:39:14 ansari Exp $
+// $Id: tmatrix.cc,v 1.8 2000-04-18 13:38:52 ansari Exp $
 //                         C.Magneville          04/99
 #include "machdefs.h"
@@ -290,5 +290,5 @@
 {
   if (maxprt < 0)  maxprt = max_nprt_;
-  int_4 npr = 0;
+  uint_4 npr = 0;
   Show(os, si);
   if (ndim_ < 1)  return;
@@ -299,5 +299,5 @@
       if(kc > 0) os << ", ";  
       os << (*this)(kr, kc);   npr++; 
-      if (npr >= maxprt) {
+      if (npr >= (uint_4) maxprt) {
 	if (npr < totsize_)  os << "\n     .... " << endl; return;
       }
Index: trunk/SophyaLib/TArray/tmatrix.h
===================================================================
--- trunk/SophyaLib/TArray/tmatrix.h	(revision 956)
+++ trunk/SophyaLib/TArray/tmatrix.h	(revision 958)
@@ -126,5 +126,4 @@
 }
 
-
 // Surcharge d'operateurs C = A (+,-) B
 // $CHECK$ Reza 3/4/2000 Pas necessaire  de redefinir les operateurs
@@ -132,10 +131,12 @@
 // Doit-on le faire aussi pour les constantes ? - Fin de $CHECK$ Reza 3/4/2000
 
-//! + : add matrixes \b a and \b b
+/*! \ingroup TArray \fn operator+(const TMatrix<T>&,const TMatrix<T>&)
+  \brief + : add matrixes \b a and \b b */
 template <class T>
 inline TMatrix<T> operator + (const TMatrix<T>& a,const TMatrix<T>& b)
     {TMatrix<T> result(a); result.SetTemp(true); result.AddElt(b); return result;}
 
-//! - : substract matrixes \b a and \b b
+/*! \ingroup TArray \fn operator-(const TMatrix<T>&,const TMatrix<T>&)
+  \brief \- : substract matrixes \b a and \b b */
 template <class T>
 inline TMatrix<T> operator - (const TMatrix<T>& a,const TMatrix<T>& b)
@@ -143,5 +144,6 @@
 
 // Surcharge d'operateurs C = A * B
-//! - : multiply matrixes \b a and \b b
+/*! \ingroup TArray \fn operator*(const TMatrix<T>&,const TMatrix<T>&)
+  \brief * : multiply matrixes \b a and \b b */
 template <class T> inline TMatrix<T> operator * (const TMatrix<T>& a, const TMatrix<T>& b)
 { TMatrix<T> result(a); result.SetTemp(true); return(result.Multiply(b)); }
