Résolution Système différentiel couplé - de type Lokta Volterra par runge kutta d'ordre 4

Bonjour,
je dois resoudre un systeme proie-predateur de type :

dL/dt = A*L(t) + B*R(t)
dR/dt = C*L(t) + D*R(t)

et tracer l'évolution des populations L et R en fonction du temps

Pour cela j'utilise la méthode runge kutta d'ordre 4 à pas variable (mon système peut se complexifier, d'où le pas variable pour une meilleure précision), j'ai trouvé une bonne classe (il me semble) : http://physique-eea.ujf-grenoble.fr/...IA/RungeKutta/

Mais je ne comprend pas comment l'utiliser, je ne fais pas beaucoup de C, j'ai quelque notions (je viens juste de débuter les classes pour organiser mieux mes programme). C'est surtout la methode EDP qui me pose probleme !

Voila mon fichier main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
#include <iostream>
#include <cmath>
 
#include "DynamicalSystem.h"
#include "MySystem.h"
 
 
using namespace std;
 
 
int main()
{
    double *Pop,*dPop;
    double t;
 
    //Conditions Initiales :
    double Xi[1];
	double ti,tf; // ti et tf temps initial et final
	Xi[0]=20.;
	Xi[1]=10;
	ti=0.;
	tf=10.;
 
	DynamicalSystem Proie_Predateur(2);
 
	MySystem EqDiffSimple;
	EqDiffSimple.EDP(0, *Pop, *dPop); /*C'est là que je comprends pas trop : Il faut bien que je "lance"
                                        EDP pour qu'il sache ce que vaut mon equation differentielle,
                                        mais dans le texte explicatif, il dit :
                                            "la methode EDP est la methode
                                            contenant vos equations du mouvement ( avec t le temps auquel est calculé dX/dt
                                            qui est representé par dX[0]...)"
                                        Du coup mon temps doit varier entre ti et tf, mais la méthode RungeKutta calcul à ce
                                        que j'ai compris à partir la valeur initiale (ici Xi) et du temps initial ti, la prochaine
                                        valeur de X à l'instant tf !!
                                        Bref je sais pas trop comment initialiser t, Pop et dPop (surtout dPop, car je sais pas l'intégrer
                                        dès le début
                                    */
	EqDiffSimple.Resolu(Xi, ti, tf);
 
	system("pause -1");
	return 0;
}

Là le header de mysystem

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#ifndef DEF_MYSYSTEM
#define DEF_MYSYSTEM
 
#include "DynamicalSystem.h"
 
 
class MySystem : public DynamicalSystem
{
 
public:
    MySystem();
    void EDP(double t, double *X, double *dX);
	void Resolu(double *Xi, double ti, double tf);
 
private:
	double *m_Xi;
	double m_ti;
	double m_tf;
 
};
#endif

Puis les méthodes de MySystem.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
#include <iostream>
#include <cmath>
 
#include "MySystem.h"
 
using namespace std;
 
MySystem::MySystem() : DynamicalSystem(2)
{
 
}
 
void MySystem::EDP(double t, double *X, double *dX)
{
	dX[0]=4*X[0]-7*X[1];
	dX[1]=-3*X[0]+2*X[1];
}
 
void MySystem::Resolu(double *Xi, double ti, double tf)
{
 
 
    *m_Xi=*Xi;
	m_ti=ti;
    m_tf=tf;
 
	DynamicalSystem::RungeKutta(m_Xi, m_ti, m_tf);
 
}

Je n'ai pas mis le fichier dynamicalsystem qu'il n'y a pas à modifer en principe.

Merci, d'essayer de m'aiguiller sur la compréhension de cette classe qui me serait forte utile (je n'ai pas vraiment le temps de coder une méthode rk4 !)