Index: trunk/SophyaLib/NTools/difeq.cc
===================================================================
--- trunk/SophyaLib/NTools/difeq.cc	(revision 2615)
+++ trunk/SophyaLib/NTools/difeq.cc	(revision 2808)
@@ -3,50 +3,38 @@
 #include "ctimer.h"
 
-//++
-// Class	DiffEqSolver
-// Lib  	Outils++ 
-// include	difeq.h
-//
-//	Classe abstraite de résolveur d'équation différentielles.
-//	Beaucoup de méthodes renvoient l'objet afin de pouvoir
-//	utiliser une notation chaînée du type
-//|	s.Step(...).Start(...).Solve(...)
-//--
-//++ 
-// Links	Implementations
-// RK4DiffEq
-// RK4CDiffEq
-//--
-
-//++
-// Titre	Constructeurs
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::DiffEqSolver
+  \brief Classe abstraite de résolveur d'équation différentielles.
+
+  Beaucoup de méthodes renvoient l'objet afin de pouvoir
+  utiliser une notation chaînée du type:
+
+  s.Step(...).Start(...).Solve(...)
+
+  \warning statut EXPERIMENTAL , NON TESTE
+
+  \sa SOPHYA::DiffEqFunction
+  \sa SOPHYA::RK4DiffEq  SOPHYA::RK4CDiffEq 
+*/
+
+//!	Constructeur vide. 
 DiffEqSolver::DiffEqSolver()
-//
-//	Constructeur vide. 
-//--
 : mFunc(NULL), mOwnFunc(false),
   mYStart(1), mXStart(0), mStep(0.01)
 {}
 
-//++
+//!  Constructeur général. L'équation est donnée sous forme de DiffEqFunction
 DiffEqSolver::DiffEqSolver(DiffEqFunction* f)
-//
-//	Constructeur général. L'équation est donnée sous forme
-//	de DiffEqFunction
-//--
 : mFunc(f), mOwnFunc(false),
   mYStart(mFunc->NFuncReal()), mXStart(0), mStep(0.01)
 {}
 
-//++
+/*!
+  Constructeur pour le cas particulier d'une équation du premier
+  ordre. Voir DiffEqFcn1. La fonction f correspond à l'équation
+  y' = f(y).
+*/
 DiffEqSolver::DiffEqSolver(DIFEQFCN1 f)
-//
-//	Constructeur pour le cas particulier d'une équation du premier
-//	ordre. Voir DiffEqFcn1. La fonction f correspond à l'équation
-//	y' = f(y).
-//--
 : mFunc(new DiffEqFcn1(f)), mOwnFunc(true),
   mYStart(mFunc->NFuncReal()), mXStart(0), mStep(0.01)
@@ -58,16 +46,12 @@
 }
 
-//++
-// Titre	Méthodes
-//--
-
-//++
+
+/*!
+  Permet de spécifier l'équation différentielle, sous la forme
+  d'une DiffEqFunction. Retourne l'objet DiffEqSolver : notation
+  chaînée possible
+*/
 DiffEqSolver&
 DiffEqSolver::Func(DiffEqFunction* f)
-//
-//	Permet de spécifier l'équation différentielle, sous la forme
-//	d'une DiffEqFunction. Retourne l'objet DiffEqSolver : notation
-//	chaînée possible
-//--
 {
   if (mFunc && mOwnFunc) delete mFunc;
@@ -77,12 +61,11 @@
 }
 
-//++
+/*!
+  Permet de spécifier l'équation différentielle, sous la forme
+  d'une fonction f telle que y' = f(y). Retourne l'objet DiffEqSolver : 
+  notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::Func(DIFEQFCN1 f)
-//
-//	Permet de spécifier l'équation différentielle, sous la forme
-//	d'une fonction f telle que y' = f(y). Retourne l'objet DiffEqSolver : 
-//	notation chaînée possible.
-//--
 {
   if (mFunc && mOwnFunc) delete mFunc;
@@ -92,12 +75,11 @@
 }
 
-//++
+/*!
+  Spécifie le pas d'intégration de l'équation différentielle (pour
+  les méthodes où ce pas a un sens). La valeur par défaut est 0.01.
+  Retourne l'objet DiffEqSolver : notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::Step(double step)
-//
-//	Spécifie le pas d'intégration de l'équation différentielle (pour
-//	les méthodes où ce pas a un sens). La valeur par défaut est 0.01.
-//	Retourne l'objet DiffEqSolver : notation chaînée possible.
-//--
 {
   mStep = step;
@@ -105,16 +87,16 @@
 }
 
-//++
+
+/*!
+  Spécifie le point de départ de l'intégration de l'équadif.
+  Le vecteur \b y contient les valeurs intiales. Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément du vecteur. \b t est la valeur initiale 
+  du temps.
+  La dimension de y doit correspondre au nombre apparent de fonctions.
+  Retourne l'objet DiffEqSolver : notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::StartV(Vector const& yi, double t)
-//
-//	Spécifie le point de départ de l'intégration de l'équadif.
-//	Le vecteur y contient les valeurs intiales. Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément du vecteur. t est la valeur initiale 
-//	du temps.
-//	La dimension de y doit correspondre au nombre apparent de fonctions.
-//	Retourne l'objet DiffEqSolver : notation chaînée possible.
-//--
 {
   ASSERT(mFunc != NULL);
@@ -127,12 +109,11 @@
 }
 
-//++
+/*!  
+  Spécifie le point de départ de l'intégration de l'équadif,
+  pour une équation y' = f(y). On donne le temps et la valeur de y.
+  Retourne l'objet DiffEqSolver : notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::Start1(double y, double t)
-//
-//	Spécifie le point de départ de l'intégration de l'équadif,
-//	pour une équation y' = f(y). On donne le temps et la valeur de y.
-//	Retourne l'objet DiffEqSolver : notation chaînée possible.
-//--
 {
   ASSERT(mFunc != NULL);
@@ -146,17 +127,17 @@
 }
 
-//++
+
+/*!
+  Spécifie le point de départ de l'intégration de l'équadif.
+  Le tableau \b yi contient les valeurs intiales. Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément du tableau. t est la valeur initiale 
+  du temps.
+  Le nombre d'éléments de yi doit correspondre au nombre apparent
+  de fonctions.
+  Retourne l'objet DiffEqSolver : notation chaînée possible.
+*/
 DiffEqSolver&
 DiffEqSolver::Start(double const* yi, double t)
-//
-//	Spécifie le point de départ de l'intégration de l'équadif.
-//	Le tableau yi contient les valeurs intiales. Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément du tableau. t est la valeur initiale 
-//	du temps.
-//	Le nombre d'éléments de yi doit correspondre au nombre apparent
-//	de fonctions.
-//	Retourne l'objet DiffEqSolver : notation chaînée possible.
-//--
 {
   mYStart.Realloc(mFunc->NFunc());
@@ -169,35 +150,36 @@
 }
 
-//++
-// virtual void DiffEqSolver::SolveArr(Matrix&  y, double* t, double tf, int n)=0
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps. N valeurs intermédiaires sont retournées dans 
-//	les tableaux y et t :
-//	t[i] est le temps au pas i, pour 0<=i<n
-//	y[i] sont les valeurs des fonctions au pas i.
-//	Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément de y[i].
-//	t[n-1] vaut tf.
-//	Le nombre d'éléments de y[i] doit correspondre au nombre apparent
-//	de fonctions.
-//	Cette fonction doit être redéfinie pour chaque méthode de résolution
-//	d'équations. Elle est appelée par toutes les autres fonctions de
-//	résolution (autres SolveArr, et Solve).
-//--
-
-
-//++
+/*!
+  \fn virtual void DiffEqSolver::SolveArr(Matrix&  y, double* t, double tf, int n)
+
+  Lance la résolution de l'équadif, jusqu'à la valeur
+  tf du temps. N valeurs intermédiaires sont retournées dans 
+  les tableaux y et t :
+  - t[i] est le temps au pas i, pour 0<=i<n
+  - y[i] sont les valeurs des fonctions au pas i.
+
+  Voir la description	
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément de y[i].
+  t[n-1] vaut tf.
+  Le nombre d'éléments de y[i] doit correspondre au nombre apparent
+  de fonctions.
+  Cette fonction doit être redéfinie pour chaque méthode de résolution
+  d'équations. Elle est appelée par toutes les autres fonctions de
+  résolution (autres SolveArr, et Solve).
+*/
+
+
+/*!
+  Lance la résolution de l'équadif, jusqu'à la valeur
+  tf du temps. Les valeurs finales sont retournées dans yf.
+  Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément de yf.
+  Le nombre d'éléments de yf doit correspondre au nombre apparent
+  de fonctions.
+*/
 void
 DiffEqSolver::SolveV(Vector& yf, double tf)
-//
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps. Les valeurs finales sont retournées dans yf.
-//	Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément de yf.
-//	Le nombre d'éléments de yf doit correspondre au nombre apparent
-//	de fonctions.
-//--
 {
   double t;
@@ -209,12 +191,12 @@
 }
 
-//++
+
+/*!
+  Lance la résolution de l'équadif, jusqu'à la valeur
+  tf du temps, pour une équation du premier ordre y' = f(y).
+  La valeur finale de y est retournée dans yf.
+*/
 void
 DiffEqSolver::Solve1(double& yf, double tf)
-//
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps, pour une équation du premier ordre y' = f(y).
-//	La valeur finale de y est retournée dans yf.
-//--
 {
   ASSERT(mFunc->NFunc() == 1);
@@ -225,16 +207,16 @@
 }
 
-//++
+
+/*!
+  Lance la résolution de l'équadif, jusqu'à la valeur	
+  tf du temps. Les valeurs finales sont retournées dans yf.
+  Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément de yf.
+  Le nombre d'éléments de yf doit correspondre au nombre apparent
+  de fonctions.
+*/
 void
 DiffEqSolver::Solve(double* yf, double tf)
-//
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps. Les valeurs finales sont retournées dans yf.
-//	Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément de yf.
-//	Le nombre d'éléments de yf doit correspondre au nombre apparent
-//	de fonctions.
-//--
 {
   double t;
@@ -245,15 +227,14 @@
 }
 
-//++
+/*!
+  Lance la résolution de l'équadif (du premier ordre), jusqu'à la valeur
+  tf du temps. N valeurs intermediaires sont retournées dans 
+  les tableaux y et t :
+  t[i] est le temps au pas i, pour 0<=i<n
+  y[i] est la valeur de la fonction au pas i.
+  t[n-1] vaut tf.
+*/
 void
 DiffEqSolver::SolveArr1(double*  y, double* t, double tf, int n)
-//
-//	Lance la résolution de l'équadif (du premier ordre), jusqu'à la valeur
-//	tf du temps. N valeurs intermediaires sont retournées dans 
-//	les tableaux y et t :
-//	t[i] est le temps au pas i, pour 0<=i<n
-//	y[i] est la valeur de la fonction au pas i.
-//	t[n-1] vaut tf.
-//--
 
 {
@@ -265,20 +246,19 @@
 }
 
-//++
+/*!
+  Lance la résolution de l'équadif, jusqu'à la valeur
+  tf du temps. N valeurs intermédiaires sont retournées dans 
+  les tableaux y et t :
+  t[i] est le temps au pas i, pour 0<=i<n
+  y[i] sont les valeurs des fonctions au pas i.
+  Voir la description
+  de chaque fonction-objet-équation différentielle pour connaître
+  le rôle de chaque élément de y[i].
+  t[n-1] vaut tf.
+  Le nombre d'éléments de y[i] doit correspondre au nombre apparent
+  de fonctions.
+*/
 void
 DiffEqSolver::SolveArr2(double** y, double* t, double tf, int n)
-//
-//	Lance la résolution de l'équadif, jusqu'à la valeur
-//	tf du temps. N valeurs intermédiaires sont retournées dans 
-//	les tableaux y et t :
-//	t[i] est le temps au pas i, pour 0<=i<n
-//	y[i] sont les valeurs des fonctions au pas i.
-//	Voir la description
-//	de chaque fonction-objet-équation différentielle pour connaître
-//	le rôle de chaque élément de y[i].
-//	t[n-1] vaut tf.
-//	Le nombre d'éléments de y[i] doit correspondre au nombre apparent
-//	de fonctions.
-//--
 {
    Matrix m(n, mFunc->NFuncReal());
@@ -290,53 +270,44 @@
 
 
-//++
-// Class	DiffEqFunction
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Classe de fonctions pour la résolution d'équations différentielles.
-//	On résoud de facon générale un système de n équations différentielles
-//	du premier ordre, donnant les dérivées fpi de n fonctions fi. 
-//	Cette méthode permet de résoudre toutes les sortes d'équations :
-//	pour une équation du second ordre on crée une fonction intermédiaire
-//	qui est la dérivée de la fonction cherchée.
-//--
-
-//++
-// DiffEqFunction::DiffEqFunction(int n)
-//	Constructeur. N est le nombre de fonctions dans le
-//	système.
-//--
-
-//++
-// DiffEqFunction::DiffEqFunction(int n, int napp)
-//	Constructeur. N est le nombre réel de fonctions dans le
-//	système, et napp le nombre apparent (pour l'utilisateur).
-//	En effet, dans certains cas, on peut avoir besoin de fonctions
-//	supplémentaires masquées à l'utilisateur, par exemple la fonction
-//	constante valant 1, si l'équadif fait intervenir le temps (t).
-//--
-
-//++
-//  virtual void ComputeV(Vector& fpi, Vector const& fi)
-//	Calcule les valeurs des dérivées fpi à partir des valeurs 
-//	des fonctions fi. A redéfinir.
-//--
-
-//++
-//  virtual void Compute(double& fp, double f)
-//	Dans le cas où il y a une seule fonction, calcule la dérivée
-//      fp à partir de la valeur de la fonction f. A redéfinir.
-//--
-
-//++
-// int NFunc()
-// 	Nombre apparent de fonctions dans le système
-//--
-  
-//++
-// int NFuncReal() {return mNFunc;}
-// 	Nombre réel de fonctions dans le système
-//--
+/*!
+  \ingroup NTools 
+  \class SOPHYA::DiffEqFunction
+  
+  \brief Classe de fonctions pour la résolution d'équations différentielles.
+  
+  On résoud de facon générale un système de n équations différentielles
+  du premier ordre, donnant les dérivées fpi de n fonctions fi. 
+  Cette méthode permet de résoudre toutes les sortes d'équations :
+  pour une équation du second ordre on crée une fonction intermédiaire
+  qui est la dérivée de la fonction cherchée.
+
+  \warning statut EXPERIMENTAL , NON TESTE
+
+  \sa SOPHYA::DiffEqSolver
+*/
+
+
+
+/*!
+  \fn DiffEqFunction::DiffEqFunction(int n, int napp)
+  Constructeur. N est le nombre réel de fonctions dans le
+  système, et napp le nombre apparent (pour l'utilisateur).
+  En effet, dans certains cas, on peut avoir besoin de fonctions
+  supplémentaires masquées à l'utilisateur, par exemple la fonction
+  constante valant 1, si l'équadif fait intervenir le temps (t).
+*/
+
+/*!
+  \fn virtual void ComputeV(Vector& fpi, Vector const& fi)
+  Calcule les valeurs des dérivées fpi à partir des valeurs 
+  des fonctions fi. A redéfinir.
+*/
+
+/*!
+  \fn virtual void Compute(double& fp, double f)
+  Dans le cas où il y a une seule fonction, calcule la dérivée
+  fp à partir de la valeur de la fonction f. A redéfinir.
+*/
+
 
 //++
@@ -348,28 +319,26 @@
 
 
-//++
-// Class	DiffEqFcn1
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles de la forme y' = f(y).
-//	On fournit une fonction de type
-//|	typedef double(*DIFEQFCN1)(double);
-//	qui retourne y' en fonction de y.
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
-
-//++
+/*! 
+  \ingroup NTools
+  \class SOPHYA::DiffEqFcn1
+  
+  \brief Objet-fonction générique pour la résolution d'équations
+  différentielles de la forme y' = f(y).
+  
+  On fournit une fonction de type <br>
+  <tt> typedef double(*DIFEQFCN1)(double); </tt> <br>
+  qui retourne y' en fonction de y.
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
+
+
+//!	Constructeur. On fournit la fonction f tq y'=f(y)
 DiffEqFcn1::DiffEqFcn1(DIFEQFCN1 fcn)
-//
-//	Constructeur. On fournit la fonction f tq y'=f(y)
-//--
 : DiffEqFunction(1), mFcn(fcn)
 {}
 
+
+//! Implementation de Compute qui va utiliser la fonction fournie au constructeur.
 void
 DiffEqFcn1::Compute(double& fp, double f)
@@ -378,28 +347,25 @@
 }
 
-//++
-// Class	DiffEqFcnT1
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles de la forme y' = f(y,t).
-//	On fournit une fonction de type
-//|	typedef double(*DIFEQFCNT1)(double, double);
-//	qui retourne y' en fonction de y et t.
-//	Note : le système résolu est alors en fait
-//|	y'[0] = fcn(y[0], y[1])
-//|	y'[1] = 1
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class   SOPHYA::DiffEqFcnT1
+
+  Objet-fonction générique pour la résolution d'équations
+  différentielles de la forme y' = f(y,t).
+  On fournit une fonction de type
+  <tt>	typedef \tt double(*DIFEQFCNT1)(double, double); </tt>
+  qui retourne y' en fonction de y et t.
+
+  \verbatim
+  Note : le système résolu est alors en fait
+  y'[0] = fcn(y[0], y[1])
+  y'[1] = 1
+  \endverbatim
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
+
+//! Constructeur. On fournit la fonction f tq y' = f(y,t)
 DiffEqFcnT1::DiffEqFcnT1(DIFEQFCNT1 fcn)
-//
-//	Constructeur. On fournit la fonction f tq y' = f(y,t)
-//--
 : DiffEqFunction(2, 1), mFcn(fcn)
 {}
@@ -419,28 +385,24 @@
 }
 
-//++
-// Class	DiffEqFcn2
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles de la forme y'' = f(y',y).
-//	On fournit une fonction de type
-//|	typedef double(*DIFEQFCN2)(double, double);
-//	qui retourne y'' en fonction de y' et y.
-//	Note : le système résolu est en fait
-//|	y'[0] = y[1]
-//|	y'[1] = f(y[1], y[0])
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class   SOPHYA::DiffEqFcn2
+  
+  Objet-fonction générique pour la résolution d'équations
+  différentielles de la forme y'' = f(y',y).
+  On fournit une fonction de type
+  <tt>	typedef double(*DIFEQFCN2)(double, double); </tt>
+  qui retourne y'' en fonction de y' et y.
+  \verbatim
+  Note : le système résolu est en fait
+  y'[0] = y[1]
+  y'[1] = f(y[1], y[0])
+  \endverbatim
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
+
+//!   Constructeur. On fournit la fonction f tq y''=f(y',y)
 DiffEqFcn2::DiffEqFcn2(DIFEQFCN2 fcn)
-//
-//	Constructeur. On fournit la fonction f tq y''=f(y',y)
-//--
 : DiffEqFunction(2), mFcn(fcn)
 {}
@@ -453,29 +415,25 @@
 }
 
-//++
-// Class	DiffEqFcnT2
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles de la forme y'' = f(y',y,t).
-//	On fournit une fonction de type
-//|	typedef double(*DIFEQFCNT2)(double, double, double);
-//	qui retourne y'' en fonction de y', y et t.
-//	Note : le système résolu est alors en fait
-//|	y'[0] = y[1]
-//|	y'[1] = f(y[1], y[0], y[2])
-//|	y'[2] = 1
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
-
-//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::DiffEqFcnT2
+  
+  Objet-fonction générique pour la résolution d'équations
+  différentielles de la forme y'' = f(y',y,t).
+  On fournit une fonction de type <br>
+  <tt> typedef double(*DIFEQFCNT2)(double, double, double); </tt> <br>
+  qui retourne y'' en fonction de y', y et t.
+  \verbatim
+  Note : le système résolu est alors en fait
+  y'[0] = y[1]
+  y'[1] = f(y[1], y[0], y[2])
+  y'[2] = 1
+  \endverbatim
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
+
+//!	Constructeur. On fournit la fonction f tq y'' = f(y',y,t)
 DiffEqFcnT2::DiffEqFcnT2(DIFEQFCNT2 fcn)
-//
-//	Constructeur. On fournit la fonction f tq y'' = f(y',y,t)
-//--
 : DiffEqFunction(3,2), mFcn(fcn)
 {}
@@ -497,28 +455,27 @@
 
 
-//++
-// Class	DiffEqFcnV
-// Lib	Outils++ 
-// include	difeq.h
-//
-//	Objet-fonction générique pour la résolution d'équations
-//	différentielles 3D de la forme y'' = f(y',y), ou y est
-//	un vecteur de dimension 3.
-//	On fournit une fonction de type
-//|	typedef void(*DIFEQFCNV)(Vector& y2, Vector const& y1, 
-//|	                         Vector const& y);
-//	qui retourne y'' en fonction de y' et y.
-//	Note : le système résolu est alors en fait
-//|	v(0-2) = y, v(3-5) = y'
-//|
-//|	v'[0] = v[3]
-//|	v'[1] = v[4]
-//|	v'[2] = v[5]
-//|	v'[3-5] = f(v[3-5], v[0-2])
-//--
-//++
-// Links	Parents
-// DiffEqFunction
-//--
+/*!
+  \ingroup NTools
+  \class  SOPHYA::DiffEqFcnV
+  
+  Objet-fonction générique pour la résolution d'équations
+  différentielles 3D de la forme y'' = f(y',y), ou y est
+  un vecteur de dimension 3.
+  On fournit une fonction de type <br>
+  <tt> typedef void(*DIFEQFCNV)(Vector& y2, Vector const& y1, <br>
+  Vector const& y); </tt> <br>
+  qui retourne y'' en fonction de y' et y.
+  \verbatim
+  Note : le système résolu est alors en fait
+  v(0-2) = y, v(3-5) = y'
+
+  v'[0] = v[3]
+  v'[1] = v[4]
+  v'[2] = v[5]
+  v'[3-5] = f(v[3-5], v[0-2])
+  \endverbatim
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
 
 DiffEqFcnV::DiffEqFcnV(DIFEQFCNV fcn)
@@ -543,21 +500,14 @@
 
 
-//++
-// Class	RK4DiffEq
-// Lib  	Outils++ 
-// include	difeq.h
-//
-//	Classe de résolution d'équadif par la méthode de
-//	Runge-Kutta d'ordre 4.
-//	Voir DiffEqSolver pour les méthodes.
-//--
-//++
-// Links	Parents
-// DiffEqSolver
-//--
-
-//++
-// Titre	Constructeurs
-//--
+/*!
+  \ingroup NTools
+  \class SOPHYA::RK4DiffEq
+  
+  Classe de résolution d'équadif par la méthode de
+  Runge-Kutta d'ordre 4.
+  Voir DiffEqSolver pour les méthodes.
+
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
 
 RK4DiffEq::RK4DiffEq()
@@ -565,18 +515,13 @@
 {}
 
-//++
+//!	Constructeur général
 RK4DiffEq::RK4DiffEq(DiffEqFunction* f)
-//
-//	Constructeur général
-//--
 : DiffEqSolver(f), k1(f->NFuncReal()), 
   k2(f->NFuncReal()), k3(f->NFuncReal()), k4(f->NFuncReal())
 {}
 
-//++
+
+//!	Constructeur pour y' = f(y)
 RK4DiffEq::RK4DiffEq(DIFEQFCN1 f)
-//
-//	Constructeur pour y' = f(y)
-//--
 : DiffEqSolver(f), k1(1), k2(1), k3(1), k4(1)
 {}
