Index: trunk/SophyaLib/NTools/difeq.h
===================================================================
--- trunk/SophyaLib/NTools/difeq.h	(revision 307)
+++ trunk/SophyaLib/NTools/difeq.h	(revision 508)
@@ -28,5 +28,5 @@
   
   // Calcule les valeurs des derivees fpi a partir des valeurs des fonctions fi
-  virtual void ComputeV(Vector& fpi, Vector const& fi)
+  virtual void ComputeV(OVector& fpi, OVector const& fi)
        { Compute(fpi(0), fi(0)); }
 
@@ -44,5 +44,5 @@
   // Pour ajuster vecteur de depart quand il y a des fonctions a usage
   // interne...
-  virtual void AdjustStart(Vector& /*start*/, double /*tstart*/) 
+  virtual void AdjustStart(OVector& /*start*/, double /*tstart*/) 
     {}   
 protected:
@@ -87,8 +87,8 @@
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
-  virtual void ComputeV(Vector& fpi, Vector const& fi);
+  virtual void ComputeV(OVector& fpi, OVector const& fi);
 
   // Implementation de AdjustStart qui gere la fonction a usage interne.
-  virtual void AdjustStart(Vector& start, double tstart);
+  virtual void AdjustStart(OVector& start, double tstart);
 protected:
   DIFEQFCNT1 mFcn;
@@ -102,5 +102,5 @@
   DiffEqFcn2(DIFEQFCN2);
 
-  virtual void ComputeV(Vector& fpi, Vector const& fi);
+  virtual void ComputeV(OVector& fpi, OVector const& fi);
 protected:
   DIFEQFCN2 mFcn;
@@ -121,8 +121,8 @@
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
-  virtual void ComputeV(Vector& fpi, Vector const& fi);
+  virtual void ComputeV(OVector& fpi, OVector const& fi);
 
   // Implementation de AdjustStart qui gere la fonction a usage interne.
-  virtual void AdjustStart(Vector& start, double tstart);
+  virtual void AdjustStart(OVector& start, double tstart);
 protected:
   DIFEQFCNT2 mFcn;
@@ -130,12 +130,12 @@
 
 // Cas y'' = f(y',y) avec des 3-vecteurs
-typedef void(*DIFEQFCNV)(Vector&, Vector const&, Vector const&);
+typedef void(*DIFEQFCNV)(OVector&, OVector const&, OVector const&);
 
 // <summary> y'' = f(y',y,t) </summary>
 // Cas y'' = f(y',y,t), on fournit la fonction f, sous la forme
-// double f(Vector), et ca construit la bonne DiffEqFunction
+// double f(OVector), et ca construit la bonne DiffEqFunction
 class DiffEqFcnV : public DiffEqFunction {
 public:
-  // Constructeur, on fournit une fonction (Vector)->double
+  // Constructeur, on fournit une fonction (OVector)->double
   // qui donne y'' en fonction du vecteur (t, y, y')
   DiffEqFcnV(DIFEQFCNV);
@@ -143,8 +143,8 @@
   // Implementation de Compute qui va utiliser la fonction fournie
   // au constructeur.
-  virtual void ComputeV(Vector& fpi, Vector const& fi);
+  virtual void ComputeV(OVector& fpi, OVector const& fi);
 protected:
   DIFEQFCNV mFcn;
-  Vector tmp1, tmp2, tmp3;
+  OVector tmp1, tmp2, tmp3;
 };
 
@@ -176,5 +176,5 @@
   // Change les conditions initiales. Notation chainee possible.
   // <group>
-  DiffEqSolver& StartV(Vector const& yi, double t);
+  DiffEqSolver& StartV(OVector const& yi, double t);
   // si NFunc == 1
   DiffEqSolver& Start1(double        yi, double t);
@@ -184,9 +184,9 @@
   // Lance la resolution, avec ou sans conservation de n valeurs intermediaires
   // <group>
-  virtual void SolveV(Vector& yf, double tf);
+  virtual void SolveV(OVector& yf, double tf);
   // si NFunc == 1
   virtual void Solve1(double& yf, double tf);  
   virtual void Solve(double* yf, double tf);
-  virtual void SolveArr(Matrix&  y, double* t, double tf, int n)=0;
+  virtual void SolveArr(OMatrix&  y, double* t, double tf, int n)=0;
   // si NFunc == 1
   virtual void SolveArr1(double*  y, double* t, double tf, int n);   
@@ -198,5 +198,5 @@
   bool mOwnFunc;
 
-  Vector  mYStart;
+  OVector  mYStart;
   double  mXStart;
   double  mStep;
@@ -215,11 +215,11 @@
 
   // Implementation de RK4
-  virtual void SolveArr(Matrix& y, double* t, double tf, int n);
+  virtual void SolveArr(OMatrix& y, double* t, double tf, int n);
 
 protected:
   // Un pas RK4
-  void RKStep(Vector& newY, Vector const& y0, double dt);
+  void RKStep(OVector& newY, OVector const& y0, double dt);
   // Vecteurs utilises en interne, pour ne pas les reallouer.
-  Vector k1, k2, k3, k4;
+  OVector k1, k2, k3, k4;
 };
 
