Ecosystèmes et Dynamiques Chaotiques

Laurent Orseau

Description

Ecosystèmes et Dynamiques Chaotiques November 18, 2010 Laurent Orseau <> Antoine Cornuéjols <> 1 Introduction On voit souvent un écosystème comme un équilibre statique fragile, entre un certain nombres d'espèces. La réalité est en fait bien plus proche d'un système fortement dynamique, voire chaotique au sens de la théorie du chaos. Cette dernière propose un socle mathématique permettant de modéliser ces effets ; mais nous allons nous contenter de les observer en programmant des règles simples. Prenez des loups et des moutons, et mettez-les dans un grand pré. Attendez quelques générations et vous verrez une dynamique chaotique émerger (sous condition que les loups n'aient pas mangé tous les moutons, ou que les moutons n'aient pas mangé toute l'herbe). Nous allons modéliser cela en utilisant les règles suivantes: • L'herbe se reproduit en se propageant de proche en proche, • Les moutons et les loups bougent à chaque instant sur une case voisine si elle est libre ou s'ils peuvent manger ce qui s'y trouve, ou ne bougent pas sinon, • À chaque instant, tout animal perd 1 point d'énergie, • Quand un mouton mange de l'herbe, cela lui procure 10 points d'énergie, • Quand un loup mange un mouton, cela lui procure 200 points d'énergie, • Un animal se reproduit lorsque son énergie dépasse une fois et demie son énergie initiale, et perd alors autant d'énergie que l'énergie d'un nouveau né • Tout mouton

• board-draw


• herbe de couleur verte


• structure de données


• appel de board-cell-pic


• herbe dans le reste du programme


• proche en proche

Sujets

• Structure de données

Informations

• Publié par: pefav
• Nombre de lectures: 31
• Langue: Français

Extrait

Ecosystèmes et Dynamiques Chaotiques
November 18, 2010
LaurentOrseau<laurent orseau@agroparistech fr>
AntoineCornuéjols<antoine@lri fr>
1 Introduction
On voit souvent un écosystème comme un équilibre statique fragile, entre un certain
nombres d’espèces. La réalité est en fait bien plus proche d’un système fortement
dynamique, voire chaotique au sens de la théorie du chaos. Cette dernière propose
un socle mathématique permettant de modéliser ces effets ; mais nous allons nous
contenter de les observer en programmant des règles simples.
Prenez des loups et des moutons, et mettez-les dans un grand pré. Attendez quelques
générations et vous verrez une dynamique chaotique émerger (sous condition que les
loups n’aient pas mangé tous les moutons, ou que les moutons n’aient pas mangé toute
l’herbe).
Nous allons modéliser cela en utilisant les règles suivantes:
• L’herbe se reproduit en se propageant de proche en proche,
• Les moutons et les loups bougent à chaque instant sur une case voisine si elle est
libre ou s’ils peuvent manger ce qui s’y trouve, ou ne bougent pas sinon,
• À chaque instant, tout animal perd 1 point d’énergie,
• Quand un mouton mange de l’herbe, cela lui procure 10 points d’énergie,
• Quand un loup mange un mouton, cela lui procure 200 points d’énergie,
• Un animal se reproduit lorsque son énergie dépasse une fois et demie son énergie
initiale, et perd alors autant d’énergie que l’énergie d’un nouveau né
• Tout mouton (resp. loup) qui nait a initialement 100 (resp. 200) points d’énergie,
1
...2 Le champ / La matrice
Ouvrez le fichier "ecosyst-gui-etu.ss". Le plateau est déjà défini.
Définissez la variable globale en récupérant la matrice du plateau grâce à
la fonction .
Vous aurez probablement besoin de vous référer aux TD précédents pour les fonc-
tions graphiques.
3 Modélisation de l’herbe
Commençons par modéliser l’herbe et la faire pousser.
3.1 Structure de données de l’herbe
Un brin d’herbe dans la matrice sera représenté par le symbole . Pour faire les
choses bien, nous allons créer une structure de données très simple avec un construc-
teur, qui permet de construire un nouveau brin d’herbe, et un testeur, qui permet de
savoir si quelque chose est de l’herbe.
En dehors de ces deux fonctions, le symbole ne devra plus jamais ap-
paraître dans votre programme. L’avantage principal est que cela laisse alors la
possibilité de modifier par la suite la manière dont l’herbe est représentée en modifiant
uniquement le constructeur et l’accesseur, sans avoir à modifier toutes les occurrences
de dans le reste du programme. Par exemple on peut vouloir (ce que l’on ne
fera pas) ajouter des attributs à l’herbe, comme la taille des brins, en ne changeant que
2 fonctions. Un autre avantage est que cela rend votre programme moins sujet aux bugs
(fautes de frappe, programme illisible, etc.).
Question 1
Définissez le constructeur
!
qui renvoie simplement un brin d’herbe.
Note : cette fonction est vraiment très simple, ne cherchez pas compliqué.
Question 2
Définissez letesteur qui renvoie vrai si l’objet testé est un brin d’herbe.
!
Question 3
Sur le même modèle, définissez le constructeur
!
et le testeur
2
'herbe?herbe?xherbe)(herbemake-videbool?'(make-herbe:herbeany(')matricevide?board-get-matrixherbe?)x!
permettant de modéliser les cases vides.
Question 4
Créez une fonction
!
qui initialise la matrice avec un petite densité d’herbe, le reste devant être des cases
vides.
3.2 Affichage de l’herbe
Question 5
Définissez l’image de case de couleur verte grâce à
.
Question 6
Créez la fonction
!
qui prend en argument la valeur d’une case de la matrice et qui renvoie l’imagette
correspondante à afficher : si est un brin d’herbe, renvoyer l’imagette de l’herbe,
sinon si c’est une case vide, renvoyer .
Passer ensuite cette fonction en argument à un appel de pour
dire au monde qu’il faut utiliser pour afficher correctement la matrice.
Question 7
Visualisez le résultat grâce à .
3.3 Croissance de l’herbe
Nous allons maintenant rendre notre système dynamique, en faisant se reproduire
l’herbe à chaque instant.
Question 8
Définissez une fonction
!
qui prend en argument une position , dans la matrice correspondant nécessairement
déjà à un brin d’herbe, qui choisit aléatoirement une case adjacente dans la matrice
3
board-drawnone('v(cevide?:xpicchange-herinit-matribevxchoix-imageypicture?)choix-imag)board-make-void?yxx:)number?void?ycase-herbe:anynumber?vbool?)xe:(board-cell-cell-picany((attention à rester dans les bornes!), et qui la transforme en herbe avec une probabilité
de 3% si elle est vide (en modifiant la case correspondante dans la matrice).
Question 9
Créez une fonction
!
qui prend une case de position , et de valeur dans la matrice, et qui appelle
si est un brin d’herbe.
Remarque : Notez bien l’ordre des paramètre et .
Question 10
Créez la fonction
!
qui parcourt la matrice et applique à chaque case de la matrice. Pour
cela, vous disposez de la fonction
!
avec :
!
La fonction prend en argument une matrice et une fonction et
exécute pour chaque case de la matrice. Cette fonction prend en argument
la ligne , la colonne et la valeur de la case de la matrice en , (ca devrait vous
faire penser à une fonction que vous avez créé récemment...).
Question 11
Créez une fonction
!
qui fait la boucle d’animation en appelant à chaque itération.
Question 12
Créez une fonction
!
qui compte le nombre de brins d’herbe dans la matrice.
4
beprocyx)procanyprocveachtmatrix-for-change-herv:any::change-casvanimationnumber?change-tou:vxchange-toutnumber?vy(:number?xvoid?yyvoid?void?)(v)xvoid?y(procx(beprocedure?vyxyproc:matrix?number?:xmatcompte-hervoid?))number?procymat)-eachxmatrix-fore((change-case:Question 13
Modifiez la fonction pour afficher le numéro de l’itération courante ainsi
que le nombre de brins d’herbes pour cette itération.
4 Modélisation des moutons
4.1 Structure de données des moutons
Nous allons maintenant créer une structure de données pour les moutons. Un mouton
est une liste de deux éléments où le premier élément est le symbole et le
second élément est le nombre correspondant à son énergie vitale.
Question 14
Créez le constructeur
!
qui prend en argument une valeur de l’énergie et renvoie un nouveau mouton.
Question 15
Créez le testeur
!
qui prend un objet quelconque en argument et renvoie uniquement si est un
mouton, sinon y compris dans le cas où n’est pas une liste !
Vérifiez votre fonction sur les exemples suivants:
Question 16
Modifiez la fonction pour créer des moutons avec une densité plus
faible que celle de l’herbe.
4.2 Affichage des moutons
Question 17
Créez une imagette bleue.
5
x)mouton):#tce>:10(emouton?((xmakex-herbebool?)()mouton?#fmake-mouto>case-mouton(init-matrimouton?>(#flist#t'anyboxuc)1mouton?00number?)e))#fn-mouton(make'(animationmouton?xQuestion 18
Modifiez la fonction pour prendre en compte le cas des moutons.
Testez votre programme, vous devez voir l’herbe et les moutons.
4.3 Animation des moutons
Question 19
Créez une fonction
!
qui modifie la matrice en fonction des règles données en introduction.
Attention, un mouton ne peut pas se déplacer sur un autre mouton sous peine de
disparition d’un ! (Dans cette simulation, nos moutons ne sont pas canibales.)
Question 20
Modifiez la fonction pour prendre en compte le cas des moutons.
Question 21
Modifiez la fontion pour renvoyer non plus seulement le nombre de brins
d’herbe, mais maintenant la liste contenant le nombre de brins d’herbe et le nombre de
moutons. Modifiez la fonction pour afficher aussi le nombre de moutons à
chaque itération (ou toutes les itérations).
Ralentissez l’affichage et n’hésitez pas à écrire des valeurs en sortie (avec )
pour vérifier que votre programme fonctionne correctement.
5 Modélisation des loups
Question 22
Reprenez l’ensemble des questions concernant les moutons pour modéliser les loups
(de couleur rouge) et leur animation.
Attention, le loup ne peut pas aller sur l’herbe sous peine de perdre un brin d’herbe...
Il ne peut pas non plus aller sur une case où il y a déjà un autre loup.
6 Graphe d’évolution
Nous voulons maintenant tracer le graphe d’évolution des populations. Pour cela, il
faut mémoriser le nombre d’individus de chaque espèce pour chaque instant (ou tous
les pas de temps).
6
evoid?nx:displaycomptexnumber?ynumber?))ton(change-mouchange-cas(neychoix-imaganimation:Question 23
Modifiez l