Méthode Prédateur - Proie

Bonjour,
J'ai quelques soucis dans l'écriture d'une telle méthode. En effet,
Ce modèle prédateur-proie définit: H [n] comme le nombre de lièvres et L [n], le nombre de lynx au temps n
Le modèle de Lotka-Volterra est définie par la formule suivante:
H [n + 1] =H [n] * (1 + a1 - a2 * L [n])
L [n + 1] = L [n] * (1 - b1 + b2 * H [n])

Le nombre initial de lièvres est preyPred[0] et celui de lynx est preyPred[1]
a et b sont 2 tableaux tels que a[0]=a1, a[1]=a2; b[0]=b1 et b[1]=b2.
n est la période à laquelle nous voulons prédire l'avenir des lièvres et des lynxs
Le problème peut-être résolu avec une boucle while ou for
La méthode doit retourner le tableau "preyPred", d'une manière à ce qu'il contienne:

(H [n]) dans preyPred [0] et (L [n]) dans preyPred [1].


Voici mon code, il ne fonctionne pas, pourriez vous me dire ce qui ne va pas? Merci d'avance

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

public class PredateurProie {   private static double a1; private static double a2; private static double b1; private static double b2;     static double[] preyPredLV(double[] preyPred, double[] a, double[] b, int n){ double H[]={preyPred[0]}; double L[]={preyPred[1]};   a[0]=a1; a[1]=a2; b[0]=b1; b[1]=b2;   // while(n>=0){   H[n+1]=H[n] * (1 + a1 - a2*L[n]); L[n+1]=L[n] * (1 + b1 + b2*H[n]); //}     return preyPred; }     public static void main(String[] args) { double [] preyP={300,20}; int n=100; double [] a= {0.1, 0.01}; double [] b= {0.01, 0.00002}; double[] p= preyPredLV(preyP,a,b,n); System.out.println(p); } }

---

Salut,

Le premier souci est que lorsque tu écris :

Code:

---

1 2 3

double H[]={preyPred[0]}; double L[]={preyPred[1]};

---

tu déclares un tableau d'un seul élément. Or un tableau est de taille fixe.

Donc si n>= 0, les 2 lignes suivantes planteront (ArrayIndexOutOfBoundException), car n+1 sera supérieur 0

Code:

---

1 2	H[n+1]=H[n] * (1 + a1 - a2*L[n]); L[n+1]=L[n] * (1 + b1 + b2*H[n]);

---

Le second souci est que si tu dois faire progresser i dans H[i] et L[i] de 1 à n, ce n'est certainement pas un while (n>=0) qu'il faut faire, parce que tu vas commencer à calculer le dernier, puis l'avant dernier, si tant est que tu faisais varier n en le décrémentant. Un for( int i=1; i<=n; i++) serait plus adéquat

Troisième souci ici :

Code:

---

1 2 3 4

a[0]=a1; a[1]=a2; b[0]=b1; b[1]=b2;

---

Outre le fait que a1, a2, b1 et b2 devrait être déclarés localement et pas dans la classe (le jour où tu feras du multithread, tu comprendras mieux pourquoi), ce n'est pas logique de faire paramètre = variable de traitement : c'est plutôt variable de traitement = paramètre. Là, ce code ne fait que remplacer ce qu'il y a dans les tableaux a et b passés en paramètre par des variables initialisées nulle part, donc vallant 0. Quoique tu passes en paramètre de l'appel de la méthode preyPredLV, a et b vallent toujours 0.

4ème souci tu retournes un tableau en résultat, qui ne fait que contenir ce qui a été passé en paramètre (aucune modification de ce tableau n'est faite, quand bien même on corrigerait les soucis précités.

Enfin, à ce que j'ai compris, tu n'as pas besoin de stocker les différentes h[i], et h[i] (pour i=1 à n) : tu as juste besoin de retourner H[n] et L[n] en résulat
Donc, on n'a pas vraiment besoin de i de 1 à n. On a juste besoin de faire n fois le traitement.

Donc tu peux simplement faire :

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

static double[] preyPredLV(double[] preyPred, double[] a, double[] b, int n){ double H=preyPred[0]; // H est H[0] double L=preyPred[1]; // L est L[0]   // on met a et b dans des variables locales pour mieux coller aux formules de l'algorithme double a1=a[0]; double a2=a[1]; double b1=b[0]; double b2=b[1];   for(int i=1 ; i<=n; n++ ) { // on colle au mieux à l'algo (on pourra optimiser après, en faisant i=0; i<n; n++, ou même for( ; n>0; n--)...   // on calcule les nouvelles valeur (pour i), à partir des précédentes double Hi=H * (1 + a1 - a2*L); double Li=L * (1 + b1 + b2*H);   // puis on dit que les courantes (qui deviendront les précédentes dans la prochaine itération) sont les nouvelles H = Hi; L = Li;   }   // on met le résultat dans le tableau preyPred[0]=H; preyPred[1]=L;   return preyPred; }

---

Merci Joel,

Votre retour a été rapide et je vous en remercie. Maintenant, ça a l'air plus clair. Cependant, j'ai testé la méthode avec les mêmes valeurs de la méthode main de mon code, mais elle retourne une chaîne de caractères.

Pourriez vous y jeter un coup de main pour moi? Merci d'avance.

Tu parles probablement de ça : System.out.println(p);Pour afficher un tableau de double, faire à la place System.out.println(Arrays.toString(p));

Merci du retour, En le testant j'obtiens [Infinity, -Infinity]. Je pense que le problème doit venir de ma méthode main

Code:

---

1 2 3 4 5 6 7 8 9 10

public static void main(String[] args) { double [] preyP={300,20}; int n=100; double [] a= {0.1, 0.01}; double [] b= {0.01, 0.00002}; double[] p= preyPredLV(preyP,a,b,n);   System.out.println(Arrays.toString(p));   }

---

Ta fonction progresse trop vite (exponentiellement) et, donc, pour un n=100, on dépasse les capacités du double. Les coefficients que tu utilises sont-ils pris au pif, ou te demande-t'on de faire le calcul pour ces valeurs ?

NB : il y'avait une erreur dans mon code (je pense que tu l'as corrigée vu que ton code donne un résultat). Au lieu de for(int i=1 ; i<=n; n++ ), il fallait for(int i=1 ; i<=n; i++ )

Bonjour Joel,

Votre solution marche en effet, il fallait faire progresser les i au lieu des n. Mille merci, mais en essayant de debuguer le weekend, j'ai trouvé les n++ très beau (j'affichais à chaque fois le résultat donné jusqu'à n fois).

Cela a reveillé en moi, l'envie de connaître mieux Java pour en faire une courbe(graphique). Cela doit être beau.
Je vais prochainement me lancer dans la création des graphiques avec Java. Pourrais-je y arriver avec mon niveau actuel? En tout cas mille merci, vous êtes sympa. A très bientôt ;)