Le modèle proie

Le modèle proie-
prédateur
Equations de Lotka-Volterra
Adrien CASANOVA - Daniel Arasu ANBARASU -
Fabien FOERSTER - Jamal HENNANI
PROGRAMMATION CONCURRENTE

Table des matières
Spécifications ........................................................................................................................................... 2
Équations de Lotka-Volterra .................................................................................................................... 2
Proies ................................................................................................................................................... 2
Prédateurs ........................................................................................................................................... 3
Implémentation ....................................................................................................................................... 3
Solution itérative ................................................................................................................................. 3
Solution parallèle ................................................................................................................................. 4
Références ............................................................................................................................................... 6

Spécifications
Le but de ce projet est de proposer, à partir d’un algorithme itératif, un algorithme parallèle
et son modèle FSP associé permettant de résoudre la problématique qui régit le modèle proie-
prédateur de Lotka-Volterra.
Ce modèle s’intéresse à l’évolution au cours du temps d’un système biologique composé de
deux espèces : des proies et des prédateurs.
Équations de Lotka-Volterra
Ce sont deux hommes, Alfred J. Lotka (1880 – 1949), un statisticien américain, et Vito
Volterra (1860-1940), mathématicien italien, qui sont indépendamment à l’origine de ce modèle et
du couple d'équations différentielles non-linéaires du premier ordre qui le gouverne.
Proies
Soit 𝒙(𝒕) le nombre de proies en fonction du temps. On suppose que les proies ont une source
illimitée de nourriture et que leur taux de reproduction, α, est constant et indépendant de la
présence de prédateurs.
Ainsi, en l’absence de prédateurs, les proies se reproduisent de façon exponentielle. Cette évolution
est représentée par le terme α𝒙(𝒕) .
Soit β le taux de mortalité des proies dû aux prédateurs rencontrés et 𝒚(𝒕) le nombre de prédateurs
en fonctions du temps. Le terme β𝒙(𝒕)𝒚(𝒕) représente donc la mortalité des proies due à la
rencontre avec des prédateurs.
Ainsi, la variation du nombre de proies peut être vue comme la croissance moins la mortalité due aux
prédateurs.

Prédateurs
Notons δ le taux de reproduction des prédateurs en fonction des proies rencontrées et mangées.
Ainsi, le terme δ𝒙(𝒕)𝒚(𝒕) représente la croissance des prédateurs.
Le terme γ 𝒚(𝒕) représente la mortalité des prédateurs, avec γ le taux de mortalité des prédateurs,
constant et indépendant du nombre de proies.
Ainsi, de façon identique à la variation du nombre de proies, la variation du nombre de prédateurs
peut être vue comme la croissance moins la mortalité, naturelle, des prédateurs.
Ces deux équations forment donc le système sur lequel reposeront nos solutions itérative et
parallèle.
Implémentation
Grâce aux précédentes équations, nous allons pouvoir implémenter deux versions d’un
programme représentant le modèle proie-prédateur : une version itérative, « naïve », puis une
deuxième version, parallèle, basée sur la première.
Ce programme modélise l’évolution d’une population d’un type de proies ainsi que l’évolution d’une
population de prédateurs associés lorsqu’ils interagissent entre eux dans une zone spatiale finie.
Solution itérative
Cette solution repose sur un modèle synchrone. En effet, le temps est représenté par des tours
successifs. A chaque tour, les proies et les prédateurs effectuent un certain nombre d’actions qui
conduisent à la mort ou à la naissance d’animaux et modifient ainsi les populations présentes sur le
terrain.
Les actions possibles sont relativement sommaires pour correspondre aux équations de Lotka-
Volterra.
Proies :
 Naitre, selon un coefficient aléatoire
 Etre mangé par un prédateur
Prédateurs :
 Naitre, selon un coefficient aléatoire
 Mourir, selon un coefficient constant

Des notions de priorité et des coefficients aléatoires ont bien sûr été ajoutées à ces actions afin que
le modèle soit le plus cohérent avec un modèle réel.
Ainsi, on récupère à chaque tour le nombre de proies et de prédateurs, ce qui permet de modéliser
l’évolution des populations dans un modèle de temps discret.
Solution parallèle
Bien que la solution précédente soit correcte, certains problèmes se posent par rapport au
modèle réel, tels que la gestion du temps en continu ou l’accès par plusieurs prédateurs à une même
proie. C’est en se tournant vers une approche concurrente que des solutions vont donc pouvoir être
trouvées.
Ainsi, dans cette solution parallèle, chaque animal, qu’il soit une proie ou un prédateur, va
être représenté par un thread, qui s’exécutera indépendamment des autres selon son propre modèle
de temps continu. Ceci permet de se soustraire aux contraintes de temps et d’ordre d’exécution et
de se rapprocher d’un comportement naturel.
Ces changements entrainent l’apparition de verrous afin de s’assurer du bon déroulement
des actions des différentes threads sur les cases du terrain.
L’algorithme global régissant le programme est le suivant :
 Pour chaque action sur la case adjacente libre la plus proche de la case de coordonnées (0;
0), faire :
o Verrouillage de la case courante
o Verrouillage de la case adjacente choisie
o Exécution de l’action
o Libération de la case
L’affichage doit également suivre un modèle de synchronisation de ressources afin de rendre compte
de l’évolution asynchrone des populations. Ainsi, c’est le modèle producteur-consommateur qui le
régit ici.
Chaque thread est alors un producteur et l’interface est le consommateur. Toute action effectuée
par un animal est ajoutée à une file partagée ; Lorsque la file est pleine, toutes les threads voulant y
accéder après avoir effectué une action sont bloqués.