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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 !)