Index: trunk/SophyaLib/TArray/basarr.cc
===================================================================
--- trunk/SophyaLib/TArray/basarr.cc	(revision 893)
+++ trunk/SophyaLib/TArray/basarr.cc	(revision 894)
@@ -9,6 +9,7 @@
 
 // Variables statiques globales
-char * BaseArray::ck_op_msg_[6] = {"???", "Size(int )", "IsPacked(int )", 
-		       "Stride(int )", "ElemCheckBound()", "operator()" };
+char * BaseArray::ck_op_msg_[6] =
+     {"???", "Size(int )", "IsPacked(int )"
+     ,"Stride(int )", "ElemCheckBound()", "operator()" };
 uint_4 BaseArray::max_nprt_ = 50;
 uint_4 BaseArray::prt_lev_ = 0;
@@ -19,5 +20,4 @@
 // ------ Methodes statiques globales --------
 
-//  1/ Gestion des impressions 
 //! Set maximum number of printed elements and print level
 /*!
@@ -41,4 +41,12 @@
 
 
+//! Compute totale size
+/*!
+  \param ndim : number of dimensions
+  \param siz : array of size along the \b ndim dimensions
+  \param step[ndim] : step value
+  \param offset : offset value
+  \return Total size of the array
+*/
 uint_8 BaseArray::ComputeTotalSize(uint_4 ndim, const uint_4 * siz, uint_4 step, uint_8 offset)
 {
@@ -48,4 +56,37 @@
 }
 
+//! Set Default Memory Mapping
+/*!
+  \param mm : Memory Mapping type
+  \verbatim
+     mm == CMemoryMapping : C like memory mapping
+     mm == FortranMemoryMapping : Fortran like memory mapping
+  \endverbatim
+  \verbatim
+  # ===== For Matrices
+  *** MATHEMATICS:   m(row,column) with indexes running [1,n])
+                          | 11 12 13 |
+     matrix Math = Mmath= | 21 22 23 |
+                          | 31 32 33 |
+  *** IDL, \b FORTRAN: indexes data in \b row-major format:
+     indexes arrays in (column,row) order.
+     index IDL running [0,n[ ; index FORTRAN running [1,n]
+     M in memory: [ 11 12 13 : 21 22 23 : 31 32 33 : ... ]
+                     line 1  : line 2   : line 3  : ...
+     ex: Midl(0,2) = Mfor(1,3) = Mmath(3,1) = 31
+         Midl(2,0) = Mfor(3,1) = Mmath(1,3) = 13
+  *** C: indexes data in \b column-major format:
+     indexes arrays in [row][column] order.
+     index C running [0,n[
+     M in memory: [ 11 21 31 : 12 22 32 : 13 23 33 : ... ]
+                    column 1 : column 2 : column 3 : ...
+     ex: Mc[2][0] = Mmath(3,1) = 31
+         Mc[0][2] = Mmath(1,3) = 13
+  *** RESUME diff Idl/Fortan/C/Math:
+    Midl(col-1,row-1) = Mfor(col,row) = Mc[row-1][col-1] = Mmath(row,col)
+    TRANSPOSE(column-major array) --> row-major array
+  \endverbatim
+  \return default memory mapping value
+ */
 short BaseArray::SetDefaultMemoryMapping(short mm)
 {
@@ -54,4 +95,9 @@
 }
 
+//! Set Default Vector Type
+/*!
+  \param vt : vector type (ColumnVector,RowVector)
+  \return default vector type value
+ */
 short BaseArray::SetDefaultVectorType(short vt)
 {
@@ -60,12 +106,24 @@
 }
 
-// Memory organisation 
+//! Select Memory Mapping
+/*!
+  Do essentially nothing.
+  \param mm : type of Memory Mapping (CMemoryMapping,FortranMemoryMapping)
+  \return return \b mm if it makes sense or default memory mapping value
+  \sa SetDefaultMemoryMapping
+ */
 short BaseArray::SelectMemoryMapping(short mm)
-// si mm == CMemoryMapping, elements d'une ligne suivant X (consecutif)
-// sinon (mm == FortranMemoryMapping)  elements d'une colonne suivant X 
 {
   if ( (mm == CMemoryMapping) || (mm == FortranMemoryMapping) )  return (mm) ; 
   else return (default_memory_mapping);
 }
+
+//! Select Vector type
+/*!
+  Do essentially nothing.
+  \param vt : vector type (ColumnVector,RowVector)
+  \return return \b vt if it makes sense or default vector type
+  \sa SetDefaultVectorType
+ */
 short BaseArray::SelectVectorType(short vt)
 {
@@ -74,4 +132,10 @@
 }
 
+//! Update Memory Mapping
+/*!
+  Update variables marowi_ macoli_ veceli_
+  \param mm : type of Memory Mapping (CMemoryMapping,FortranMemoryMapping)
+  \sa SetDefaultMemoryMapping
+ */
 void BaseArray::UpdateMemoryMapping(short mm)
 {
@@ -94,4 +158,11 @@
 }
 
+//! Update Memory Mapping
+/*!
+  \param a  : Array to be compared with
+  \param mm : type of Memory Mapping or memory mapping transfert
+       (SameMemoryMapping,AutoMemoryMapping,CMemoryMapping,FortranMemoryMapping)
+  \sa SetDefaultMemoryMapping
+ */
 void BaseArray::UpdateMemoryMapping(BaseArray const & a, short mm)
 {
@@ -119,4 +190,11 @@
 }
 
+//! Set Memory Mapping type
+/*!
+  Compute values for variables marowi_ macoli_ veceli_
+  \param mm : Memory Mapping type (SameMemoryMapping,AutoMemoryMapping
+                                  ,CMemoryMapping,FortranMemoryMapping)
+  \sa SetDefaultMemoryMapping
+ */
 void BaseArray::SetMemoryMapping(short mm)
 {
@@ -140,4 +218,10 @@
 }
 
+//! Set Vector Type
+/*!
+  Compute values for variable veceli_
+  \param vt : vector type ()
+  \sa SetDefaultVectorType
+ */
 void BaseArray::SetVectorType(short vt)
 {
@@ -184,8 +268,8 @@
 
 
-//! Returns true if \b ndim and \b sizes are equal
+//! Returns true if dimension and sizes are equal
 /*!
   \param a : array to be compared
-  \return true if ndim and sizes are equal, false if not
+  \return true if ndim and sizes[ndim] are equal, false if not
 */
 bool BaseArray::CompareSizes(const BaseArray& a)
@@ -201,4 +285,5 @@
 }
 
+//! Change dimension if some size == 1
 void BaseArray::CompactAllDim()
 {
@@ -223,4 +308,5 @@
 }
 
+//! Change dimension if some trailed size == 1
 void BaseArray::CompactTrailingDim()
 {
@@ -240,5 +326,5 @@
 }
 
-
+//! return minimum value for step[ndim]
 uint_4 BaseArray::MinStepKA() const
 {
@@ -248,4 +334,5 @@
 }
 
+//! return maximum value for step[ndim]
 uint_4 BaseArray::MaxSizeKA() const
 {
@@ -262,4 +349,5 @@
 // Position de l'element 0 du vecteur i selon l'axe ka
 // --------------------------------------------------
+//! return position of first element for vector \b i alond \b ka th axe.
 uint_8 BaseArray::Offset(uint_4 ka, uint_8 i) const
 {
@@ -285,4 +373,5 @@
 }
 
+//! return position of element \b ip.
 uint_8 BaseArray::Offset(uint_8 ip) const
 {
@@ -317,4 +406,5 @@
 // ----------------------------------------------------
 
+//! Show infos on stream \b os (\b si to display DvList)
 void BaseArray::Show(ostream& os, bool si) const
 {
@@ -345,4 +435,5 @@
 }
 
+//! Return BaseArray Type
 string BaseArray::InfoString() const
 {
@@ -352,4 +443,5 @@
 }
 
+//! Return attached DVList
 DVList& BaseArray::Info()
 {
@@ -358,5 +450,13 @@
 }
 
-
+//! Update sizes and information for array
+/*!
+  \param ndim : dimension
+  \param siz[ndim] : sizes
+  \param step : step (must be the same on all dimensions)
+  \param offset : offset of the first element
+  \return true if all OK, false if problems appear
+  \return string \b exmsg for explanation in case of problems
+ */
 bool BaseArray::UpdateSizes(uint_4 ndim, const uint_4 * siz, uint_4 step, uint_8 offset, string & exmsg)
 {
@@ -402,4 +502,13 @@
 }
 
+//! Update sizes and information for array
+/*!
+  \param ndim : dimension
+  \param siz[ndim] : sizes
+  \param step[ndim] : steps
+  \param offset : offset of the first element
+  \return true if all OK, false if problems appear
+  \return string \b exmsg for explanation in case of problems
+ */
 bool BaseArray::UpdateSizes(uint_4 ndim, const uint_4 * siz, const uint_4 * step, uint_8 offset, string & exmsg)
 {
@@ -450,4 +559,10 @@
 }
 
+//! Update sizes and information relative to array \b a
+/*!
+  \param a : array to be compare with
+  \return true if all OK, false if problems appear
+  \return string \b exmsg for explanation in case of problems
+ */
 bool BaseArray::UpdateSizes(const BaseArray& a, string & exmsg)
 {
@@ -492,4 +607,13 @@
 
 
+//! Update sizes and information relative to array \b a
+/*!
+  \param a : array to be compare with
+  \param ndim : could be change (but should be less than the ndim of the current class)
+  \param siz[ndim],pos[ndim],step[ndim] : could be changed but must be
+             compatible within the memory size with those of the current class.
+  \return true if all OK, false if problems appear
+  \return string \b exmsg for explanation in case of problems
+ */
 void BaseArray::UpdateSubArraySizes(BaseArray & ra, uint_4 ndim, uint_4 * siz, uint_4 * pos, uint_4 * step) const
 {
Index: trunk/SophyaLib/TArray/basarr.h
===================================================================
--- trunk/SophyaLib/TArray/basarr.h	(revision 893)
+++ trunk/SophyaLib/TArray/basarr.h	(revision 894)
@@ -13,5 +13,6 @@
 
 
-//! Maximum number of dimensions for an array
+//! Maximum number of dimensions for an array 
+/*! \anchor BASEARRAY_MAXNDIMS */
 #define BASEARRAY_MAXNDIMS  5
 
@@ -21,5 +22,7 @@
 //! Base class for template arrays
 /*!
-  Define base methods, enum and defaults for TArray , TMatrix and TVector
+  No data are connected to this class.
+
+  Define base methods, enum and defaults for TArray , TMatrix and TVector.
 */
 class BaseArray : public AnyDataObj {
@@ -51,9 +54,7 @@
   static inline uint_4 GetPrintLevel() { return prt_lev_; }
 
-  //! Set Default Memory Mapping
   static short   SetDefaultMemoryMapping(short mm=CMemoryMapping);
   //! Get Default Memory Mapping
   static inline short GetDefaultMemoryMapping() { return default_memory_mapping; }
-  //! Set Default Vector Type
   static short   SetDefaultVectorType(short vt=ColumnVector);
   //! Get Default Vector Type
@@ -146,6 +147,6 @@
   virtual string InfoString() const;
 
-  //  Objet DVList info 
-  DVList&       Info();
+  // DVList info Object
+  DVList& Info();
 
 protected:
@@ -166,24 +167,24 @@
   virtual void UpdateSubArraySizes(BaseArray & ra, uint_4 ndim, uint_4 * siz, uint_4 * pos, uint_4 * step) const;
 
-  uint_4 ndim_; //! number of dimensions of array
-  uint_4 size_[BASEARRAY_MAXNDIMS]; //! array of the size in each dimension
-  uint_8 totsize_; //! Total number of elements
+  uint_4 ndim_; //!< number of dimensions of array
+  uint_4 size_[BASEARRAY_MAXNDIMS]; //!< array of the size in each dimension
+  uint_8 totsize_; //!< Total number of elements
   //! two consecutive elements distance in a given dimension 
   uint_4 step_[BASEARRAY_MAXNDIMS];
-  uint_4 minstep_; //! minimal step (in any axes)
-  uint_4 moystep_; //! mean step, if == 0 --\> non regular steps
-  uint_8 offset_;  //! global offset -\> position of elem[0] in DataBlock
-  uint_4 marowi_; //! For matrices, Row index in dimensions
-  uint_4 macoli_; //! For matrices, Column index in dimensions
-  uint_4 veceli_; //! For vectors, dimension index = marowi_/macoli_ (Row/Col vectors)
-  bool ck_memo_vt_; //! if true, check MemoryOrg./VectorType for CompareSize
-  DVList* mInfo;    //! Infos (variables) attached to the array
-
-  static char * ck_op_msg_[6]; //! Operation messages for CheckDI() CheckBound()
-  static uint_4 max_nprt_; //! Nb maximum number of printed elements
-  static uint_4 prt_lev_;  //! Print level
-  static short default_memory_mapping; //! Default memory mapping
-  static short default_vector_type;    //! Default vector type Row/Column
-  static uint_8 openmp_size_threshold; //! Size limit for parallel routine calls
+  uint_4 minstep_; //!< minimal step (in any axes)
+  uint_4 moystep_; //!< mean step, if == 0 --\> non regular steps
+  uint_8 offset_;  //!< global offset -\> position of elem[0] in DataBlock
+  uint_4 marowi_; //!< For matrices, Row index in dimensions
+  uint_4 macoli_; //!< For matrices, Column index in dimensions
+  uint_4 veceli_; //!< For vectors, dimension index = marowi_/macoli_ (Row/Col vectors)
+  bool ck_memo_vt_; //!< if true, check MemoryOrg./VectorType for CompareSize
+  DVList* mInfo;    //!< Infos (variables) attached to the array
+
+  static char * ck_op_msg_[6]; //!< Operation messages for CheckDI() CheckBound()
+  static uint_4 max_nprt_; //!< maximum number of printed elements
+  static uint_4 prt_lev_;  //!< Print level
+  static short default_memory_mapping; //!< Default memory mapping
+  static short default_vector_type;    //!< Default vector type Row/Column
+  static uint_8 openmp_size_threshold; //!< Size limit for parallel routine calls
 };
 
Index: trunk/SophyaLib/TArray/fioarr.cc
===================================================================
--- trunk/SophyaLib/TArray/fioarr.cc	(revision 893)
+++ trunk/SophyaLib/TArray/fioarr.cc	(revision 894)
@@ -13,4 +13,5 @@
 ///////////////////////////////////////////////////////////
 
+//! Default constructor
 template <class T>
 FIO_TArray<T>::FIO_TArray()
@@ -20,4 +21,6 @@
 }
 
+
+//! Constructor from the file \b filename
 template <class T>
 FIO_TArray<T>::FIO_TArray(string const & filename) 
@@ -28,4 +31,5 @@
 }
 
+//! Constructor from the TArray \b obj
 template <class T>
 FIO_TArray<T>::FIO_TArray(const TArray<T> & obj) 
@@ -41,4 +45,5 @@
 }
 
+//! Connect with a TArray \b obj
 template <class T>
 FIO_TArray<T>::FIO_TArray(TArray<T> * obj) 
@@ -48,4 +53,5 @@
 }
 
+//! destructor
 template <class T>
 FIO_TArray<T>::~FIO_TArray()
@@ -54,4 +60,5 @@
 }
 
+//! Return pointer to the connected TArray
 template <class T>
 AnyDataObj* FIO_TArray<T>::DataObj()
@@ -60,4 +67,5 @@
 }
 
+//! Connect TArray \b o
 template <class T>
 void FIO_TArray<T>::SetDataObj(AnyDataObj & o)
Index: trunk/SophyaLib/TArray/fioarr.h
===================================================================
--- trunk/SophyaLib/TArray/fioarr.h	(revision 893)
+++ trunk/SophyaLib/TArray/fioarr.h	(revision 894)
@@ -15,5 +15,9 @@
 namespace SOPHYA {
 /////////////////////////////////////////////////////////////////////////
-// Classe pour la gestion de persistance
+//! Class for persistent management of TArray
+/*!
+  This class manage also persistence for TMatrix and TVector.
+  \sa TArray TMatrix TVector.
+ */
 template <class T>
 class FIO_TArray : public  PPersist  {
@@ -30,11 +34,14 @@
   virtual void ReadSelf(PInPersist&);           
   virtual void WriteSelf(POutPersist&) const;  
-  TArray<T> * dobj;
-  bool ownobj;
+  TArray<T> * dobj; //!< Pointer to the connected TArray
+  bool ownobj; //!< true if the connected object belong to the class
 };
 
+//! 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
 template <class T>
 inline PInPersist& operator >> (PInPersist& is, TArray<T> & obj)
Index: trunk/SophyaLib/TArray/matharr.cc
===================================================================
--- trunk/SophyaLib/TArray/matharr.cc	(revision 893)
+++ trunk/SophyaLib/TArray/matharr.cc	(revision 894)
@@ -10,4 +10,11 @@
 // ----------------------------------------------------
 
+
+//! Apply Function In Place (function double version)
+/*!
+  \param a : array to be replaced in place
+  \param f : function for replacement
+  \return Return an array \b a filled with function f(a(i,j))
+*/
 template <class T>
 TArray<T>& MathArray<T>::ApplyFunctionInPlace(TArray<T> & a, Arr_DoubleFunctionOfX f)
@@ -36,4 +43,10 @@
 }
 
+//! Apply Function In Place (function float version)
+/*!
+  \param a : array to be replaced in place
+  \param f : function for replacement
+  \return Return an array \b a filled with function f(a(i,j))
+*/
 template <class T>
 TArray<T>& MathArray<T>::ApplyFunctionInPlace(TArray<T> & a, Arr_FloatFunctionOfX f)
@@ -63,4 +76,10 @@
 
 
+//! Apply Function (function double version)
+/*!
+  \param a : argument array of the function
+  \param f : function for replacement
+  \return Return a new array filled with function f(a(i,j))
+*/
 template <class T>
 TArray<T> MathArray<T>::ApplyFunction(TArray<T> const & a, Arr_DoubleFunctionOfX f)
@@ -72,4 +91,10 @@
 }
 
+//! Apply Function (function float version)
+/*!
+  \param a : argument array of the function
+  \param f : function for replacement
+  \return Return a new array filled with function f(a(i,j))
+*/
 template <class T>
 TArray<T> MathArray<T>::ApplyFunction(TArray<T> const & a, Arr_FloatFunctionOfX f)
@@ -81,4 +106,5 @@
 }
 
+//! Compute \b mean and \b sigma of elements of array \b a, return \b mean
 template <class T>
 double MathArray<T>::MeanSigma(TArray<T> const & a, double & mean, double & sig)
Index: trunk/SophyaLib/TArray/matharr.h
===================================================================
--- trunk/SophyaLib/TArray/matharr.h	(revision 893)
+++ trunk/SophyaLib/TArray/matharr.h	(revision 894)
@@ -12,7 +12,8 @@
 namespace SOPHYA {
 
-//       Class for simple mathematical operation on arrays 
-//   Instanciated only for real and double (r_4, r_8) type arrays 
-//                                                Reza 03/2000
+//! Class for simple mathematical operation on arrays 
+/*!
+  \warning Instanciated only for \b real and \b double (r_4, r_8) type arrays
+*/
 template <class T>
 class MathArray {
@@ -84,8 +85,10 @@
 #endif
 
+//! 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
 template <class T>
 inline double Mean(const TArray<T>& a)
Index: trunk/SophyaLib/TArray/tarray.cc
===================================================================
--- trunk/SophyaLib/TArray/tarray.cc	(revision 893)
+++ trunk/SophyaLib/TArray/tarray.cc	(revision 894)
@@ -15,12 +15,20 @@
 // -------------------------------------------------------
 
-// Les constructeurs 
+////////////////////////// Les constructeurs / destructeurs
+
+//! Default constructor
 template <class T>
 TArray<T>::TArray()
   : BaseArray() , mNDBlock() 
-// Default constructor
-{
-}
-
+{
+}
+
+//! Constructor
+/*!
+  \param ndim : number of dimensions (less or equal to
+                \ref BASEARRAY_MAXNDIMS "BASEARRAY_MAXNDIMS")
+  \param siz[ndim] : size along each dimension
+  \param step : step (same for all dimensions)
+ */
 template <class T>
 TArray<T>::TArray(uint_4 ndim, const uint_4 * siz, uint_4 step)
@@ -31,4 +39,8 @@
 }
 
+//! Constructor
+/*!
+  \param nx,ny,nz,nt,nu : sizes along first, second, third, fourth and fifth dimension
+ */
 template <class T>
 TArray<T>::TArray(uint_4 nx, uint_4 ny, uint_4 nz, uint_4 nt, uint_4 nu)
@@ -48,4 +60,13 @@
 }
 
+//! Constructor
+/*!
+  \param ndim : number of dimensions
+  \param siz[ndim] : size along each dimension
+  \param db : datas are given by this NDataBlock
+  \param share : if true, data are shared, if false they are copied
+  \param step : step (same for all dimensions) in data block
+  \param offset : offset for first element in data block
+ */
 template <class T>
 TArray<T>::TArray(uint_4 ndim, const uint_4 * siz, NDataBlock<T> & db, bool share, uint_4 step, uint_8 offset)
@@ -57,4 +78,15 @@
 }
 
+//! Constructor
+/*!
+  \param ndim : number of dimensions
+  \param siz[ndim] : size along each dimension
+  \param values : datas are given by this pointer
+  \param share : if true, data are shared, if false they are copied
+  \param step : step (same for all dimensions) in data block
+  \param offset : offset for first element in data block
+  \param br : if not NULL, dats are bridge with other datas
+  \sa NDataBlock
+ */
 template <class T>
 TArray<T>::TArray(uint_4 ndim, const uint_4 * siz, T* values, uint_4 step, uint_8 offset, Bridge* br)
@@ -65,4 +97,5 @@
 }
 
+//! Constructor by copy
 template <class T>
 TArray<T>::TArray(const TArray<T>& a)
@@ -74,4 +107,8 @@
 }
 
+//! Constructor by copy
+/*!
+  \param share : if true, data are shared, if false they are copied
+ */
 template <class T>
 TArray<T>::TArray(const TArray<T>& a, bool share)
@@ -83,5 +120,5 @@
 }
 
-// Destructeur 
+//! Destructor 
 template <class T>
 TArray<T>::~TArray()
@@ -89,4 +126,7 @@
 }
 
+////////////////////////// Les methodes de copie/share
+
+//! Set array equal to \b a and return *this
 template <class T>
 TArray<T>& TArray<T>::Set(const TArray<T>& a)
@@ -94,5 +134,5 @@
   if (this != &a) { 
     CloneOrShare(a);
-    if (mInfo) delete mInfo;
+    if (mInfo) {delete mInfo; mInfo = NULL;}
     if (a.mInfo) mInfo = new DVList(*(a.mInfo));
   }
@@ -100,4 +140,5 @@
 }
 
+//! Clone array \b a
 template <class T>
 void TArray<T>::Clone(const TArray<T>& a)
@@ -106,8 +147,14 @@
   if (!UpdateSizes(a, exmsg))  throw( ParmError(exmsg) );
   mNDBlock.Clone(a.mNDBlock);
-  if (mInfo) delete mInfo;
+  if (mInfo) {delete mInfo; mInfo = NULL;}
   if (a.mInfo) mInfo = new DVList(*(a.mInfo));
 }
 
+//! Resize array
+/*!
+  \param ndim : number of dimensions
+  \param siz[ndim] : size along each dimension
+  \param step : step (same for all dimensions)
+ */
 template <class T>
 void TArray<T>::ReSize(uint_4 ndim, uint_4 * siz, uint_4 step)
@@ -118,4 +165,12 @@
 }
 
+//! Re-allocate space for array
+/*!
+  \param ndim : number of dimensions
+  \param siz[ndim] : size along each dimension
+  \param step : step (same for all dimensions)
+  \param force : if true re-allocation is forced, if not it occurs
+          only if the required space is greater than the old one.
+ */
 template <class T>
 void TArray<T>::Realloc(uint_4 ndim, uint_4 * siz, uint_4 step, bool force)
@@ -127,4 +182,5 @@
 
 
+//! Compact dimensions in one or more is equal to 1.
 template <class T>
 TArray<T>& TArray<T>::CompactAllDimensions()
@@ -134,4 +190,5 @@
 }
 
+//! Compact dimensions if the last one is equal to 1.
 template <class T>
 TArray<T>& TArray<T>::CompactTrailingDimensions()
@@ -141,4 +198,5 @@
 }
 
+//! Give value (in \b double) for element at position \b ip..
 template <class T>
 double TArray<T>::ValueAtPosition(uint_8 ip) const
@@ -150,5 +208,8 @@
 }
 
-// For complex values, we return the module of the complex number
+//! Give value (in \b double) for element at position \b ip..
+/*!
+  For complex values, we return the module of the complex number
+*/
 double TArray< complex<r_4> >::ValueAtPosition(uint_8 ip) const
 {
@@ -162,4 +223,8 @@
 }
 
+//! Give value (in \b double) for element at position \b ip..
+/*!
+  For complex values, we return the module of the complex number
+*/
 double TArray< complex<r_8> >::ValueAtPosition(uint_8 ip) const
 {
@@ -173,5 +238,11 @@
 }
 
-
+//! Return array with elements packed
+/*!
+  \param force : if true, pack elements in a new array.
+                 If false and array is already packed, return
+                 an array that share data with the current one.
+  \return packed array
+ */
 template <class T>
 TArray<T> TArray<T>::PackElements(bool force) const
@@ -194,4 +265,9 @@
 // SubArrays 
 // $CHECK$ Reza 03/2000  Doit-on declarer cette methode const ?
+//! Extract a sub-array
+/*!
+  \param rx,ry,rz,rt,ru : range of extraction along dimensions
+  \sa Range
+ */
 template <class T>
 TArray<T> TArray<T>::SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const
@@ -232,5 +308,11 @@
 //              ------- Attention --------
 //  Boucles normales prenant en compte les steps ....
-//  Possibilite de // , vectorisation 
+//  Possibilite de // , vectorisation
+
+//! Fill TArray with Sequence \b seq
+/*!
+  \param seq : sequence to fill the array
+  \sa Sequence
+ */
 template <class T>
 TArray<T>& TArray<T>::SetSeq(Sequence seq)
@@ -261,4 +343,5 @@
 //  >>>> Operations avec 2nd membre de type scalaire 
 
+//! Fill an array with a constant value \b x
 template <class T>
 TArray<T>& TArray<T>::SetT(T x)
@@ -287,4 +370,5 @@
 }
 
+//! Add a constant value \b x to an array
 template <class T>
 TArray<T>& TArray<T>::Add(T x)
@@ -313,4 +397,5 @@
 }
 
+//! Substract a constant value \b x to an array
 template <class T>
 TArray<T>& TArray<T>::Sub(T x)
@@ -339,4 +424,5 @@
 }
 
+//! Multiply an array by a constant value \b x
 template <class T>
 TArray<T>& TArray<T>::Mul(T x)
@@ -365,4 +451,5 @@
 }
 
+//! Divide an array by a constant value \b x
 template <class T>
 TArray<T>& TArray<T>::Div(T x)
@@ -370,4 +457,6 @@
   if (NbDimensions() < 1) 
     throw RangeCheckError("TArray<T>::Div(T )  - Not Allocated Array ! ");
+  if (x == (T) 0 ) 
+    throw MathExc("TArray<T>::Div(T )  - Divide by zero ! ");
   T * pe;
   uint_8 j,k;
@@ -392,4 +481,5 @@
 
 
+//! Inverse substract : A = \b x - A
 template <class T>
 TArray<T>& TArray<T>::SubInv(T x)
@@ -418,4 +508,5 @@
 }
 
+//! Inverse Divide : A(i,j,...) = x / A(i,j,...)
 template <class T>
 TArray<T>& TArray<T>::DivInv(T x)
@@ -446,4 +537,5 @@
 
 //  >>>> Operations avec 2nd membre de type tableau
+//! Add two TArrays
 template <class T>
 TArray<T>& TArray<T>::AddElt(const TArray<T>& a)
@@ -480,4 +572,5 @@
 }
 
+//! Substract two TArrays
 template <class T>
 TArray<T>& TArray<T>::SubElt(const TArray<T>& a)
@@ -514,5 +607,5 @@
 }
 
-
+//! Multiply two TArrays (elements by elements)
 template <class T>
 TArray<T>& TArray<T>::MulElt(const TArray<T>& a)
@@ -550,4 +643,5 @@
 
 
+//! Divide two TArrays (elements by elements)
 template <class T>
 TArray<T>& TArray<T>::DivElt(const TArray<T>& a)
@@ -584,4 +678,5 @@
 }
 
+//! Copy elements of \b a
 template <class T>
 TArray<T>& TArray<T>::CopyElt(const TArray<T>& a)
@@ -620,4 +715,5 @@
 
 // Somme et produit des elements
+//! Sum all elements
 template <class T>
 T TArray<T>::Sum() const
@@ -647,4 +743,5 @@
 }
 
+//! Multiply all elements
 template <class T>
 T TArray<T>::Product() const
@@ -680,4 +777,5 @@
 // ----------------------------------------------------
 
+//! Return a string that contain the type \b T of the array
 template <class T>
 string TArray<T>::InfoString() const
@@ -689,4 +787,11 @@
 }
 
+//! Print array
+/*!
+  \param os : output stream
+  \param maxprt : maximum numer of print
+  \param si : if true,  display attached DvList
+  \sa SetMaxPrint
+ */
 template <class T>
 void TArray<T>::Print(ostream& os, int_4 maxprt, bool si) const
@@ -720,5 +825,5 @@
 }
 
-
+//! Clone if \b a is not temporary, share if temporary
 template <class T>
 void TArray<T>::CloneOrShare(const TArray<T>& a)
@@ -729,4 +834,5 @@
 }
 
+//! Share data with a
 template <class T>
 void TArray<T>::Share(const TArray<T>& a)
Index: trunk/SophyaLib/TArray/tarray.h
===================================================================
--- trunk/SophyaLib/TArray/tarray.h	(revision 893)
+++ trunk/SophyaLib/TArray/tarray.h	(revision 894)
@@ -23,4 +23,9 @@
 //  ( See BaseArray class for data organisation in  memory and related methods )
 
+//! Class for template arrays
+/*!
+  This class implements arrays of dimensions up to
+  \ref BASEARRAY_MAXNDIMS "BASEARRAY_MAXNDIMS"
+*/
 template <class T>
 class TArray : public BaseArray {
@@ -38,4 +43,6 @@
 
   // A = B : partage les donnees si "a" est temporaire, clone sinon.
+  //! = operator between TArray
+  /*! \sa Set */
   inline  TArray<T>& operator = (const TArray<T>& a) { return Set(a); }
   virtual TArray<T>& Set(const TArray<T>& a);
@@ -54,5 +61,7 @@
 
   // SubArrays - $CHECK$ Reza 03/2000 je ne sais pas s'il faut declarer ca const ??
-  TArray<T> SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const ; 
+  TArray<T> SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const ;
+  //! () operator for Sub arrays extraction
+  /*! \sa SubArray */
   inline TArray<T> operator () (Range rx, Range ry, Range rz, Range rt=0, Range ru=0) const
                    { return  SubArray(rx, ry, rz, rt, ru); }
@@ -75,11 +84,17 @@
   inline T&       ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0);
 
+  //! Return pointer to first element adress
   inline        T* Data()       {return mNDBlock.Begin()+offset_;}
+  //! Return pointer to first element adress
   inline const  T* Data() const {return mNDBlock.Begin()+offset_;}
+  //! Return reference to datablock NDataBlock
   inline        NDataBlock<T>& DataBlock()       {return mNDBlock;}
+  //! Return reference to datablock NDataBlock
   inline const  NDataBlock<T>& DataBlock() const {return mNDBlock;}
 
   // Temporaire?
+  //! Are the array temporay ?
   inline bool   IsTemp(void) const {return mNDBlock.IsTemp();}
+  //! Set the array as temporay
   inline void   SetTemp(bool temp=false) const {mNDBlock.SetTemp(temp);}
 
@@ -89,16 +104,22 @@
 // Met les elements a une suite de valeurs
   virtual TArray<T>&  SetSeq(Sequence seq);
+  //! Fill TArray with Sequence \b seq
   inline  TArray<T>&  operator = (Sequence seq)    { return SetSeq(seq); }
 // A = x (tous les elements a x)
   virtual TArray<T>&  SetT(T x);
+  //! Fill TArray with all elements equal to \b x
   inline  TArray<T>&  operator = (T x)             { return SetT(x); }
 // A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
   virtual TArray<T>&  Add(T x);
+  //! Add \b x to all elements
   inline  TArray<T>&  operator += (T x)            { return Add(x); }
   virtual TArray<T>&  Sub(T x);
+  //! Substract \b x to all elements
   inline  TArray<T>&  operator -= (T x)            { return Sub(x); }
   virtual TArray<T>&  Mul(T x);
+  //! Multiply all elements by \b x
   inline  TArray<T>&  operator *= (T x)            { return Mul(x); }
   virtual TArray<T>&  Div(T x);
+  //! Divide all elements by \b x
   inline  TArray<T>&  operator /= (T x)            { return Div(x); }
   virtual TArray<T>&  SubInv(T x);  //   A ---> x-A
@@ -107,6 +128,8 @@
 // A += -=  (ajoute, soustrait element par element les deux tableaux )
   virtual TArray<T>&  AddElt(const TArray<T>& a);
+  //! Operator TArray += TArray
   inline  TArray<T>&  operator += (const TArray<T>& a)  { return AddElt(a); }
   virtual TArray<T>&  SubElt(const TArray<T>& a);
+  //! Operator TArray -= TArray
   inline  TArray<T>&  operator -= (const TArray<T>& a)  { return SubElt(a); }
 // Multiplication, division element par element les deux tableaux 
@@ -133,9 +156,10 @@
   void Share(const TArray<T>& a);
 
-  NDataBlock<T> mNDBlock;      // Le bloc des donnees
+  NDataBlock<T> mNDBlock; //!< Block for datas
 };
 
 ////////////////////////////////////////////////////////////////
 //   Surcharge d'operateur << 
+//! Print TArray \b a on stream \b os
 template <class T>
 inline ostream& operator << (ostream& os, const TArray<T>& a)
@@ -145,22 +169,29 @@
 // Surcharge d'operateurs A (+,-,*,/) (T) x
 
+//! 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
 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
 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
 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
 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
 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
 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;}
@@ -169,8 +200,10 @@
 // Surcharge d'operateurs C = A (+,-) B
 
+//! 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
 template <class T>
 inline TArray<T> operator - (const TArray<T>& a,const TArray<T>& b)
@@ -181,4 +214,6 @@
 //        inline element acces methods
 // --------------------------------------------------
+
+//! Return element (ix,iy,iz,it,iu) value
 template <class T>
 inline T const& TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
@@ -189,4 +224,5 @@
 }
 
+//! Return element (ix,iy,iz,it,iu) value
 template <class T>
 inline T & TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
@@ -197,4 +233,5 @@
 }
 
+//! Return element (ix,iy,iz,it,iu) value with Check of indexes bound first
 template <class T>
 inline T const& TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
@@ -204,4 +241,5 @@
 }
 
+//! Return element (ix,iy,iz,it,iu) value with Check of indexes bound first
 template <class T>
 inline T & TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
@@ -211,4 +249,5 @@
 }
 
+//! Return element (ix,iy,iz) value
 template <class T>
 inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz) const
@@ -221,4 +260,5 @@
 }
 
+//! Return element (ix,iy,iz) value
 template <class T>
 inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz) 
@@ -231,4 +271,5 @@
 }
 
+//! Operator () : return element (ix,iy,iz,it,iu) value
 template <class T>
 inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
@@ -242,4 +283,5 @@
 }
 
+//! Operator () : return element (ix,iy,iz,it,iu) value
 template <class T>
 inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
@@ -254,4 +296,5 @@
 
 
+//! Operator [] : return element at positon ip
 template <class T>
 inline T const& TArray<T>::operator[](uint_8 ip) const
@@ -263,4 +306,5 @@
 }
 
+//! Operator [] : return element at positon ip
 template <class T>
 inline T & TArray<T>::operator[](uint_8 ip) 
@@ -273,4 +317,5 @@
 
 
+//! Return the value of first element
 template <class T>
 inline T TArray<T>::toScalar()
@@ -281,4 +326,5 @@
 
 // Typedef pour simplifier
+//! To simplify, Array \<==\> TArray<r_8>
 typedef TArray<r_8> Array;
 
Index: trunk/SophyaLib/TArray/tarrinit.h
===================================================================
--- trunk/SophyaLib/TArray/tarrinit.h	(revision 893)
+++ trunk/SophyaLib/TArray/tarrinit.h	(revision 894)
@@ -11,4 +11,5 @@
 namespace SOPHYA {
 
+//! Class to initialize the TArray's classes
 class TArrayInitiator : public SophyaInitiator {
 private:
Index: trunk/SophyaLib/TArray/tmatrix.cc
===================================================================
--- trunk/SophyaLib/TArray/tmatrix.cc	(revision 893)
+++ trunk/SophyaLib/TArray/tmatrix.cc	(revision 894)
@@ -1,3 +1,3 @@
-// $Id: tmatrix.cc,v 1.5 2000-04-10 12:57:44 ansari Exp $
+// $Id: tmatrix.cc,v 1.6 2000-04-12 17:42:21 ansari Exp $
 //                         C.Magneville          04/99
 #include "machdefs.h"
@@ -12,4 +12,5 @@
 ////////////////////////////////////////////////////////////////
 //**** Createur, Destructeur
+//! Default constructor
 template <class T>
 TMatrix<T>::TMatrix()
@@ -20,4 +21,11 @@
 }
 
+//! constructor of a matrix with  r lines et c columns.
+/*!
+  \param r : number of rows
+  \param c : number of columns
+  \param mm : define the memory mapping type
+  \sa ReSize
+ */
 template <class T>
 TMatrix<T>::TMatrix(uint_4 r,uint_4 c, short mm)
@@ -30,4 +38,5 @@
 }
 
+//! Constructor by copy (share data if \b a is temporary).
 template <class T>
 TMatrix<T>::TMatrix(const TMatrix<T>& a)
@@ -37,4 +46,8 @@
 }
 
+//! Constructor by copy
+/*!
+  \param share : if true, share data. If false copy data
+ */
 template <class T>
 TMatrix<T>::TMatrix(const TMatrix<T>& a, bool share)
@@ -44,5 +57,5 @@
 }
 
-
+//! Constructor of a matrix from a TArray \b a
 template <class T>
 TMatrix<T>::TMatrix(const TArray<T>& a)
@@ -59,4 +72,10 @@
 }
 
+//! Constructor of a matrix from a TArray \b a
+/*!
+  \param a : TArray to be copied or shared
+  \param share : if true, share data. If false copy data
+  \param mm : define the memory mapping type
+ */
 template <class T>
 TMatrix<T>::TMatrix(const TArray<T>& a, bool share, short mm )
@@ -73,11 +92,11 @@
 }
 
+//! Destructor
 template <class T>
 TMatrix<T>::~TMatrix()
-// Destructeur
-{
-
-}
-
+{
+}
+
+//! Set matirx equal to \b a and return *this
 template <class T>
 TArray<T>& TMatrix<T>::Set(const TArray<T>& a)
@@ -95,4 +114,12 @@
 }
 
+//! Resize the matrix
+/*!
+  \param r : number of rows
+  \param c : number of columns
+  \param mm : define the memory mapping type
+         (SameMemoryMapping,CMemoryMapping
+         ,FortranMemoryMapping,DefaultMemoryMapping)
+ */
 template <class T>
 void TMatrix<T>::ReSize(uint_4 r, uint_4 c, short mm)
@@ -115,4 +142,13 @@
 }
 
+//! Re-allocate space for the matrix
+/*!
+  \param r : number of rows
+  \param c : number of columns
+  \param mm : define the memory mapping type
+  \param force : if true re-allocation is forced, if not it occurs
+          only if the required space is greater than the old one.
+  \sa ReSize
+ */
 template <class T>
 void TMatrix<T>::Realloc(uint_4 r,uint_4 c, short mm, bool force)
@@ -136,4 +172,5 @@
 
 // $CHECK$ Reza 03/2000  Doit-on declarer cette methode const ?
+//! Return a submatrix define by \b Range \b rline and \b rcol
 template <class T>
 TMatrix<T> TMatrix<T>::SubMatrix(Range rline, Range rcol) const
@@ -151,4 +188,5 @@
 ////////////////////////////////////////////////////////////////
 // Transposition
+//! Transpose matrix in place
 template <class T>
 TMatrix<T>& TMatrix<T>::Transpose() 
@@ -163,4 +201,10 @@
 
 
+//! Transpose matrix into new matrix
+/*!
+  \param mm : define the memory mapping type
+    (SameMemoryMapping,CMemoryMapping,FortranMemoryMapping)
+  \return return a new matrix
+ */
 template <class T>
 TMatrix<T> TMatrix<T>::Transpose(short mm)
@@ -175,6 +219,10 @@
 }
 
-// Rearrangement memoire
-// Si identique, renvoie une matrice qui partage les donnees 
+//! Rearrange data in memory memoire according to \b mm
+/*!
+  \param mm : define the memory mapping type
+    (SameMemoryMapping,CMemoryMapping,FortranMemoryMapping)
+  \warning If identical, return a matrix that share the datas
+ */
 template <class T>
 TMatrix<T> TMatrix<T>::Rearrange(short mm)
@@ -195,4 +243,5 @@
 }
 
+//! Set the matrix to the identity matrix \b imx
 template <class T>
 TMatrix<T>& TMatrix<T>::SetIdentity(IdentityMatrix imx)
@@ -215,4 +264,5 @@
 ////////////////////////////////////////////////////////////////
 //**** Impression
+//! Return info on number of rows, column and type \b T
 template <class T>
 string TMatrix<T>::InfoString() const
@@ -226,4 +276,10 @@
 }
 
+//! Print matrix
+/*!
+  \param maxprt : maximum numer of print
+  \param si : if true,  display attached DvList
+  \sa SetMaxPrint
+ */
 template <class T>
 void TMatrix<T>::Print(ostream& os, int_4 maxprt, bool si) const
@@ -252,4 +308,8 @@
 ////////////////////////////////////////////////////////////////
 
+//! Return the matrix product C = (*this)*B
+/*!
+  \param mm : define the memory mapping type for the return matrix
+ */
 template <class T>
 TMatrix<T> TMatrix<T>::Multiply(const TMatrix<T>& b, short mm) const
Index: trunk/SophyaLib/TArray/tmatrix.h
===================================================================
--- trunk/SophyaLib/TArray/tmatrix.h	(revision 893)
+++ trunk/SophyaLib/TArray/tmatrix.h	(revision 894)
@@ -8,4 +8,9 @@
 
 namespace SOPHYA {
+
+//! Class of matrixes
+/*!
+  \sa TArray
+ */
 
 template <class T>
@@ -23,10 +28,14 @@
   //  Pour verifiez la compatibilite de dimensions lors de l'affectation
   virtual TArray<T>& Set(const TArray<T>& a);
+  //! Operator = between matrices
   inline  TMatrix<T>& operator = (const TMatrix<T>& a)
-                       { Set(a);  return(*this); }
+                     { Set(a);  return(*this); }
 
   // Size - Changing the Size 
+  //! return number of rows
   inline uint_4 NRows() const {return Size(marowi_); }
+  //! return number of columns
   inline uint_4 NCols() const {return Size(macoli_); }
+  //! return number of columns
   inline uint_4 NCol()  const {return Size(macoli_); } // back-compat Peida
 
@@ -36,9 +45,12 @@
   // Sub-matrix extraction $CHECK$ Reza 03/2000  Doit-on declarer ces methode const ?
   TMatrix<T> SubMatrix(Range rline, Range rcol) const ;
+  //! () : Return submatrix define by \b Range \b rline and \b rcol
   inline TMatrix<T> operator () (Range rline, Range rcol) const 
                     { return SubMatrix(rline, rcol); }
   // Lignes et colonnes de la matrice
+  //! Return submatrix define by line \b ir (line vector)
   inline TMatrix<T> Row(uint_4 ir) const
                     { return SubMatrix(Range(ir,ir), Range(0,NCols()-1)); }
+  //! Return submatrix define by column \b ic (column vector)
   inline TMatrix<T> Column(uint_4 ic) const
                     { return SubMatrix(Range(0,NRows()-1), Range(ic,ic)); }
@@ -58,20 +70,29 @@
   // A = x (matrice diagonale Identite)
   virtual TMatrix<T>& SetIdentity(IdentityMatrix imx);
+  // = : fill matrix with an identity matrix \b imx
   inline  TMatrix<T>& operator = (IdentityMatrix imx) { return SetIdentity(imx); }
 
+  // = : fill matrix with a Sequence \b seq
   inline  TMatrix<T>&  operator = (Sequence seq)    { SetSeq(seq); return(*this); }
 
   // Operations diverses  avec une constante
+  //! = : fill matrix with constant value \b x
   inline  TMatrix<T>&  operator = (T x)             { SetT(x); return(*this); }
+  //! += : add constant value \b x to matrix
   inline  TMatrix<T>&  operator += (T x)            { Add(x); return(*this); }
+  //! -= : substract constant value \b x to matrix
   inline  TMatrix<T>&  operator -= (T x)            { Sub(x); return(*this); }
+  //! *= : multiply matrix by constant value \b x
   inline  TMatrix<T>&  operator *= (T x)            { Mul(x); return(*this); }
+  //! /= : divide matrix by constant value \b x
   inline  TMatrix<T>&  operator /= (T x)            { Div(x); return(*this); }
 
   //  operations avec matrices 
+  //! += : add a matrix
   inline  TMatrix<T>&  operator += (const TMatrix<T>& a)  { AddElt(a); return(*this); }
+  //! -= : substract a matrix
   inline  TMatrix<T>&  operator -= (const TMatrix<T>& a)  { SubElt(a); return(*this); }
-  // Produit matriciel Multiply : C = (*this)*B
   TMatrix<T>  Multiply(const TMatrix<T>& b, short mm=SameMemoryMapping) const;
+  //! *= : matrix product : C = (*this)*B
   inline  TMatrix<T>&  operator *= (const TMatrix<T>& b)
           { this->Set(Multiply(b));  return(*this); }
@@ -85,4 +106,5 @@
 
 //  ---- inline acces methods ------
+ //! () : return element for line \b r and column \b c
 template <class T>
 inline T const& TMatrix<T>::operator()(uint_4 r, uint_4 c) const
@@ -96,4 +118,5 @@
 }
 
+//! () : return element for line \b r and column \b c
 template <class T>
 inline T & TMatrix<T>::operator()(uint_4 r, uint_4 c) 
@@ -113,8 +136,10 @@
 // Doit-on le faire aussi pour les constantes ? - Fin de $CHECK$ Reza 3/4/2000
 
+//! + : 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
 template <class T>
 inline TMatrix<T> operator - (const TMatrix<T>& a,const TMatrix<T>& b)
@@ -122,8 +147,9 @@
 
 // Surcharge d'operateurs C = A * B
-
+//! - : 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)); }
 
+//! Define Matrix to be TMatrix<r_8>
 typedef TMatrix<r_8> Matrix;
 
Index: trunk/SophyaLib/TArray/tvector.cc
===================================================================
--- trunk/SophyaLib/TArray/tvector.cc	(revision 893)
+++ trunk/SophyaLib/TArray/tvector.cc	(revision 894)
@@ -1,3 +1,3 @@
-// $Id: tvector.cc,v 1.3 2000-04-05 15:44:17 ansari Exp $
+// $Id: tvector.cc,v 1.4 2000-04-12 17:42:30 ansari Exp $
 //                         C.Magneville          04/99
 #include "machdefs.h"
@@ -9,4 +9,5 @@
 //**** Createur, Destructeur
 
+//! Default constructor
 template <class T>
 TVector<T>::TVector()
@@ -15,4 +16,11 @@
 }
 
+//! construct a vector
+/*!
+  \param n : number of elements
+  \param lcv : line or column vector ?
+  \param mm : memory mapping type
+  \sa SelectVectorType
+ */
 template <class T>
 TVector<T>::TVector(uint_4 n, short lcv, short mm)
@@ -24,5 +32,5 @@
 }
 
-
+//! Constructor by copy (share if \b a is temporary)
 template <class T>
 TVector<T>::TVector(const TVector<T>& a)
@@ -32,4 +40,8 @@
 }
 
+//! Constructor by copy
+/*!
+  \param share : if true, share data. If false copy data
+ */
 template <class T>
 TVector<T>::TVector(const TVector<T>& a, bool share)
@@ -39,4 +51,5 @@
 }
 
+//! Constructor from a TArray
 template <class T>
 TVector<T>::TVector(const TArray<T>& a)
@@ -48,4 +61,12 @@
 
 
+//! Constructor of a vector from a TArray \b a
+/*!
+  \param a : TArray to be copied or shared
+  \param share : if true, share data. If false copy data
+  \param mm : define the memory mapping type
+  \param lcv : line or column vector ?
+  \sa SelectVectorType
+ */
 template <class T>
 TVector<T>::TVector(const TArray<T>& a, bool share, short mm, short lcv )
@@ -61,11 +82,16 @@
 }
 
+//! Destructor
 template <class T>
 TVector<T>::~TVector()
-// Destructeur
 {
-
 }
 
+//! Resize the vector
+/*!
+  \param n : number of elements
+  \param lcv : line or column vector ?
+  \sa SelectVectorType
+ */
 template <class T>
 void TVector<T>::ReSize(uint_4 n, short lcv)
@@ -82,4 +108,12 @@
 }
 
+//! Re-allocate space for the vector
+/*!
+  \param n : number of elements
+  \param lcv : line or column vector ?
+  \param force : if true re-allocation is forced, if not it occurs
+          only if the required space is greater than the old one.
+  \sa ReSize SelectVectorType
+ */
 template <class T>
 void TVector<T>::Realloc(uint_4 n, short lcv, bool force)
@@ -97,4 +131,5 @@
 
 // $CHECK$ Reza 03/2000  Doit-on declarer cette methode const ?
+//! Return a subvector define by \b Range \b relt
 template <class T>
 TVector<T> TVector<T>::SubVector(Range relt) const
@@ -109,4 +144,5 @@
 }
 
+//! Return the norm \f$ \sum{V(i)^2} \f$
 template <class T>
 T TVector<T>::Norm2() const
@@ -117,4 +153,5 @@
 }
 
+//! Return info on number of rows, column and type \b T
 template <class T>
 string TVector<T>::InfoString() const
Index: trunk/SophyaLib/TArray/tvector.h
===================================================================
--- trunk/SophyaLib/TArray/tvector.h	(revision 893)
+++ trunk/SophyaLib/TArray/tvector.h	(revision 894)
@@ -8,4 +8,8 @@
 namespace SOPHYA {
 
+//! Class of vector (line or column)
+/*!
+  \sa TMatrix TArray
+  */
 template <class T>
 class TVector : public TMatrix<T> {
@@ -21,4 +25,5 @@
   virtual ~TVector();
 
+  //! Operator =
   inline  TVector<T>& operator = (const TVector<T>& a)
                        { Set(a);  return(*this); }
@@ -31,8 +36,10 @@
   // Sub-Vector extraction $CHECK$ Reza 03/2000  Doit-on declarer cette methode const ?
   TVector<T> SubVector(Range relt) const ;
+  //! Extract a vector define by Range \b relt
   inline TVector<T> operator () (Range relt) const 
                     { return SubVector(relt); }
 
   // Informations pointeur/data
+  //! return the number of elements
   inline uint_4 NElts() const {return Size(); }
   
@@ -42,15 +49,23 @@
 
   // Operateur d'affectation
+  //! Fill the 
   inline  TMatrix<T>&  operator = (Sequence seq)    { SetSeq(seq); return(*this); }
 
   // Operations diverses  avec une constante
+  //! Set vector elements to constant value \b x
   inline  TVector<T>&  operator = (T x)             { SetT(x); return(*this); }
+  //! Add constant value \b x to vector elements
   inline  TVector<T>&  operator += (T x)            { Add(x); return(*this); }
+  //! Substract constant value \b x to vector elements
   inline  TVector<T>&  operator -= (T x)            { Sub(x); return(*this); }
+  //! Multiply vector elements by constant value \b x
   inline  TVector<T>&  operator *= (T x)            { Mul(x); return(*this); }
+  //! Divide vector elements by constant value \b x
   inline  TVector<T>&  operator /= (T x)            { Div(x); return(*this); }
 
   //  operations avec matrices 
+  //! += : add a vector in place
   inline  TVector<T>&  operator += (const TVector<T>& a)  { AddElt(a); return(*this); }
+  //! += : substract a vector in place
   inline  TVector<T>&  operator -= (const TVector<T>& a)  { SubElt(a); return(*this); }
 
@@ -63,4 +78,6 @@
 
 //  ---- inline acces methods ------
+
+//! Return the value of element \b n
 template <class T>
 inline T const& TVector<T>::operator()(uint_4 n) const
@@ -73,4 +90,5 @@
 }
 
+//! Return the value of element \b n
 template <class T>
 inline T & TVector<T>::operator()(uint_4 n) 
@@ -84,4 +102,5 @@
 
 // Typedef pour simplifier et compatibilite Peida
+//! Define Vector to be TVector<r_8>
 typedef TVector<r_8> Vector;
 
Index: trunk/SophyaLib/TArray/utilarr.cc
===================================================================
--- trunk/SophyaLib/TArray/utilarr.cc	(revision 893)
+++ trunk/SophyaLib/TArray/utilarr.cc	(revision 894)
@@ -8,4 +8,11 @@
 // Classe utilitaires
 
+//////////////////////////////////////////////////////////
+//! Constructor
+/*!
+  \param typ : generator type
+  \param m : mean parameter of the generator (if needed)
+  \param s : sigma parameter of the generator (if needed)
+ */
 RandomSequence::RandomSequence(int typ, double m, double s)
 {
@@ -15,4 +22,5 @@
 }
 
+//! Return random sequence values.
 double RandomSequence::Rand()
 {
@@ -23,4 +31,13 @@
 
 
+//////////////////////////////////////////////////////////
+//! Constructor
+/*!
+  \param start : start value
+  \param step : step value
+  \param f : pointer to the sequence function
+
+  See \ref SequenceOperat "operator()"
+ */
 Sequence::Sequence(double start, double step, Arr_DoubleFunctionOfX f)
   : rseq_(RandomSequence::Gaussian)
@@ -32,4 +49,10 @@
 }
 
+//! Constructor
+/*!
+  \param rseq : RandomSequence
+
+  See \ref SequenceOperat "operator()"
+ */
 Sequence::Sequence(RandomSequence rseq)
 {
@@ -41,4 +64,17 @@
 }
 
+//! Get the \b k th value
+/*!
+  \param k : index of the value
+  \anchor SequenceOperat
+
+  If the constructor was done with RandomSequence, return a RandomSequence
+  and \b k doesn't matter.
+
+  If the constructor has a NULL Arr_DoubleFunctionOfX, return start+k*step
+
+  If the constructor has a not NULL Arr_DoubleFunctionOfX, return f(start+k*step)
+  \return the \b k th value
+ */
 double Sequence::operator () (uint_4 k)
 {
@@ -51,4 +87,16 @@
 }
 
+//////////////////////////////////////////////////////////
+//! Constructor
+/*!
+  Define a range of indexes
+  \param start : start index
+  \param end : start end
+  \param size : size
+  \param step : step
+
+  \warning If \b end \> \b start, \b size is computed automatically
+  \warning If not \b size is fixed and \b end recomputed
+ */
 Range::Range(uint_4 start, uint_4 end, uint_4 size, uint_4 step)
 {
@@ -77,4 +125,6 @@
 
 
+//////////////////////////////////////////////////////////
+//! Constructor of a (n,n) diagonal matrix with value diag on the diagonal
 IdentityMatrix::IdentityMatrix(double diag, uint_4 n)
 {
Index: trunk/SophyaLib/TArray/utilarr.h
===================================================================
--- trunk/SophyaLib/TArray/utilarr.h	(revision 893)
+++ trunk/SophyaLib/TArray/utilarr.h	(revision 894)
@@ -13,51 +13,79 @@
 /* Quelques utilitaires pour les tableaux (Array) */             
 
+//! define a function of double which returns a double
 typedef double (* Arr_DoubleFunctionOfX) (double x);
+//! define a function of float which returns a float
 typedef float  (* Arr_FloatFunctionOfX)  (float x);
 
+//////////////////////////////////////////////////////////
+//! Class to generate a random sequence of values
 class RandomSequence {
 public:
-  enum { Gaussian = 0, Flat = 1 };
+  //! to define the generator type
+  enum {
+    Gaussian = 0, //!< gaussian generator
+    Flat = 1      //!< Flat generator
+    };
+
   RandomSequence(int typ = RandomSequence::Gaussian, double m=0., double s=1.);
   double Rand();
 protected:
-  int typ_;
-  double mean_, sig_;
+  int typ_;            //!< random generation type
+  double mean_, sig_;  //!< generation parameters mean and sigma (if needed)
 };
 
 
+//////////////////////////////////////////////////////////
+//! Class to generate a sequence of values
 class Sequence {
 public:
   explicit Sequence (double start=0., double step=1., Arr_DoubleFunctionOfX f=NULL);
   explicit Sequence (RandomSequence rseq);
+
+  //! return start value of the sequence
   inline double & Start() { return start_; }
+  //! return step value of the sequence
   inline double & Step() { return step_; }
   double operator () (uint_4 k);
 protected:
-  double start_, step_;
-  Arr_DoubleFunctionOfX myf_;
-  bool fgrseq_;
-  RandomSequence rseq_; 
+  double start_;              //!< start value of the sequence
+  double step_;               //!< step value of the sequence
+  Arr_DoubleFunctionOfX myf_; //!< pointer to the sequence function
+  bool fgrseq_;               //!< true if RandomSequence is used
+  RandomSequence rseq_;       //!< RandomSequence
 };
 
+//////////////////////////////////////////////////////////
+//! Class to define a range of indexes
 class Range {
 public:
   explicit Range(uint_4 start=0, uint_4 end=0, uint_4 size=1, uint_4 step=1);
+  //! Return the start index
   inline uint_4 & Start()  {  return start_; }
+  //! Return the last index
   inline uint_4 & End()    {  return end_; }
+  //! Return the size
   inline uint_4 & Size()   {  return size_; }
+  //! Return the step
   inline uint_4 & Step()   {  return step_; }
 protected:
-  uint_4 start_, end_, size_, step_ ;
+  uint_4 start_; //!< start index
+  uint_4 end_;   //!< end index
+  uint_4 size_;  //!< size
+  uint_4 step_;  //!< step
 };
 
+//////////////////////////////////////////////////////////
+//! Class to define an identity matrix
 class IdentityMatrix {
 public:
   explicit IdentityMatrix(double diag=1., uint_4 n=0);
+  //! return the size of the identity matrix
   inline uint_4 Size() { return size_; }
+  //! return the value of the diagonal elements
   inline double Diag() { return diag_; }
 protected:
-  uint_4 size_;
-  double diag_;
+  uint_4 size_; //!< size of the matrix
+  double diag_; //!< value of the diagonal elements
 };
 
@@ -65,3 +93,2 @@
 
 #endif
-
