Index: trunk/SophyaLib/NTools/difeq.cc
===================================================================
--- trunk/SophyaLib/NTools/difeq.cc	(revision 244)
+++ trunk/SophyaLib/NTools/difeq.cc	(revision 508)
@@ -106,5 +106,5 @@
 //++
 DiffEqSolver&
-DiffEqSolver::StartV(Vector const& yi, double t)
+DiffEqSolver::StartV(OVector const& yi, double t)
 //
 //	Spécifie le point de départ de l'intégration de l'équadif.
@@ -169,5 +169,5 @@
 
 //++
-// virtual void DiffEqSolver::SolveArr(Matrix&  y, double* t, double tf, int n)=0
+// virtual void DiffEqSolver::SolveArr(OMatrix&  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 
@@ -189,5 +189,5 @@
 //++
 void
-DiffEqSolver::SolveV(Vector& yf, double tf)
+DiffEqSolver::SolveV(OVector& yf, double tf)
 //
 //	Lance la résolution de l'équadif, jusqu'à la valeur
@@ -201,5 +201,5 @@
 {
   double t;
-  Matrix m(1, mFunc->NFuncReal());
+  OMatrix m(1, mFunc->NFuncReal());
   SolveArr(m, &t, tf, 1);
   yf.Realloc(mFunc->NFunc());
@@ -219,5 +219,5 @@
   ASSERT(mFunc->NFunc() == 1);
   double t;
-  Matrix m(1,mFunc->NFuncReal());
+  OMatrix m(1,mFunc->NFuncReal());
   SolveArr(m, &t, tf, 1);
   yf = m(0,0);
@@ -238,5 +238,5 @@
 {
   double t;
-  Matrix m(1, mFunc->NFuncReal());
+  OMatrix m(1, mFunc->NFuncReal());
   SolveArr(m, &t, tf, 1);
   for (int i=0; i<mFunc->NFunc(); i++)
@@ -258,5 +258,5 @@
 {
   ASSERT(mFunc->NFunc() == 1);
-  Matrix m(n, mFunc->NFuncReal());
+  OMatrix m(n, mFunc->NFuncReal());
   SolveArr(m, t, tf, n);
   for (int i=0; i<n; i++)
@@ -281,5 +281,5 @@
 //--
 {
-   Matrix m(n, mFunc->NFuncReal());
+   OMatrix m(n, mFunc->NFuncReal());
    SolveArr(m, t, tf, n);
    for (int i=0; i<n; i++)
@@ -318,5 +318,5 @@
 
 //++
-//  virtual void ComputeV(Vector& fpi, Vector const& fi)
+//  virtual void ComputeV(OVector& fpi, OVector const& fi)
 //	Calcule les valeurs des dérivées fpi à partir des valeurs 
 //	des fonctions fi. A redéfinir.
@@ -340,5 +340,5 @@
 
 //++
-// virtual void AdjustStart(Vector& start, double tstart)
+// virtual void AdjustStart(OVector& start, double tstart)
 //	Pour ajuster le vecteur de départ quand il y a des 
 //	fonctions à usage interne...
@@ -405,5 +405,5 @@
 
 void
-DiffEqFcnT1::ComputeV(Vector& fpi, Vector const& fi)
+DiffEqFcnT1::ComputeV(OVector& fpi, OVector const& fi)
 {
   fpi(0) = (*mFcn)(fi(0), fi(1));
@@ -412,5 +412,5 @@
 
 void
-DiffEqFcnT1::AdjustStart(Vector& start, double tstart)
+DiffEqFcnT1::AdjustStart(OVector& start, double tstart)
 {
   start.Realloc(2);
@@ -446,5 +446,5 @@
 
 void
-DiffEqFcn2::ComputeV(Vector& fpi, Vector const& fi)
+DiffEqFcn2::ComputeV(OVector& fpi, OVector const& fi)
 {
   fpi(0) = fi(1);
@@ -481,5 +481,5 @@
 
 void
-DiffEqFcnT2::ComputeV(Vector& fpi, Vector const& fi)
+DiffEqFcnT2::ComputeV(OVector& fpi, OVector const& fi)
 {
   fpi(0) = fi(1);
@@ -489,5 +489,5 @@
 
 void
-DiffEqFcnT2::AdjustStart(Vector& start, double tstart)
+DiffEqFcnT2::AdjustStart(OVector& start, double tstart)
 {
   start.Realloc(3);
@@ -505,6 +505,6 @@
 //	un vecteur de dimension 3.
 //	On fournit une fonction de type
-//|	typedef void(*DIFEQFCNV)(Vector& y2, Vector const& y1, 
-//|	                         Vector const& y);
+//|	typedef void(*DIFEQFCNV)(OVector& y2, OVector const& y1, 
+//|	                         OVector const& y);
 //	qui retourne y'' en fonction de y' et y.
 //	Note : le système résolu est alors en fait
@@ -527,5 +527,5 @@
 
 void
-DiffEqFcnV::ComputeV(Vector& fpi, Vector const& fi)
+DiffEqFcnV::ComputeV(OVector& fpi, OVector const& fi)
 {
   fpi(0) = fi(3);
@@ -582,5 +582,5 @@
 
 void
-RK4DiffEq::SolveArr(Matrix& y, double* t, double tf, int n)
+RK4DiffEq::SolveArr(OMatrix& y, double* t, double tf, int n)
 {
   //TIMEF;
@@ -592,5 +592,5 @@
    double dx = (tf - mXStart)/(n*nStep);
    
-   Vector yt = mYStart;
+   OVector yt = mYStart;
 
    k1.Realloc(mFunc->NFuncReal());
@@ -610,5 +610,5 @@
 
 void
-RK4DiffEq::RKStep(Vector& newY, Vector const& y0, double dt)
+RK4DiffEq::RKStep(OVector& newY, OVector const& y0, double dt)
 {
     mFunc->ComputeV(k1, y0);
