Discussion :

[Busher]

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 !)

[Zenol]

Salut,

J'ai essayer de regarder un peu le code de DynamicalSystem.C (Qui devrais être .cpp, tout comme il serais peut-être plus judicieux d'utiliser des std::vector ou encore de définir EDP virtuel pure, mais passons...)

Je vois :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
dym=vector(NVariable);
        dyt=vector(NVariable);

puis

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for (i=0;i<NVariable;i++) yt[i]=y[i]+hh*dydx[i];
        EDP(xh,yt,dyt);

Donc a première vue je dirais que EDP calcule dyt_n+1 a partir de dy_t_n.

On trouve "(avec t le temps auquel est calculé $ {\frac{d\vec{X}}{dt}}$qui est représenté par dX[0]...dX[3] (ici nous avons 4 variables) " ainsi que "et X[0]...X[3] représentant les valeurs $ \vec{X}\,$(t)".
Tu dois donc calculer les dX a partir de tes X et du temps que l'on te donne en paramètre.

Si je reprend tes équations de départ :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
dX[0] = A*X[0] + B*X[1]; // (Ton L(t) est le X[0])
dX[1] = C*X[0] + D*X[1]; // (Ton R(t) est le X[1])

Bon, après j'ai peut-être mal compris, la description faite par l'auteur n'étant pas bien claire.


Edit : J'oubliais :
-On n'inclus jamais un .c(pp) dans un autre .c(pp)
Pour compiler ton projet, tu compile rk4.cpp, tu inclus rk4.h dans MySystem.h, et tu compile MySystem.cpp qui inclus MySystem.h, tu compile enfin ton main et tu link le tout.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

g++ -I./ MySystem.cpp Rk4.cpp main.cpp -o nom_du_programme

(Exécuter dans ton répertoire de travaille)

Et a vrais dire, ce n'est pas vraiment une question de language. ce n'est pas tout à fait la bonne section