Changeset 2808 for trunk/SophyaLib/NTools – PI

trunk/SophyaLib/NTools/FSAppIrrSmpl.h

-              r2322
+              r2808
 ////////////////////////////////////////////////////////////////////
+// Un signal donne , suppose a bande de frequences limitee, de longueur
+// finie est periodise. Ce signal periodise est suppose developpe
+// en serie de Fourier finie: l'approximation consiste a rechercher
+// les coefficients de cette serie de Fourier. Cela est fait en utilisant
+// le fait que la matrice du systeme a ecrire est Toeplitz. On utilise
+// une classe ToeplitzMatrix, qui utilise les FFT pour la resolution
+// L'utilisation standard comporte les etapes suivantes :
+//
+//   constructeur --> definit l'echantillonnage et l'amplitude
+//                    des abscisses (pour periodisation)
+//
+//   methode approximateSignal(nbFreq, signal) : definit la bande
+//                    de frequences et les valeurs du signal
+//
+//   recuperation de valeurs approximees ou interpolees :
+//   methodes:  . restaureSignal() (signal "debruite" aux valeurs
+//                                              d'echantionnage)
+//              . restaureRegularlySampledSignal() (signal recalcule
+//                          sur un echantillonnage regulier quelconque)
+//              . computeSignalOnASampling()  (signal recalcule
+//                          sur un echantillonnage irregulier quelconque)
+//
+//  on peut aussi recuperer les valeurs des coefficients du developpement
+//  en serie de Fourier (methodes complexFourierCoef() et coeffCosSin()
+/*!
+  \ingroup NTools
+  \class SOPHYA::FSApproximationIrregularSampling
+  \brief Signal interpolation/approximation using Fourier series with irregularly
+  sampled data
+  \verbatim
+  Un signal donne , suppose a bande de frequences limitee, de longueur
+  finie est periodise. Ce signal periodise est suppose developpe
+  en serie de Fourier finie: l'approximation consiste a rechercher
+  les coefficients de cette serie de Fourier. Cela est fait en utilisant
+  le fait que la matrice du systeme a ecrire est Toeplitz. On utilise
+  une classe ToeplitzMatrix, qui utilise les FFT pour la resolution
+  L'utilisation standard comporte les etapes suivantes :
+  constructeur --> definit l'echantillonnage et l'amplitude
+  des abscisses (pour periodisation)
+  methode approximateSignal(nbFreq, signal) : definit la bande
+  de frequences et les valeurs du signal
+  recuperation de valeurs approximees ou interpolees :
+  methodes:  . restaureSignal() (signal "debruite" aux valeurs
+  d'echantionnage)
+  . restaureRegularlySampledSignal() (signal recalcule
+  sur un echantillonnage regulier quelconque)
+  . computeSignalOnASampling()  (signal recalcule
+  sur un echantillonnage irregulier quelconque)
+  on peut aussi recuperer les valeurs des coefficients du developpement
+  en serie de Fourier (methodes complexFourierCoef() et coeffCosSin()
+  \endverbatim
+  \sa SOPHYA::ToeplitzMatrix
+*/
 /////////////////////////////////////////////////////////////////////
+namespace SOPHYA {
 class FSApproximationIrregularSampling
+{
 …
 };
+} // namespace SOPHYA
 #endif

trunk/SophyaLib/NTools/cspline.cc

-              r2615
+              r2808
 #include "cspline.h"
+//++
+// Class        CSpline
+// Lib  Outils++
+// include      cspline.h
+//
+//      Classe de spline 1D
+//--
+//++
+// Titre        Constructeurs
+//--
+//////////////////////////////////////////////////////////////////////////////
+//++
+/*!
+  \class SOPHYA::CSpline
+  \ingroup NTools
+  Spline 3 smoother (interpolator) for 1-D data points (y = f(x))
+  \sa CSpline2
+*/
+/*!
+  Createur pour spline 3 sur "x[0->n],y[0->n]" avec "yp1,ypn" derivees
+  au premier et dernier points et "natural" indiquant les types de
+  contraintes sur les derivees 2sd au premier et dernier point.
+  "order" doit etre mis a "true" si le tableau de "x[]" n'est pas ordonne
+  dans l'ordre des "x" croissants ("x[i]<x[i+1]"): cette option
+  realloue la place pour les tableaux "x,y" autrement seule une
+  connection aux tableaux "x,y" externes est realisee.
+*/
 CSpline::CSpline(int n,double* x,double* y,double yp1,double ypn
                 ,int natural,bool order)
-//
-//      Createur pour spline 3 sur "x[0->n],y[0->n]" avec "yp1,ypn" derivees
-//      au premier et dernier points et "natural" indiquant les types de
-//      contraintes sur les derivees 2sd au premier et dernier point.
-//      "order" doit etre mis a "true" si le tableau de "x[]" n'est pas ordonne
-//      dans l'ordre des "x" croissants ("x[i]<x[i+1]"): cette option
-//      realloue la place pour les tableaux "x,y" autrement seule une
-//      connection aux tableaux "x,y" externes est realisee.
-//--
   : Nel(0), corrupt_Y2(true), XY_Created(false), Natural(natural)
   , YP1(yp1), YPn(ypn), X(NULL), Y(NULL), Y2(NULL), tmp(NULL)
 …
+}
+//////////////////////////////////////////////////////////////////////////////
+//++
+//!     Createur par defaut.
 CSpline::CSpline(double yp1,double ypn,int natural)
-//
-//      Createur par defaut.
-//--
   : Nel(0), corrupt_Y2(true), XY_Created(false), Natural(natural)
   , YP1(yp1), YPn(ypn), X(NULL), Y(NULL), Y2(NULL), tmp(NULL)
 …
 //////////////////////////////////////////////////////////////////////////////
+//! destructeur
 CSpline::~CSpline()
-// destructeur
+{
 DelTab();
+}
+//++
+// Titre        Methodes
+//--
+//////////////////////////////////////////////////////////////////////////////
+//++
+/*!
+  Pour changer les tableaux sans recreer la classe,
+  memes arguments que dans le createur.
+  Pour connecter les tableaux "x[n],y[n]" aux pointeurs internes "X,Y"
+  Si "order=true", on considere que x n'est pas range par ordre
+  des "x" croissants. La methode alloue de la place pour des tableaux
+  internes "X,Y" qu'elle re-ordonne par "x" croissant.
+  "force=true" impose la reallocation des divers buffers, sinon
+  la reallocation n'a lieu que si le nombre de points augmente.
+*/
 void CSpline::SetNewTab(int n,double* x,double* y,bool order,bool force)
-//
-//      Pour changer les tableaux sans recreer la classe,
-//      memes arguments que dans le createur.
-//      Pour connecter les tableaux "x[n],y[n]" aux pointeurs internes "X,Y"
-//      Si "order=true", on considere que x n'est pas range par ordre
-//      des "x" croissants. La methode alloue de la place pour des tableaux
-//      internes "X,Y" qu'elle re-ordonne par "x" croissant.
-//      "force=true" impose la reallocation des divers buffers, sinon
-//      la reallocation n'a lieu que si le nombre de points augmente.
-//--
+{
 ASSERT( n>3 );
 …
 //////////////////////////////////////////////////////////////////////////////
+//! destruction des divers tableaux en tenant compte des allocations/connections
 void CSpline::DelTab()
-// destruction des divers tableaux en tenant compte des allocations/connections
+{
 if( X   != NULL && XY_Created ) delete [] X;    X   = NULL;
 …
 //////////////////////////////////////////////////////////////////////////////
+//++
+/*!
+  Pour changer les valeurs des derivees 1ere au 1er et dernier points
+  Valeurs imposees des derivees 1ere au points "X[0]" et "X[Nel-1]".
+*/
 void CSpline::SetBound1er(double yp1,double ypn)
-//
-//      Pour changer les valeurs des derivees 1ere au 1er et dernier points
-//      Valeurs imposees des derivees 1ere au points "X[0]" et "X[Nel-1]".
-//--
+{
 if( yp1 == YP1 && ypn == YPn ) return;
 …
+}
+//////////////////////////////////////////////////////////////////////////////
+//++
+//! Pour calculer les tableaux de coeff permettant le calcul des interpolations spline.
 void CSpline::ComputeCSpline()
-//
-//      Pour calculer les tableaux de coeff permettant le calcul
-//      des interpolations spline.
-//--
+{
 // on ne fait rien si les tableaux ne sont pas connectes
 …
+}
+//////////////////////////////////////////////////////////////////////////////
+//++
+//!     Interpolation spline en \b x
 double CSpline::CSplineInt(double x)
-//
-//      Interpolation spline en "x"
-//--
+{
 int klo,khi,k;
 …
+}
+///////////////////////////////////////////////////////////////
+///////// rappel des inlines pour commentaires ////////////////
+///////////////////////////////////////////////////////////////
+//++
+// inline void SetNaturalCSpline(int type = NaturalAll)
+//      Pour changer le type de contraintes sur les derivees 2sd
+//--
+//++
+// inline void Free_Tmp()
+//      Pour liberer la place tampon qui ne sert que
+//      dans ComputeCSpline() et pas dans CSplineInt
+//--
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+//++
+// Class        CSpline2
+// Lib  Outils++
+// include      cspline.h
+//
+//      Classe de spline 2D
+//--
+//++
+// Titre        Constructeurs
+//--
+//////////////////////////////////////////////////////////////////////////////
+//++
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+/*!
+  \class SOPHYA::CSpline2
+  \ingroup NTools
+  Spline smoother (interpolator) for 2-D data points (y = f(x1,x2))
+  \sa CSpline
+*/
+/*!
+  Contructeur - Meme commentaire que pour CSpline avec:
+  \verbatim
+  x1[n1]: liste des coordonnees selon l axe 1
+  x2[n2]: liste des coordonnees selon l axe 2
+  y[n1*n2]: liste des valeurs avec le rangement suivant
+  x1[0]......x1[n1-1]  x1[0]......x1[n1-1]  ... x1[0]......x1[n1-1]
+  |    0<=i<n1      |  |    0<=i<n1      |  ... |    0<=i<n1      |
+  |      j=0 X2[0]            j=1 X2[1]              j=n2-1 X2[n2-1]
+  \endverbatim
+*/
 CSpline2::CSpline2(int n1,double* x1,int n2,double* x2,double* y
                   ,int natural,bool order)
-//
-//      Meme commentaire que pour CSpline avec:
-//| x1[n1]: liste des coordonnees selon l axe 1
-//| x2[n2]: liste des coordonnees selon l axe 2
-//| y[n1*n2]: liste des valeurs avec le rangement suivant
-//| x1[0]......x1[n1-1]  x1[0]......x1[n1-1]  ... x1[0]......x1[n1-1]
-//| |    0<=i<n1      |  |    0<=i<n1      |  ... |    0<=i<n1      |
-//|      j=0 X2[0]            j=1 X2[1]              j=n2-1 X2[n2-1]
-//--
   : Nel1(0), Nel2(0), corrupt_Y2(true), XY_Created(false), Natural(natural)
   , X1(NULL), X2(NULL), Y(NULL), Y2(NULL)
 …
+}
+//////////////////////////////////////////////////////////////////////////////
+//++
+//!     Createur par defaut.
 CSpline2::CSpline2(int natural)
-//
-//      Createur par defaut.
-//--
   : Nel1(0), Nel2(0), corrupt_Y2(true), XY_Created(false), Natural(natural)
   , X1(NULL), X2(NULL), Y(NULL), Y2(NULL)
 …
+}
+//++
+// Titre        Methodes
+//--
+//////////////////////////////////////////////////////////////////////////////
+//++
+//////////////////////////////////////////////////////////////////////////////
+//!     Voir commentaire meme methode de CSpline
 void CSpline2::SetNewTab(int n1,double* x1,int n2,double* x2,double* y
                         ,bool order,bool force)
-//
-//      Voir commentaire meme methode de CSpline
-//--
+{
 ASSERT( n1>3 && n2>3 );
 …
 //////////////////////////////////////////////////////////////////////////////
 //++
+//!     Voir commentaire meme methode de CSpline
 void CSpline2::ComputeCSpline()
-//
-//      Voir commentaire meme methode de CSpline
-//--
+{
 // on ne fait rien si X1 ou X2 ou Y non connectes
 …
 //////////////////////////////////////////////////////////////////////////////
 //++
+//! Calcule la valeur interpole (spline) pour le point \b (x1,x2)
 double CSpline2::CSplineInt(double x1,double x2)
-//
-//      Voir commentaire meme methode de CSpline
-//--
+{
 // calcul de la valeur Y pour x=x1 et remplissage du tampon tmp
 …
+}
-///////////////////////////////////////////////////////////////
-///////// rappel des inlines pour commenatires ////////////////
-///////////////////////////////////////////////////////////////
-//++
-// inline void SetNaturalCSpline(int type = NaturalAll)
-//      Voir commentaire meme methode de CSpline
-//--

trunk/SophyaLib/NTools/cspline.h

-              r896
+              r2808
   void SetBound1er(double yp1 = 0.,double yp2 = 0.);
+//!  Pour changer le type de contraintes sur les derivees 2sd
   inline void SetNaturalCSpline(int type = NaturalAll)
                  { Natural = type;}
+//!  Pour liberer la place tampon qui ne sert que dans ComputeCSpline() et pas dans CSplineInt
   inline void Free_Tmp()
                 { if(tmp != NULL) delete [] tmp; tmp=NULL;}
 …
                 ,bool order=true,bool force=false);
+//!  Pour changer le type de contraintes sur les derivees 2sd
   inline void SetNaturalCSpline(int type = CSpline::NaturalAll)
                  { Natural = type;}

trunk/SophyaLib/NTools/dates.cc

-              r2615
+              r2808
 #include "dates.h"
+//++
+// Class        TimeZone
+// Lib          Outils++
+// include      dates.h
+//
+//      Classe de fuseau horaire. Permet les conversion
+//      GMT <-> temps local, en gérant les changements
+//      d'heure hiver-été.
+//      Deux fuseaux horaires sont prédéfinis, "France"
+//      et "Chili".
+//--
+/*!
+  \class TimeZone
+  \ingroup NTools
+  Management of time zones - This class is used with class Date.
+  \warning Unless necessary, DO NOT USE this class.
+  \sa SOPHYA::TimeStamp
+  \verbatim
+  Classe de fuseau horaire. Permet les conversion
+  GMT <-> temps local, en gérant les changements
+  d'heure hiver-été.
+  Deux fuseaux horaires sont prédéfinis, "France"
+  et "Chili".
+  \endverbatim
+*/
 TimeZone* gTimeZone = NULL;
+//++
+// Titre        Constructeurs
+//--
+//++
+/*!
+  Constructeur par défaut. Il lit la variable
+  d'environnement ACQ_TZ pour choisir le fuseau
+  horaire. Si la variable n'est pas définie, nous
+  sommes en France...
+*/
 TimeZone::TimeZone()
-//
-//      Constructeur par défaut. Il lit la variable
-//      d'environnement ACQ_TZ pour choisir le fuseau
-//      horaire. Si la variable n'est pas définie, nous
-//      sommes en France...
-//--
+{
   char* p = getenv("ACQ_TZ");
 …
+}
 //++
+//!     Constructeur à partir du nom d'un fuseau horaire.
 TimeZone::TimeZone(const char* nom)
-//
-//      Constructeur à partir du nom d'un fuseau horaire.
-//--
+{
   SetZone(nom);
+}
+//++
+/*!
+  Choisit un fuseau horaire. Contient la définition
+  du fuseau "France" (GMT+1, DST : dernier dimanche
+  de mars - dernier dimanche de septembre, c'est-à-dire
+  pré-gouvernement Juppé), et Chili (GMT-4, DST :
+  deuxième dimanche d'octobre - deuxième dimanche de mars).
+*/
 void TimeZone::SetZone(const char* nom)
-//
-//      Choisit un fuseau horaire. Contient la définition
-//      du fuseau "France" (GMT+1, DST : dernier dimanche
-//      de mars - dernier dimanche de septembre, c'est-à-dire
-//      pré-gouvernement Juppé), et Chili (GMT-4, DST :
-//      deuxième dimanche d'octobre - deuxième dimanche de mars).
-//--
+{
   if (!strcmp(nom,"France")) {
 …
+}
 //++
+//!     Teste si une date est en heure d'été (DST).
 int TimeZone::IsDst(const Date& date)
-//
-//      Teste si une date est en heure d'été (DST).
-//--
+{
   Date dt = date;
 …
+}
+//++
+/*!
+  Retourne la difference TL-GMT pour une date donnée,
+  en tenant compte de l'heure d'été éventuelle.
+*/
 int TimeZone::GetOffset(const Date& date)
-//
-//      Retourne la difference TL-GMT pour une date donnée,
-//      en tenant compte de l'heure d'été éventuelle.
-//--
+{
   return IsDst(date) ? gmtOffset+dstOffset : gmtOffset;
+}
+//++
+// Class        Date
+// Lib          Outils++
+// include      dates.h
+//
+//      Une classe date comme une autre, avec gestion
+//      temps local / GMT / changement d'heure, et un
+//      jour temps sidéral.
+//
+//      Une partie de la date (heure, jour...) peut être
+//      indéterminée. Les comparaisons sont alors faites
+//      de façon astucieuse...
+//
+//      La date peut être déterminée de minuit à minuit
+//      ou de midi à midi (nuit d'observation). Logique
+//      complexe et peut-être foireuse pour passer de
+//      l'un à l'autre, mais pas encore d'ennuis pour le
+//      moment... Une date-nuit doit avoir une heure
+//      indéterminée.
+//
+//      Il faut que Date::gTimeZone soit initialisé pour
+//      éviter des gros pépins, mais PeidaInit() le fait.
+//
+//      An 2000 : Lorsqu'on gère des dates sous forme de chaine :
+//      * En sortie, 2 caractères pour l'année entre 1950 et 1999
+//        et 4 caractères sinon
+//      * En entrée, si AA<100 on ajoute 1900.
+//--
+//++
+/*!
+  \class Date
+  \ingroup NTools
+  Date manipulation classe
+  \warning Unless necessary, DO NOT USE this class.
+  Use  SOPHYA::TimeStamp instead.
+  \verbatim
+  Une classe date comme une autre, avec gestion
+  temps local / GMT / changement d'heure, et un
+  jour temps sidéral.
+  Une partie de la date (heure, jour...) peut être
+  indéterminée. Les comparaisons sont alors faites
+  de façon astucieuse...
+  La date peut être déterminée de minuit à minuit
+  ou de midi à midi (nuit d'observation). Logique
+  complexe et peut-être foireuse pour passer de
+  l'un à l'autre, mais pas encore d'ennuis pour le
+  moment... Une date-nuit doit avoir une heure
+  indéterminée.
+  Il faut que Date::gTimeZone soit initialisé pour
+  éviter des gros pépins, mais PeidaInit() le fait.
+  An 2000 : Lorsqu'on gère des dates sous forme de chaine :
+  * En sortie, 2 caractères pour l'année entre 1950 et 1999
+  et 4 caractères sinon
+  * En entrée, si AA<100 on ajoute 1900.
+*/
+//!     Retourne le nombre de jours dans le mois
 short Date::MonthDays(short mois, short annee)
-//
-//      Retourne le nombre de jours dans le mois
-//--
+{
   if (mois<1 || mois>12) throw ParmError(PExcLongMessage(""));
 …
+}
 //++
+//!  Retourne le nombre de jours dans l'année
 short Date::YearDays(short annee)
-//
-//      Retourne le nombre de jours dans l'année
-//--
+{
   return (((annee%4 == 0) && (annee%100 != 0)) || (annee%400 == 0)) ? 366 : 365;
+}
-//++
 bool Date::UndetDate() const
 //
+//      Retourne true si une partie de la date (jour
 //      ou mois ou année) est indéterminée.
+//--
+/*!
+  Retourne true si une partie de la date (jour
+  ou mois ou année) est indéterminée.
+*/
+{
   return ((AA == -1) || (MM == -1) || (JJ == -1));
+}
+//++
+/*!
+  Retourne true si toute la date (jour
+  et mois et année) est indéterminée.
+*/
 bool Date::AllUndetDate() const
-//
-//      Retourne true si toute la date (jour
-//      et mois et année) est indéterminée.
-//--
+{
   return ((AA == -1) && (MM == -1) && (JJ == -1));
+}
-//++
 bool Date::UndetTime() const
 //
 //      Retourne true si une partie de l'heure (heure
 //      ou minutes ou secondes) est indéterminée.
+//--
+/*!
+  Retourne true si une partie de l'heure (heure
+  ou minutes ou secondes) est indéterminée.
+*/
+{
   return ((hh == -1) || (mm == -1) || (ss == -1));
+}
+//++
+/*!
+  Retourne true si toute l'heure (heure
+  et minutes et secondes) est indéterminée.
+*/
 bool Date::AllUndetTime() const
-//
-//      Retourne true si toute l'heure (heure
-//      et minutes et secondes) est indéterminée.
-//--
+{
   return ((hh == -1) && (mm == -1) && (ss == -1));
 …
 //Date::operator double() const
 //++
+//!     Jours écoulés depuis le 0 janvier 1901 0h TU
 double
 Date::GetDays() const
-//
-//      Jours écoulés depuis le 0 janvier 1901 0h TU
-//--
+{
    if (UndetTime() && !AllUndetTime()) throw ParmError(PExcLongMessage(""));
 …
+}
 //++
+//!     Initialisation a partir jours écoulés depuis le 0 janvier 1901 0h TU
 void Date::Set(double t)
-//
-//      Jours écoulés depuis le 0 janvier 1901 0h TU
-//--
+{
    t += 1/8640000.0;
 …
    nuit = 0;
+}
+//++
+//!     Constructeur. Prend l'heure courante...
 Date::Date()
-//
-//      Constructeur. Prend l'heure courante...
-//--
 : timeZone(gTimeZone)
+{
 …
+}
 //++
+//!     Constructeur simple.
 Date::Date(int J, int M, int A, int h, int m, double s)
-//
-//      Constructeur simple.
-//--
 : JJ(J), MM(M), AA(A), hh(h), mm(m), ss(s), timeZone(gTimeZone), nuit(0)
+{
+}
 //++
+//!     Constructeur à partir des jours écoulés depuis le 0 janvier 1901 0h TU
 Date::Date(double t)
-//
-//      Constructeur à partir des
-//      jours écoulés depuis le 0 janvier 1901 0h TU
-//
-//--
 : timeZone(gTimeZone)
+{
 …
+}
 //++
+//!     On change de fuseau horaire.
 void Date::SetTimeZone(TimeZone* tz)
-//
-//      On change de fuseau horaire.
-//--
+{
   timeZone = tz;
+}
+//++
+/*!
+  Constructeur à partir de la date sous la forme
+  'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
+  (par défaut) ou Date::kLocalTime.
+*/
 Date::Date(const char* date, const char* heure, int tOpt)
-//
-//      Constructeur à partir de la date sous la forme
-//      'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
-//      (par défaut) ou Date::kLocalTime.
-//
-//      Tout ou partie de la date peut être indéterminée ('??').
-//--
 : timeZone(gTimeZone)
+{
 …
+}
+//++
+/*!
+  Constructeur à partir de la date sous la forme
+  'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
+  (par défaut) ou Date::kLocalTime.
+  Tout ou partie de la date peut être indéterminée ('??').
+*/
 Date::Date(string const& date, string const& heure, int tOpt)
-//
-//      Constructeur à partir de la date sous la forme
-//      'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
-//      (par défaut) ou Date::kLocalTime.
-//
-//      Tout ou partie de la date peut être indéterminée ('??').
-//--
 : timeZone(gTimeZone)
+{
 …
+}
+//++
+/*!
+  Positionne la date sous la forme
+  'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
+  (par défaut) ou Date::kLocalTime.
+  Tout ou partie de la date peut être indéterminée ('??').
+*/
 void Date::Set(string const& date, string const& heure, int tOpt)
-//
-//      Positionne la date sous la forme
-//      'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
-//      (par défaut) ou Date::kLocalTime.
-//
-//      Tout ou partie de la date peut être indéterminée ('??').
-//--
+{
   Set(date.c_str(), heure == "" ? (char*)NULL : heure.c_str(), tOpt);
+}
+//++
+/*!
+  Positionne la date sous la forme
+  'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
+  (par défaut) ou Date::kLocalTime.
+  Tout ou partie de la date peut être indéterminée ('??').
+*/
 void Date::Set(const char* date, const char* heure, int tOpt)
-//
-//      Positionne la date sous la forme
-//      'DD/MM/YYYY'  'HH/MM/SS', et tOpt est Date::kGMTTime
-//      (par défaut) ou Date::kLocalTime.
-//
-//      Tout ou partie de la date peut être indéterminée ('??').
-//--
+{
   nuit = 0;
 …
+}
+//++
+/*!
+  Récupère la date sous la forme d'une chaîne 'DD/MM/YYYY'
+  en tOpt = Date::kGMTTime ou Date::kLocalTime.
+*/
 void Date::GetDateStr(char* s, int tOpt) const
-//
-//      Récupère la date sous la forme d'une chaîne 'DD/MM/YYYY'
-//      en tOpt = Date::kGMTTime ou Date::kLocalTime.
-//--
+{
   Date dt(*this);
 …
+}
 //++
+//!     Code EROS de la date.
 void Date::GetDateCode(char* s, int tOpt) const
-//
-//      Code EROS de la date.
-//--
+{
   Date dt(*this);
 …
+}
 //++
+//!     Récupère l'heure sous la forme 'HH:MM:SS'
 void Date::GetTimeStr(char* s, int tOpt) const
-//
-//      Récupère l'heure sous la forme 'HH:MM:SS'
-//--
+{
   Date dt(*this);
 …
+}
 //++
+//!     Récupèrera un jour le temps sidéral.
 void Date::GetSidTStr(char* s) const
-//
-//      Récupèrera un jour le temps sidéral.
-//--
+{
   strcpy(s,"TOBEDONE!!");
+}
-//++
 string Date::DateStr(int tOpt) const
 //
 //      Récupère la date sous la forme d'une chaîne 'DD/MM/YYYY'
 //      en tOpt = Date::kGMTTime ou Date::kLocalTime.
+//--
+/*!
+  Récupère la date sous la forme d'une chaîne 'DD/MM/YYYY'
+  en tOpt = Date::kGMTTime ou Date::kLocalTime.
+*/
+{
    char s[20];
 …
+}
 //++
+//!     Code EROS de la date.
 string Date::DateCode(int tOpt) const
-//
-//      Code EROS de la date.
-//--
+{
    char s[20];
 …
+}
 //++
+//!     Récupère l'heure sous la forme 'HH:MM:SS'
 string Date::TimeStr(int tOpt) const
-//
-//      Récupère l'heure sous la forme 'HH:MM:SS'
-//--
+{
    char s[20];
 …
+}
 //++
+//!     Récupèrera un jour le temps sidéral.
 string Date::SidTStr() const
-//
-//      Récupèrera un jour le temps sidéral.
-//--
+{
    char s[20];
 …
+}
 //++
+//!   Retourne le jour dans la semaine, 0-6 avec 0 = Date::jour_Lundi.
 int Date::DayOfWeek(int tOpt) const
-//
-//      Retourne le jour dans la semaine, 0-6
-//      avec 0 = Date::jour_Lundi.
-//--
+{
   double t = GetDays();
 …
+}
+//++
+/*!
+  Retourne la date correspondant au ieme joursem dans le mois
+  correspondant (exemple, 2e dimanche de mars 1960).
+*/
 short Date::NthMonthDay(short i, short joursem, short mois, short annee)
-//
-//      Retourne la date correspondant au ieme joursem dans le mois
-//      correspondant (exemple, 2e dimanche de mars 1960).
-//--
+{
    if (i>0) {
 …
+}
 //++
+//! Ajout un nombre \b dt en jours
 Date& Date::operator += (double dt)
-//
-//      dt en jours
-//--
+{
   int u = UndetTime();
 …
+}
 //++
+//!  retranche un intervalle de temps \b dt en jours
 Date& Date::operator -= (double dt)
-//
-//      dt en jours
-//--
+{
   int u = UndetTime();
 …
+}
-//++
 Date operator + (Date const& d, double dt)
-//
-//--
+{
   Date a(d);
 …
+}
-//++
 Date operator - (Date const& d, double dt)
-//
-//--
+{
   Date a(d);
 …
+}
 //++
+//!     Résultat en jours
 double operator - (Date const& a, Date const& b)
-//
-//      Résultat en jours
-//--
+{
   if (a.UndetTime() != b.UndetTime()) throw ParmError(PExcLongMessage(""));
 …
+}
 //++
+//!     On n'a pas égalite dès que des éléments déterminés sont différents
 bool operator == (Date const& a, Date const& b)
-//
-//      On n'a pas égalite dès que des éléments déterminés sont différents
-//--
+{
   if (a.nuit && a.UndetTime() && !b.nuit && !b.UndetTime() && b.hh<12)
 …
+}
-//++
 bool operator != (Date const& a, Date const& b)
-//
-//--
+{
   return !(a == b);
+}
 //++
+//!     Inégalité large. Pas de subtilités
 bool operator <= (Date const& a, Date const& b)
-//
-//      Inégalité large. Pas de subtilités
-//--
+{
   if (a.nuit && a.UndetTime() && !b.nuit && !b.UndetTime() && b.hh<12)
 …
+}
+//++
+/*!
+  Inégalité stricte, codée à partir de la large pour résoudre
+  sans cas particuliers les subtilités
+/02/95 < ??/03/95 mais pas 01/02/95 < ??/02/95
+*/
 bool operator < (Date const& a, Date const& b)
-//
-//      Inégalité stricte, codée à partir de la large pour résoudre
-//      sans cas particuliers les subtilités
-//      01/02/95 < ??/03/95 mais pas 01/02/95 < ??/02/95
-//--
+{
   return (a <= b) && !(a == b);
+}
-//++
 bool operator >= (Date const& a, Date const& b)
-//
-//--
+{
   return (b <= a);
+}
-//++
 bool operator > (Date const& a, Date const& b)
-//
-//--
+{
   return (b < a);
+}
-//++
 ostream& operator << (ostream& s, Date const& d)
-//
-//--
+{
   char x[20];
 …
   return s;
+}

trunk/SophyaLib/NTools/dates.h

-              r2322
+              r2808
 class TimeZone;
 // <summary> Dates, conversions, operations </summary>
+//! Dates, conversions, operations
 // Classe generale de date et heure, operation, TU/TL ...
 class Date  {
 public:
+  // Enumerations jours et mois
+  // <group>
+  //! Enumerations jours et mois
   enum Jour {jour_Lundi=0, jour_Mardi, jour_Mercredi, jour_Jeudi, jour_Vendredi, jour_Samedi, jour_Dimanche};
   enum Mois {mois_Janvier=1, mois_Fevrier, mois_Mars, mois_Avril, mois_Mai, mois_Juin, mois_Juillet,
              mois_Aout, mois_Septembre, mois_Octobre, mois_Novembre, mois_Decembre};
   enum {kGMTTime=0, kLocalTime=1};
-  // </group>
   // Constructeur : maintenant

trunk/SophyaLib/NTools/datime.c

-              r682
+              r2808
 /*       Fonctions de calcule de date et temps (Heure)       */
+/*
+++
+  Module        Dates (C)
+  Lib   LibsUtil
+  include       datime.h
+        Ce groupe de fonctions permettent de manipuler des dates et heures.
+        En particulier, il est possible de calculer l'ecart (en nombre de jours
+        ou de secondes separant deux dates, ou le temps sideral correspondant
+        a une date et heure legale. Deux structures simples sont definies
+        afin de faciliter le passage des arguments entre differentes fonctions:
+        - *JMA* : Jour, Mois, Annee
+        - *HMS* : Heure, Minutes, Secondes
+--
+*/
+/*
+++
+  Links Voir aussi:
+ Temps Sideral, Universel (C)
+--
+*/
+/*
+++
+Titre   Quelques Macros
+--
+/*!
+  \ingroup NTools
+  \file datime.c
+  \brief Set of C functions and macros to manipulate date and time  + Sidereal time
+  and simple astronomical functions.
+  \warning  If possible, use class SOPHYA::TimeStamp in module BaseTools
+  for date/time computation.
+  Ce groupe de fonctions permettent de manipuler des dates et heures.
+  En particulier, il est possible de calculer l'ecart (en nombre de jours
+  ou de secondes separant deux dates, ou le temps sideral correspondant
+  a une date et heure legale. Deux structures simples sont definies
+  afin de faciliter le passage des arguments entre differentes fonctions:
+  - JMA : Jour, Mois, Annee
+  - HMS : Heure, Minutes, Secondes
+  \sa SOPHYA::TimeStamp
 */
 …
 --
 */
+/*!
+  \ingroup NTools
+   Decodage d'une chaine de caracteres "strg" sous forme de "hh:mm:ss 10:43:60.5"
+   en structure HMS "hms" avec gestion des signes (decodage correcte de -44:30:05.23)
+*/
 void StrtoHMS(char *s,HMS* h)
 /* On ne peut pas ecrire 1:-05:-45 pas gere et debile! (mn et sec >=0.)  cmv 12/8/97 */
 …
+}
+/*!
+  \ingroup NTools
+  Ecrit le contenu de la structure HMS "hms" sous forme de "hh:mm:ss" dans la chaine
+  de caracteres "strg" avec gestion des signes
+*/
 void HMStoStr(HMS h,char *s)
 /* L'ecriture est forcee a h:mn:sec avec mn et sec >=0  cmv 12/8/97 */
 …
 /* Nouvelle-Fonction */
+/*!
+  \ingroup NTools
+  \brief Retourne le nombre de jours dans le mois m, annee a
+*/
 int NbJourMois(int a, int m)
 /* Retourne le nombre de jours dans le mois m, annee a */
 …
+}
+/*!
+  \ingroup NTools
+  Calcule le Nombre de jours ecoules depuis 0 Jan 1901.
+  Si annee < 100  On considere annee = annee+1900  (1900-1999)
+*/
 /* Nouvelle-Fonction */
 long JMAtoJ(JMA jma)
-/*           Calcule le Nb. de jours ecoules depuis 0 Jan 1901         */
-/*   Si annee < 100  On considere annee = annee+1900  (1900-1999)      */
+{
 long rc,nban;
 …
+}
+/*!
+  \ingroup NTools
+  \brief retourne la date correspondant a \b j jours ecoules depuis le 0/1/1901
+*/
 /* Nouvelle-Fonction */
 JMA JtoJMA(long j)
-/* retourne la date correspondant a j jours ecoules depuis le 0/1/1901 */
+{
 long i;
 …
+}
+/*!
+  \ingroup NTools
+  \brief Cette fonction calcule le numero de jour de la semaine (Lundi=1 .. Dimanche=7)
+*/
 /* Nouvelle-Fonction */
 int NumJour(JMA jma)
-/*        Cette fonction calcule le numero de jour de la semaine    */
-/*        (Lundi=1 .. Dimanche=7)                                   */
+{
 int l;
 …
+}
+/*!
+  \ingroup NTools
+  Pour "nj=dd*10+jj", calcule la date correspondant au jour
+  "jj" (1 .. 7 - Lundi .. Dimanche) du mois "mm" , annee "aa"
+  se trouvant apres (ou egal a) la date "dd/mm/aa" .
+  Si annee "aa" <= 99   ->  annee de 1901 - 1999
+*/
 JMA JApmmaatoJMA(int nj, int mm, int aa)
-/*    Pour "nj=dd*10+jj", calcule la date correspondant au jour
-      "jj" (1 .. 7 - Lundi .. Dimanche) du mois "mm" , annee "aa"
-      se trouvant apres (ou egal a) la date "dd/mm/aa" .
-      Si annee "aa" <= 99   ->  annee de 1901 - 1999       */
+{
 int i, dd, jj;
 …
+}
+/*!
+  \ingroup NTools
+  Cette fonction calcule le nombre d'heures en decimales pour \b hms.
+  Heures/Minutes/Secondes peuvent etre +/- avec toutes les combinaisons possibles
+*/
 /* Nouvelle-Fonction */
 double HMStoH(HMS hms)
 …
+/*!
+  \ingroup NTools
+  \brief Conversion en secondes de la structure HMS  "hms"
+*/
 /* Nouvelle-Fonction */
 double HMStoSec(HMS hms)
 …
+}
+/*!
+  \ingroup NTools
+  Calcule le nombre de secondes correspondant a "date,heure"
+  a partir de l'origine 1er Janv 1990  0H00 ( Date entre 1930 - 2050 )
+*/
 /* Nouvelle-Fonction */
 long DatetoSec(char const* date, char const* heure)
 …
+}
+/*!
+  \ingroup NTools
+  Calcule le nombre de secondes correspondant a "date,heure"
+  a partir de l'origine 1er Janv 1990  0H00 ( Date entre 1930 - 2050 )
+  en tenant compte des decalages des heures legales.
+*/
 /* Nouvelle-Fonction */
 long DatetoSecOff(char const* date, char const* heure)
 …
+}
+/*!
+  \ingroup NTools
+  \brief Conversion heures en decimales en structure HMS
+*/
 /* Nouvelle-Fonction */
 HMS HtoHMS(double h)
 …
+}
+/*!
+  \ingroup NTools
+  Conversion degres decimaux en structure HMS (deg,min,sec)
+  Degres decimaux en D , M , Sec  Il y a un modulo 360.
+  la sortie est telle que -180 < deg <= 180.
+*/
 /* Nouvelle-Fonction */
 HMS DtoDMS(double h)
-/* Degres decimaux en D , M , Sec  Il y a un modulo 360  */
-/* la sortie est telle que -180 < deg <= 180. */
+{
 HMS hms;
 …
+}
+/*!
+  \ingroup NTools
+  Conversion degres/heures decimaux en structure HMS (deg/heure,min,sec)
+  SANS modulo 360/24
+*/
 /* Nouvelle-Fonction */
 HMS DoubletoHMS(double h)
 …
+}
+/*!
+  \ingroup NTools
+  \brief Cette fonction  donne le temps sideral moyen a greenwich a 0h UT
+*/
 /* Nouvelle-Fonction  */
 HMS GMST_at_0h_UT (JMA date)
 …
 --
 */
+/*!
+  \ingroup NTools
+  Cette fonction calcule le temps sideral GMT a partir du temps
+  universel et de la date GMT.
+  \verbatim
+  Temps sideral
+  Jour Sideral = 86400 Sec. Sid.  ( = 24 H Sid. )
+  Annee Solaire = 365 J 5H 48' 46"  =~  365.2422 J
+  Annee Solaire = 365.2422 Jours Solaire Moyen = 366.2422 Jours Sideraux
+  Jour Sol. Moyem = 24 H Sol. = 24 H Sid. * (366.2422 / 365.2422)
+  Jour Solaire Moyen = 86636.555359 Sec. Sid. = 24 H 3' 56.555359"
+  Heure Solaire Moyen = 3609.85647 Sec. Sid.
+  Sec. Sol. = 1.0027379 Sec. Sid.
+  Le 1er Janvier 1989 0H TU Il etait 6H 42' 30" GMT_Sideral
+  \endverbatim
+*/
 /* Nouvelle-Fonction  */
 HMS TUtoTSid(JMA date, HMS TU)
 …
+}
+/*!
+  \ingroup NTools
+  Cette fonction calcule les temps universels a partir du temps
+  sideral GMT et de la date GMT. Selon la valeur du TS, il peut y avoir
+  une ou deux possibilites pour le TU (return code).
+*/
 /* Nouvelle-Fonction  */
 int TSidtoTU(JMA date, HMS TS, HMS *TU1, HMS *TU2)
 …
+}
+/*
+++
+void TSidSetupLaSilla()
+        Fonction d'initialisation de conversion  de temps sideral et legal
+        pour la ESO-Silla "SetTSolMOff() , SetTLegOff()".
+|       Longitude = 70 deg 43.8 min ouest
+|       Latitude  = 29 deg 15.4 min Sud
+|       T Sol. Moyen - TU = -4.715333 Heures
+|       TLegal-TU : -4 Heures de Mars a Octobre, -3 Heures sinon
+|       Changement le 1er dimanche >= 8/03  8/10 a midi (12:00:00)
+--
+*/
+/*!
+  \ingroup NTools
+  Fonction d'initialisation de conversion  de temps sideral et legal
+  pour la ESO-Silla "SetTSolMOff() , SetTLegOff()".
+  \verbatim
+  Longitude = 70 deg 43.8 min ouest
+  Latitude  = 29 deg 15.4 min Sud
+  T Sol. Moyen - TU = -4.715333 Heures
+  TLegal-TU : -4 Heures de Mars a Octobre, -3 Heures sinon
+  Changement le 1er dimanche >= 8/03  8/10 a midi (12:00:00)
+  \endverbatim
+*/
 /* Fonction d'initialisation de calcul de temps sideral pour la Silla */
 void TSidSetupLaSilla()
 …
+/*
+++
+double ToJulianDay(JMA dateTU, HMS hmsTU);
+        Calcul du jour Julien pour une date TU.
+        Uniquement valable a partir du 15/10/1582 00:00:00.
+--
+*/
+/*!
+  \ingroup NTools
+  Calcul du jour Julien pour une date TU.
+  Uniquement valable a partir du 15/10/1582 00:00:00.
+*/
 double ToJulianDay(JMA dateTU, HMS hmsTU)
 /* Cf Fundamental astronomie, Springer Verlag 2sd ed.  cmv 4/12/98 */
 …
+}
+/*
+++
+int FromJulianDay(double JD,JMA* dateTU, HMS* hmsTU);
+        Calcul de la date date et l'heure TU a partir d'un jour Julien.
+        Retourne 0 si succes.
+--
+*/
+/*!
+  \ingroup NTools
+  Calcul de la date date et l'heure TU a partir d'un jour Julien.
+  Retourne 0 si succes.
+*/
 int FromJulianDay(double JD,JMA* dateTU, HMS* hmsTU)
 /* Cf Fundamental astronomie, Springer Verlag 2sd ed.  cmv 4/12/98 */
 …
+/*
+++
+double StrgtoDegDec(char *strg)
+        Cette fonction renvoie la valeur decimale en heures
+        d'un angle specifie sous forme de [-][+]dd:mm:ss.
+--
+*/
+/*!
+  \ingroup NTools
+  Cette fonction renvoie la valeur decimale en heures
+  d'un angle specifie sous forme de [-][+]dd:mm:ss.
+*/
 double StrgtoDegDec(char *strg)
 /*         cmv 4/12/98 */
 …
+}
+/*
+++
+char * DegDectoStrg(double deg, char *strg)
+        Cette fonction ecrit une valeur en degre decimal sous
+        forme de [-]dd:mm:ss.
+--
+/*!
+  \ingroup NTools
+  Cette fonction ecrit une valeur en degre decimal sous
+  forme de [-]dd:mm:ss.
 */
 …
+}
+/*
+++
+double EccEarth(JMA dateTU)
+        Valeur de l'eccentricite de l'orbite terrestre
+        a la date TU ``dateTU''.
+--
+/*!
+  \ingroup NTools
+  Valeur de l'eccentricite de l'orbite terrestre
+  a la date TU ``dateTU''.
+  Cf Fundamental astronomie, Springer Verlag 2sd ed p477 table E10
 */
 double EccEarth(JMA dateTU)
 …
+}
+/*
+++
+double ObliqEarth(JMA dateTU)
+        Valeur de l'obliquite de l'orbite terrestre
+        a la date TU ``dateTU'' (en degres decimaux).
+--
+/*!
+  \ingroup NTools
+  Valeur de l'obliquite de l'orbite terrestre
+  a la date TU ``dateTU'' (en degres decimaux).
 */
 double ObliqEarth(JMA dateTU)
 …
+}
+/*
+++
+double LongEcPerihelie(JMA dateTU)
+        Retourne la Longitude Ecliptique du perihelie de
+        l'orbite terrestre a la date TU ``dateTU'' (en degres decimaux).
+--
+/*!
+  \ingroup NTools
+  Retourne la Longitude Ecliptique du perihelie de
+  l'orbite terrestre a la date TU ``dateTU'' (en degres decimaux).
 */
 double LongEcPerihelie(JMA dateTU)
 …
+}
+/*
+++
+void EquatToEclip(double a,double d,double* l,double *b,JMA dateTU);
+        Renvoie les coordonnees ecliptiques ``l,b'' a partir de
+        coordonnees equatoriales ``a,d'' a la date TU ``dateTU''.
+        La date permet de corriger la variation annuelle
+        de l'obliquite terrestre.
+--
+/*!
+  \ingroup NTools
+  Renvoie les coordonnees ecliptiques \b (l,b) a partir de
+  coordonnees equatoriales \b (a,d) a la date TU \b dateTU.
+  La date permet de corriger la variation annuelle
+  de l'obliquite terrestre.
 */
 void EquatToEclip(double a,double d,double* l,double *b,JMA dateTU)

trunk/SophyaLib/NTools/datime.h

-              r220
+              r2808
+/*!
+  \ingroup NTools
+  \file datime.h
+  Set of C functions and macros to manipulate date and time + Sidereal time.
+  \sa datime.c
+  \warning : If possible, use class SOPHYA::TimeStamp
+*/
+/*!
+  \ingroup NTools
+  \brief Structure JMA pour representer une date (Jour, Mois Annee) */
 typedef struct
+  {
 …
   }  JMA ;
+/*!
+  \ingroup NTools
+  \brief Structure HMS pour representer une heure (Heure, Minute Seconde)
+*/
 typedef struct
+  {
 …
   } HMS ;
+/* \cond
 /*   ----------    2) Donnees constantes  ---------- */
 #ifdef  DATIMEPRIVEE
 …
 #endif
+/* \endcond */
 /*    ------ 3) Macro de manipulation de date et heure  -------  */
 #define  NomJour(d)      (NomJo[NumJour(d)-1])
 #define  NomMois(d)      (NomMo[d.Mois-1])
+/*   Chaine de forme  hh:mm:sec  <->  structure HMS   */
+/*        Chaine de forme  hh:mm:sec  <->  structure HMS   */
+/*! \brief  Decodage de Chaine de forme  hh:mm:sec   ->  structure HMS   */
 #define  StrgtoHMS(s,h)  ( sscanf(s,"%d:%d:%lf", &(h.Heures),&(h.Minutes),&(h.Secondes)) )
+/*! \brief  structure HMS -> Chaine de forme  hh:mm:sec  */
 #define  HMStoStrg(h,s)  ( sprintf(s,"%02d:%02d:%02.0f", h.Heures,h.Minutes,h.Secondes) )
 …
 /* EA 140998, machin infame pour que ca marche pour 1998/09/14... Pourquoi avoir fait */
 /* des macros ??????????????????????????????????????????????????????????????????????? */
+/*!  \brief Chaine de caracteres sous forme de dd/mm/aaaa -> structure JMA jma. */
 #define  StrgtoJMA(strg,j)  ( sscanf(strg,"%d/%d/%d", &(j.Jour),&(j.Mois),&(j.Annee)),\
     (j.Jour>1900 ? sscanf(strg,"%d/%d/%d", &(j.Annee),&(j.Mois),&(j.Jour)) : 1) )
+/*! \brief structure JMA -> Chaine de forme jj/mm/aa       */
 #define  JMAtoStrg(j,strg)  ( sprintf(strg,"%02d/%02d/%4d", j.Jour,j.Mois,j.Annee) )
+/*! \brief structure JMA -> Chaine de forme jj/mm/aa       */
 #define  JMAtoStrgLong(j,strg)   ( sprintf(strg,"%s , %d %s %d", NomJo[NumJour(j)-1], j.Jour, NomMo[j.Mois-1], j.Annee) )

trunk/SophyaLib/NTools/difeq.cc

-              r2615
+              r2808
 #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)
 …
+}
+//++
+// 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;
 …
+}
+//++
+/*!
+  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;
 …
+}
+//++
+/*!
+  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;
 …
+}
+//++
+/*!
+  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);
 …
+}
+//++
+/*!
+  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);
 …
+}
+//++
+/*!
+  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());
 …
+}
+//++
+// 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;
 …
+}
+//++
+/*!
+  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);
 …
+}
+//++
+/*!
+  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;
 …
+}
+//++
+/*!
+  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.
-//--
+{
 …
+}
+//++
+/*!
+  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());
 …
+//++
+// 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.
+*/
 //++
 …
+//++
+// 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)
 …
+}
 //++
+// 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)
 {}
 …
+}
+//++
+// 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)
 {}
 …
+}
+//++
+// 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)
 {}
 …
+//++
+// 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)
 …
+//++
+// 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()
 …
 {}
 //++
+//!     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)
 {}

trunk/SophyaLib/NTools/difeq.h

-              r1371
+              r2808
 class DiffEqFunction  {
 public:
   // Constructeur. n = nombre de fonctions dans le systeme
+  //! Constructeur. n = nombre de fonctions dans le systeme
   DiffEqFunction(int n)          : mNFunc(n), mNFuncApp(n) {}
   // Constructeur. n = nombre reel de fonctions dans le systeme,
   // m = nombre apparent (il y a dans certaines cas des fonctions a
   // usage interne,  par exemple la fonction constante valant 1...)
+  //  Constructeur. n = nombre reel de fonctions dans le systeme,
+  //  m = nombre apparent (il y a dans certaines cas des fonctions a
+  //  usage interne,  par exemple la fonction constante valant 1....
   DiffEqFunction(int n, int m)   : mNFunc(n), mNFuncApp(m) {}
 …
        { ASSERT(mNFunc == 1); }
   // Nombre apparent de fonctions dans le systeme
+  //! Nombre apparent de fonctions dans le systeme
   int NFunc()     {return mNFuncApp;}
   // Nombre reel de fonctions dans le systeme
+  //! Nombre reel de fonctions dans le systeme
   int NFuncReal() {return mNFunc;}
+  // Pour ajuster vecteur de depart quand il y a des fonctions a usage
+  // interne...
+  //! Pour ajuster vecteur de depart quand il y a des fonctions a usage v  interne...
   virtual void AdjustStart(Vector& /*start*/, double /*tstart*/)
     {}
 …
 class DiffEqFcn1 : public DiffEqFunction {
 public:
   // Constructeur, on fournit une fonction double->double
+  // Constructeur, on fournit une fonction double->double
   // qui donne y' en fonction de y.
   DiffEqFcn1(DIFEQFCN1);
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
+  // Implementation de Compute qui va utiliser la fonction
+  // fournie au constructeur.
   virtual void Compute(double& fp, double f);
 protected:

trunk/SophyaLib/NTools/dynccd.cc

-              r2615
+              r2808
 #include "dynccd.h"
+//++
+// Class        DynCCD
+// Lib          Images++
+// include      dynccd.h
+//
+//      Cette classe permet la specification des parametres
+//      definissant la dynamique du CCD, et doit etre utilise
+//      pour le calcul des images de bruit.
+//      - TypNoise = 1 :
+//      Bruit = Sqrt( (RONoise/Gain)**2 + ValPix/Gain )
+//      - TypNoise = 2 :
+//      Bruit = Sqrt( RefSFond**2 + (ValPix-RefFond)/Gain )
+//      - TypNoise = 0
+//      Bruit = 1  (Constant pour tous les pixels)
+//      - TypNoise = 3
+//      Bruit = Sqrt(Abs(ValPix))
+//
+//      Les pixels hors dynamique sont marques (Bruit = 0)
+//      ( < MinADU ou > MaxADU) pour toutes valeurs de TypNoise.
+//      Gain est exprime en electron par ADU, RONoise en electron,
+//      Bruit, ValPix et RefFond en ADU.
+//--
+/*!
+  \class SOPHYA::DynCCD
+  \ingroup NTools
+  Cette classe permet la specification des parametres
+  definissant la dynamique du CCD, et doit etre utilise
+  pour le calcul des images de bruit.
+//++
+// Links        Parents
+// PPersist
+//--
+//++
+// Links        Autres
+// RzImage
+// Image<T>
+//--
+//++
+// Titre        Methodes
+//--
+//++
+// DynCCD(int_4TypNoise=0, r_8 MinADU=-9.e19, r_8 MaxADU=9.e19, r_8 Gain=1., r_8 RONoise=0., r_8 RefFond=0., r_8 RefSFond=0.);
+//      Creation d'un objet DynCCD ("typ" determine la methode de calcul du bruit)
+//      |Test verbatim
+//
+// void Set(int_4TypNoise=0, r_8 MinADU=-9.e19, r_8 MaxADU=9.e19, r_8 Gain=1., r_8 RONoise=0., r_8 RefFond=0., r_8 RefSFond=0.);
+//      Modification des parametres de la dynamique
+// void Print()
+// r_8 Noise(r_8 pixel) const
+//      Renvoie la valeur du bruit pour "pixel" en ADU.
+//--
+  - TypNoise = 1
+  Bruit = Sqrt( (RONoise/Gain)**2 + ValPix/Gain )
+  - TypNoise = 2 :
+  Bruit = Sqrt( RefSFond**2 + (ValPix-RefFond)/Gain )
+  - TypNoise = 0
+  Bruit = 1  (Constant pour tous les pixels)
+  - TypNoise = 3
+  Bruit = Sqrt(Abs(ValPix))
+  Les pixels hors dynamique sont marques (Bruit = 0)
+  ( < MinADU ou > MaxADU) pour toutes valeurs de TypNoise.
+  Gain est exprime en electron par ADU, RONoise en electron,
+  Bruit, ValPix et RefFond en ADU.
+  \sa SOPHYA::Image
+*/
 /* ............................................................ */
 …
 /* --Methode-- */
+//!  Creation d'un objet DynCCD ("typ" determine la methode de calcul du bruit)
 DynCCD::DynCCD(int_4 typ, r_8 min, r_8 max, r_8 g,
                r_8 ron, r_8 rf, r_8 rfs)
 …
 /* --Methode-- */
+//!     Modification des parametres de la dynamique
 void DynCCD::Set(int_4 typ, r_8 min, r_8 max, r_8 g,
                r_8 ron, r_8 rf, r_8 rfs)
 …
+}
+//!     Renvoie la valeur du bruit pour "pixel" en ADU.
+/*!
+  Cette fonction calcule la valeur du bruit pour pixel
+  - Si TypNoise = 1 :
+  Bruit = Sqrt( (RONoise/Gain)**2 + ValPix/Gain )
+  - Si TypNoise = 2 :
+  Bruit = Sqrt( RefSFond**2 + (ValPix-RefFond)/Gain )
+  - Si TypNoise = 0
+  Bruit = 1  (Constant pour tous les pixels)
+  - Si TypNoise = 3
+  Bruit = Sqrt(Abs(PixelADU))
+  Les pixels hors dynamique sont marques (Bruit = 0)
+  ( < MinADU ou > MaxADU) pour tout valeur de TypNoise
+*/
 /* --Methode-- */
 r_8 DynCCD::Noise(r_8 pixel) const
-/* Cette fonction calcule la valeur du bruit pour pixel     */
-/*  Si TypNoise = 1 :                                       */
-/*     Bruit = Sqrt( (RONoise/Gain)**2 + ValPix/Gain )      */
-/*  Si TypNoise = 2 :                                       */
-/*     Bruit = Sqrt( RefSFond**2 + (ValPix-RefFond)/Gain )  */
-/*  Si TypNoise = 0                                         */
-/*     Bruit = 1  (Constant pour tous les pixels)           */
-/*  Si TypNoise = 3                                         */
-/*     Bruit = Sqrt(Abs(PixelADU))                          */
-/*  Les pixels hors dynamique sont marques (Bruit = 0)      */
-/*  ( < MinADU ou > MaxADU) pour tout valeur de TypNoise    */
+{
 r_8 h,s,ronsq;
 …
 /* --------------------------------------------------------------  */
-//++
-// Module       Images de bruit
-// Lib          Images++
-// include      dynccd.h
-//
-//      Ces fonctions permettent le calcul d'image de bruit a partir d'une
-//      image (RzImage ou Image<T>) et d'un objet DynCCD
-//--
-//++
-// Links        Voir classes
-// DynCCD
-// RzImage
-// Image<T>
-//--
-//++
-// Titre        Les fonctions
-//--
-//++
-// Function     RzImage * NoiseImage(RzImage const *pim, DynCCD const * dynccd)
-//      Construit et renvoie l'image du bruit pour l'image "*pim" (RzImage)
-// Function     Image<T> * NoiseImage(Image<T> const * pim, DynCCD const * dynccd)
-//      Meme fonctionalite pour une image typee (ImageU2, ImageR4, ...)
-// Function     ImgAddNoise(Image<T>&, DynCCD const&)
-//      Calcule l'image du bruit et le rajoute a l'image originale
-//--
 /* Nouvelle-Fonction */
+/*!
+  Construit et renvoie l'image du bruit pour l'image "*pim"
+  Creation et Calcul d'une image de bruit a partir de l'image
+  pim et de dynccd. Voir la methode DynCCD::Noise() pour la
+  description du calcul
+*/
 template <class T>
 Image<T> NoiseImage(Image<T> const & pim, DynCCD const & dynccd)
-/* Creation et Calcul d'une image de bruit a partir de l'image */
-/* pim et de dynccd. Voir la methode DynCCD::Noise() pour la   */
-/* description du calcul                                       */
+{
 …
 /* Nouvelle-Fonction */
+//!     Calcule l'image du bruit et le rajoute a l'image originale
 template <class T>
 void ImgAddNoise(Image<T>& img, DynCCD const& dyn)
+{
   int_4 nPix = img.XSize() * img.YSize();

trunk/SophyaLib/NTools/dynccd.h

-              r1110
+              r2808
 namespace SOPHYA {
-enum {kConstantNoise = 0, kPhotonNoise, kSigFondNoise, kSqrtADUNoise};
+//! Readout and photon noise calculation for images
 class DynCCD
+{
   public :
+  enum {kConstantNoise = 0, kPhotonNoise, kSigFondNoise, kSqrtADUNoise};
   int_4 TypNoise;      // Type de calcul du bruit
 …
+//! Return an image corresponding to the noise described by \b dynccd
 template <class T>
 Image<T> NoiseImage(Image<T> const & pim, DynCCD const & dynccd);
+//! Add noise to the image
 template <class T>
 void ImgAddNoise(Image<T>&, DynCCD const&);

trunk/SophyaLib/NTools/integ.cc

-              r2615
+              r2808
 //     utilisant le (1)
+//++
+// Class        Integrator
+// Lib          Outils++
+// include      integ.h
+//
+//      Classe abstraite d'intégration numérique 1D.
+//      On fournit une fonction double f(double) au constructeur, ou
+//      une GeneralFunction avec des paramètres définis.
+//      L'objet Integrator est convertible en valeur double qui est la valeur
+//      de l'intégrale. Diverses méthodes permettent de choisir des options
+//      de calcul, et ces méthodes retournent une référence sur l'objet, pour
+//      permettre une notation chaînée.
+//--
+//++
+// Links        Implementations
+// TrpzInteg
+// GLInteg
+//--
+//++
+// Titre        Constructeurs
+//--
+//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::Integrator
+  \brief Classe abstraite d'intégration numérique 1D.
+  On fournit une fonction double f(double) au constructeur, ou
+  une GeneralFunction avec des paramètres définis.
+  L'objet Integrator est convertible en valeur double qui est la valeur
+  de l'intégrale. Diverses méthodes permettent de choisir des options
+  de calcul, et ces méthodes retournent une référence sur l'objet, pour
+  permettre une notation chaînée.
+  \sa TrpzInteg GLInteg
+*/
+//!  Constructeur par défaut. L'objet n'est pas utilisable en l'état.
 Integrator::Integrator()
-//
-//      Constructeur par défaut. L'objet n'est pas utilisable en l'état.
-//--
 : mFunc(NULL), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
 …
 {}
 //++
+//! Constructeur à partir de la fonction double->double, et des bornes d'intégration.
 Integrator::Integrator(FUNC f, double xmin, double xmax)
-//
-//      Constructeur à partir de la fonction double->double, et des
-//      bornes d'intégration.
-//--
 : mFunc(f), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
 …
 {}
+//! Constructeur à partir de la fonction double->double, et des bornes d'intégration.
 Integrator::Integrator(fun f, double xmin, double xmax)
-//
-//      Constructeur à partir de la fonction double->double, et des
-//      bornes d'intégration.
-//--
 : mFunc(new Function(f)), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
 …
+//++
+/*!
+  Constructeur sans spécifier les bornes. Elles sont positionnées
+  à [0,1], et on pourra les modifier plus tard.
+*/
 Integrator::Integrator(FUNC f)
-//
-//      Constructeur sans spécifier les bornes. Elles sont positionnées
-//      à [0,1], et on pourra les modifier plus tard.
-//--
 : mFunc(f), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
 …
 {}
+//++
+/*!
+  Constructeur sans spécifier les bornes. Elles sont positionnées
+  à [0,1], et on pourra les modifier plus tard.
+*/
 Integrator::Integrator(fun f)
-//
-//      Constructeur sans spécifier les bornes. Elles sont positionnées
-//      à [0,1], et on pourra les modifier plus tard.
-//--
 : mFunc(new Function(f)), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
 …
 {}
+//++
+/*!
+  Constructeur à partir d'une GeneralFunction. La fonction doit être une
+  fonction de une variable, et on fournit les valeurs des paramètres ainsi
+  que les bornes d'intégration.
+*/
 Integrator::Integrator(GeneralFunction* gff, double* par, double xmin, double xmax)
-//
-//      Constructeur à partir d'une GeneralFunction. La fonction doit être une
-//      fonction de une variable, et on fournit les valeurs des paramètres ainsi
-//      que les bornes d'intégration.
-//--
 : mFunc(NULL), mGFF(gff), mGFFParm(par),
   mNStep(50), mDX(-1), mReqPrec(-1),
 …
+}
+//++
+/*!
+  Constructeur à partir d'une GeneralFunction. La fonction doit être une
+  fonction de une variable, et on fournit les valeurs des paramètres.
+  On ne spécifie pas les bornes. Elles sont positionnées
+  à [0,1], et on pourra les modifier plus tard.
+*/
 Integrator::Integrator(GeneralFunction* gff, double* par)
-//
-//      Constructeur à partir d'une GeneralFunction. La fonction doit être une
-//      fonction de une variable, et on fournit les valeurs des paramètres.
-//      On ne spécifie pas les bornes. Elles sont positionnées
-//      à [0,1], et on pourra les modifier plus tard.
-//--
 : mFunc(NULL), mGFF(gff), mGFFParm(par),
   mNStep(50), mDX(-1), mReqPrec(-1),
 …
 {if(mFunc) delete mFunc;}
 //++
+// Titre        Méthodes
+//--
+//++
+/*!
+  \brief Spécifie le nombre de pas pour l'intégration numérique.
+  La signification peut dépendre de la méthode d'intégration.
+*/
 Integrator&
 Integrator::NStep(int n)
-//
-//      Spécifie le nombre de pas pour l'intégration numérique.
-//      La signification peut dépendre de la méthode d'intégration.
-//--
+{
   mNStep = n;
 …
+}
+//++
+/*!
+  \brief Spécifie le nombre de pas pour l'intégration numérique.
+  La signification peut dépendre de la méthode d'intégration.
+*/
 Integrator&
 Integrator::DX(double d)
-//
-//      Spécifie le pas d'intégration.
-//      La signification peut dépendre de la méthode d'intégration.
-//--
+{
   mDX = d;
 …
+}
+//++
+/*!
+  \brief Spécifie la précision souhaitée.
+  La signification peut dépendre de la méthode d'intégration.
+  Non disponible dans toutes les méthodes d'intégration.
+*/
 Integrator&
 Integrator::ReqPrec(double p)
-//
-//      Spécifie la précision souhaitée.
-//      La signification peut dépendre de la méthode d'intégration.
-//      Non disponible dans toutes les méthodes d'intégration.
-//--
+{
   DBASSERT( !"Pas encore implemente !");
 …
+}
 //++
+//! Spécifie les bornes de l'intégrale.
 Integrator&
 Integrator::Limits(double xmin, double xmax)
-//
-//      Spécifie les bornes de l'intégrale.
-//--
+{
   mXMin = xmin;
 …
+}
 //++
+//! Spécifie la fonction à intégrer, sous forme double f(double).
 Integrator&
 Integrator::Func(FUNC f)
-//
-//      Spécifie la fonction à intégrer, sous forme double f(double).
-//--
+{
   mFunc = f;
 …
+}
+//++
+/*!
+  \brief Spécifie la fonction à intégrer, sous forme de GeneralFunction
+  à une variable, et les paramètres sont fournis.
+*/
 Integrator&
 Integrator::Func(GeneralFunction* gff, double* par)
-//
-//      Spécifie la fonction à intégrer, sous forme de GeneralFunction
-//      à une variable, et les paramètres sont fournis.
-//--
+{
   mGFF = gff;
 …
+}
+//++
+// Class        TrpzInteg
+// Lib          Outils++
+// include      integ.h
+//
+//      Classe d'intégration par la méthode des trapèzes.
+//      Voir Integrator pour les méthodes. Le nombre de pas
+//      est le nombre de trapèze, le pas d'intégration est
+//      la largeur des trapèzez. Impossible de demander une
+//      précision.
+//
+//--
+//++
+// Links        Parents
+// Integrator
+//--
+//++
+// Titre        Constructeurs
+//      Voir Integrator pour les détails.
+//--
+//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::TrpzInteg
+  \brief Implementation de Integrator par la methode des trapezes.
+  Classe d'intégration par la méthode des trapèzes.
+  Voir Integrator pour les méthodes. Le nombre de pas
+  est le nombre de trapèze, le pas d'intégration est
+  la largeur des trapèzez. Impossible de demander une
+  précision.
+  \sa SOPHYA::Integrator
+*/
 TrpzInteg::TrpzInteg()
+//
+//--
+{}
+//++
+{}
 TrpzInteg::TrpzInteg(FUNC f, double xmin, double xmax)
-//
-//--
 : Integrator(f, xmin, xmax)
 {}
+//++
 TrpzInteg::TrpzInteg(fun f, double xmin, double xmax)
-//
-//--
 : Integrator(f, xmin, xmax)
 {}
-//++
 TrpzInteg::TrpzInteg(FUNC f)
-//
-//--
 : Integrator(f)
 {}
 TrpzInteg::TrpzInteg(fun f)
-//
-//--
 : Integrator(f)
 {}
-//++
 TrpzInteg::TrpzInteg(GeneralFunction* gff, double* par, double xmin, double xmax)
-//
-//--
 : Integrator(gff, par, xmin, xmax)
 {}
-//++
 TrpzInteg::TrpzInteg(GeneralFunction* gff, double* par)
-//
-//--
 : Integrator(gff, par)
 {}
 …
 {}
+//! Return the value of the integral.
 double
 TrpzInteg::Value()
 …
+//++
+// Class        GLInteg
+// Lib          Outils++
+// include      integ.h
+//
+//      Classe d'intégration par la méthode de Gauss-Legendre.
+//      Voir Integrator pour les méthodes.
+//      Pour le moment, nstep est l'ordre de la méthode.
+//      Il est prévu un jour de spécifier l'ordre, et que NStep
+//      découpe en intervalles sur chacun desquels on applique GL.
+//      Le principe de la méthode est de calculer les valeurs de la
+//      fonction aux zéros des polynomes de Legendre. Avec les poids
+//      qui vont bien, GL d'ordre n est exacte pour des polynomes de
+//      degré <= 2n+1 (monome le + haut x^(2*n-1).
+//      Impossible de demander une précision donnée.
+//
+//--
+//++
+// Links        Parents
+// Integrator
+//--
+//++
+// Titre        Constructeurs
+//      Voir Integrator pour les détails.
+//--
+//++
+/*!
+  \ingroup NTools
+  \class SOPHYA::GLInteg
+  \brief Implementation de Integrator par la methode de Gauss-Legendre.
+  Classe d'intégration par la méthode de Gauss-Legendre.
+  Voir Integrator pour les méthodes.
+  Pour le moment, nstep est l'ordre de la méthode.
+  Il est prévu un jour de spécifier l'ordre, et que NStep
+  découpe en intervalles sur chacun desquels on applique GL.
+  Le principe de la méthode est de calculer les valeurs de la
+  fonction aux zéros des polynomes de Legendre. Avec les poids
+  qui vont bien, GL d'ordre n est exacte pour des polynomes de
+  degré <= 2n+1 (monome le + haut x^(2*n-1).
+  Impossible de demander une précision donnée.
+  \sa SOPHYA::Integrator
+  \warning statut EXPERIMENTAL , NON TESTE
+*/
 GLInteg::GLInteg()
-//
-//--
 : mXPos(NULL), mWeights(NULL)
 {}
-//++
 GLInteg::GLInteg(FUNC f, double xmin, double xmax)
-//
-//--
 : Integrator(f, xmin, xmax), mXPos(NULL), mWeights(NULL), mOrder(8)
+{
   NStep(1);
+}
 GLInteg::GLInteg(fun f, double xmin, double xmax)
-//
-//--
 : Integrator(f, xmin, xmax), mXPos(NULL), mWeights(NULL), mOrder(8)
+{
   NStep(1);
+}
+//++
 GLInteg::GLInteg(FUNC f)
-//
-//--
 : Integrator(f), mXPos(NULL), mWeights(NULL), mOrder(8)
+{
   NStep(1);
+}
 GLInteg::GLInteg(fun f)
-//
-//--
 : Integrator(f), mXPos(NULL), mWeights(NULL), mOrder(8)
+{
 …
+}
-//++
 GLInteg::GLInteg(GeneralFunction* gff, double* par, double xmin, double xmax)
-//
-//--
 : Integrator(gff, par, xmin, xmax), mXPos(NULL), mWeights(NULL), mOrder(8)
+{
 …
+}
-//++
 GLInteg::GLInteg(GeneralFunction* gff, double* par)
-//
-//--
 : Integrator(gff, par), mXPos(NULL), mWeights(NULL), mOrder(8)
+{
 …
+//! Definit l'ordre de la methode d'integration Gauus-Legendre
 GLInteg&
 GLInteg::SetOrder(int order)
 …
+//! Retourne la valeur de l'integrale
 double
 GLInteg::Value()
 …
+}
+//! Imprime l'ordre et la valeur des poids sur cout
 void
 GLInteg::Print(int lp)

trunk/SophyaLib/NTools/ntoolsinit.cc

-              r2615
+              r2808
 /*!
    \defgroup NTools NTools module
-   This module contains various tools for Sophya.
 */
 …
   \class SOPHYA::NToolsInitiator
   \ingroup NTools
+  Tools initiator
+  \brief NTools module initializer.
+   This module contains various tools for Sophya, in particular numerical algorithms
+   such as :
+   - Non linear fitting (parameter determination) : GeneralFit , MinZSimplex
+   - FFT (FFTServerInterface, FFTPackServer)
+   - Spline interpolation
+   - Numerical integration and differential equations
+   - Date/time manipulation and some usual astronomical quantities (datime.c .h)
 */
 NToolsInitiator::NToolsInitiator()

trunk/SophyaLib/NTools/poly.cc

-              r2615
+              r2808
   \ingroup NTools
   One dimensional polynomials class.
+  \warning status EXPERIMENTAL - not fully tested.
 */
 …
   \ingroup NTools
   Two dimensional polynomials class.
+  \warning status EXPERIMENTAL - not fully tested.
 */

trunk/SophyaLib/NTools/simplex.cc

-              r2650
+              r2808
 //---------------------------------------------------------------
 // Interface de classe de function multivariable pour le SimplexMinmizer
+/*!
+  \class SOPHYA::MinZFunction
+  \ingroup NTools
+  Interface definition for a function object f(x[]) for which MinZSimplex can
+  search the minimum.
+  The pure virtual method Value() should be implemented by the derived classes.
+*/
 MinZFunction::MinZFunction(unsigned int nvar)
 …
 //-------------------  Classe   MinZFuncXi2  --------------------
 //---------------------------------------------------------------
+/*!
+  \class SOPHYA::MinZXi2
+  \ingroup NTools
+  Implements the MinZFunction interface using a xi2 calculator
+  \sa GeneralXi2 GeneralFitData
+*/
 MinZFuncXi2::MinZFuncXi2(GeneralXi2* gxi2, GeneralFitData* gd)
   : mGXi2(gxi2) , mGData(gd), MinZFunction(gxi2->NPar())
 …
+}
+/*!
+  \class SOPHYA::MinZSimplex
+  \ingroup NTools
+  This class implements non linear minimization (optimization)
+  in a multidimensional space following the \b Simplex method.
+  A \b Simplex is a geometrical figure made of N+1 points in a
+  N-dimensional space. (triangle in a plane, tetrahedron in 3-d space).
+  The minimization method implemented in this class is based on the
+  algorithm described in "Numerical Recipes, Chapter X".
+  The algorithm has been slightly enhanced :
+  - More complex convergence / stop test
+  - A new transformation of the simplex has been included (ExpandHigh)
+  For each step, on of the following geometrical transform is performed
+  on the Simplex figure:
+  - Reflection : reflection away from the high point (expansion by factor Alpha)
+  - ReflecExpand : reflection way from the high point and expansion by factor Beta2
+  - ContractHigh : Contraction along the high point (factor Beta)
+  - ContractLow : Contraction toward the low point (factor Beta2)
+  - ExpandHigh : Expansion along the high point
+  \sa GeneralFit
+  The following sample code shows a usage example:
+  \code
+  include "simplex.h"
+  ...
+  // Define our function to be minimized:
+  class MySFunc : public MinZFunction {
+  public:
+    MySFunc() : MinZFunction(2) {}
+    virtual double Value(double const xp[])
+    { return (xp[0]*xp[0]+2*xp[1]*xp[1]); }
+  };
+  ...
+  MySFunc mysf;
+  MinZSimplex simplex(&mysf);
+  // Guess the center and step for constructing the initial simplex
+  Vector x0(2); x0 = 1.;
+  Vector step(2); step = 2.;
+  simplex.SetInitialPoint(x0);
+  simplex.SetInitialStep(step);
+  Vector oparm(2);
+  int rc = simplex.Minimize(oparm);
+  if (rc != 0) {
+    string srt;
+    int sr = simplex.StopReason(srt);
+    cout << " Convergence Pb, StopReason= " << sr << " : " << srt << endl;
+    }
+  else {
+    cout << " Converged: NStep= " << simplex.NbIter()
+         << " OParm= " << oparm << endl;
+    }
+  \endcode
+*/
+/*!
+  \brief Auto test function
+  \param tsel : select autotest (0,1,2,3,4)  , tsel<0 -> all
+  \param prtlev : printlevel
+*/
 int MinZSimplex::AutoTest(int tsel, int prtlev)
+{
 …
+}
+//! Constructor from pointer to MinZFunction object
 MinZSimplex::MinZSimplex(MinZFunction *mzf)
   : mZF(mzf) , mPoint0(mZF->NVar()) , mStep0(mZF->NVar())
 …
+}
+//! Perform the minimization
+/*!
+  Return 0 if success
+  \param fpoint : vector containing the optimal point
+  Convergence test :
+  \verbatim
+  On minimise f(x) f=mZF->Value() ,
+              f_max = max(f) sur simplex , f_min = min(f) sur simplex
+              fm = (abs(f_max)+abs(f_min))
+              [Delta f] = abs(f_max-f_min)
+              [Delta f/f]simplex = 2.*Delta f / fm
+              fm2 = (abs(f_max)+abs(f_max(iter-1)))
+              [Delta f_max/f_max]iter = [f_max(iter-1)-f_max]/fm2
+  Test d'arret :
+   fm < mTol0                                                       OU
+   [Delta f/f]simplex              < mTol1   mRep1 fois de suite    OU
+   [Delta f_max/f_max]iter         < mTol2   mRep2 fois de suite
+*/
 int MinZSimplex::Minimize(Vector& fpoint)
+{
 …
+}
+//! Return the stop reason and fills the corresponding string description
 int MinZSimplex::StopReason(string& s)
+{

trunk/SophyaLib/NTools/simplex.h

-              r2650
+              r2808
 namespace SOPHYA {
 //! Interface definition for multivaruable function (used by SimplexMinmizer)
+//! Interface definition for multivariable function (used by SimplexMinmizer)
 class MinZFunction {
 public:
 …
 };
 //!  Classe implementing MinZFunction for a GeneralXi2 associated with a GeneralFitData
+//!  Wrapper class implementing MinZFunction for a GeneralXi2 associated with a GeneralFitData
 class MinZFuncXi2 : public MinZFunction {
 public:
 …
   virtual        ~MinZSimplex();
+  //! Return the parameter space dimension
   inline int     NDim() { return mZF->NVar(); }
   // Simplex initial
+  //! Defines the initial point (center of simplex figure)
   inline void    SetInitialPoint(Vector& point) { mPoint0 = point; }
+  //! Defines the step along each dimension to construct the simplex from initial point
   inline void    SetInitialStep(Vector& step) { mStep0 = step; }
+  //! Set the info/debug print level
   inline void    SetPrtLevel(int lev=0) { mPrt = lev; }
+  //! Return the current print level
   inline int     PrtLevel() { return mPrt; }
+  //! Set the maximum number of iteration
   inline void    SetMaxIter(int max = 100000) { mMaxIter = max; }
+  //! Return the current  max iter
   inline int     MaxIter() { return mMaxIter; }
+  //! Return the number of iterations performed
   inline int     NbIter() { return mIter; }
+  //! Return the stop reason
   inline int     StopReason() { return mStop; }
+  //! Return the stop reason and a description string (\b s)
          int     StopReason(string& s);
 …
   //  [Delta f/f]simplex              < mTol1   mRep1 fois de suite    OU
   //  [Delta f_max/f_max]iter         < mTol2   mRep2 fois de suite
+  //
+  //! Define the tolerances for the various convergence tests
   inline void    SetStopTolerance(double tol0=1.e-39, double tol1 = 1.e-3, int rep1=5,
                                   double tol2=1.e-4, int rep2=5)
 …
   // Beta2  = Facteur d'homothetie pour la contraction vers le sommet bas f_min (ContractLow)
   // Gamma2 = Facteur d'homothetie pour la l'extension pour le sommet haut ExpandHigh
+  //! Define the similarity (homothetic) factors for the different simplex transformations
   inline void    SetControls(double alpha=1., double beta=0.5, double beta2=0.5,
                              double gamma=2.0, double gamma2=2.0)
                  { mAlpha = alpha; mBeta = beta; mBeta2 = beta2;  mGamma = gamma; mGamma2 = gamma2;}
+  //! Return the the homothetic factor for Reflection
   inline double  Alpha() { return mAlpha; }
+  //! Return the the homothetic factor for ContractHigh (contraction away from high point)
   inline double  Beta() { return mBeta; }
+  //! Return the the homothetic factor for ContractLow (contraction toward the low point)
   inline double  Beta2() { return mBeta2; }
+  //! Return the the homothetic factor for ReflecExpand (reflection+expansion)
   inline double  Gamma() { return mGamma; }
+  //! Return the the homothetic factor for ExpandHigh (expansion along high point)
   inline double  Gamma2() { return mGamma2; }

Context Navigation

Changeset 2808 in Sophya for trunk/SophyaLib/NTools

Legend:

trunk/SophyaLib/NTools/FSAppIrrSmpl.h

trunk/SophyaLib/NTools/cspline.cc

trunk/SophyaLib/NTools/cspline.h

trunk/SophyaLib/NTools/dates.cc

trunk/SophyaLib/NTools/dates.h

trunk/SophyaLib/NTools/datime.c

trunk/SophyaLib/NTools/datime.h

trunk/SophyaLib/NTools/difeq.cc

trunk/SophyaLib/NTools/difeq.h

trunk/SophyaLib/NTools/dynccd.cc

trunk/SophyaLib/NTools/dynccd.h

trunk/SophyaLib/NTools/integ.cc

trunk/SophyaLib/NTools/ntoolsinit.cc

trunk/SophyaLib/NTools/poly.cc

trunk/SophyaLib/NTools/simplex.cc

trunk/SophyaLib/NTools/simplex.h

Download in other formats: