PDF de présentation

Benjamin Favetto
EC1 - TP Scilab
Introduction à Scilab en EC : le jeu de la vie
1
Introduction
Le jeu de la vie est un automate cellulaire crée par John H. Conway en 1970. Un automate cellulaire
est constitué d’une grille (de taille n × n, dont les cases sont appelées (( cellules )), et de règles d’évolution.
Ces cellules peuvent être vivantes ou mortes, et à chaque étape, l’évolution d’une cellule est déterminée par
l’état de ses huit voisines.
– Une cellule morte possédant exactement trois voisines vivantes devient vivante à son tour (elle naı̂t).
– Une cellule vivante possédant deux ou trois voisines vivantes le reste, sinon elle meurt.
A chaque instant, les mêmes règles sont appliquées à l’ensemble des cellules, ce qui conduit à une nouvelle
génération. Ce n’est donc pas à proprement parler un jeu, puisque la seule satisfaction consiste à regarder
l’évolution de la configuration que l’on a initialement choisi !
Exercice 1
?
?
Déterminer les configurations obtenues à l’étape suivante dans ces cas :
?
?
?
?
?
?
On mettra en évidence différentes structures cellulaires sur les exemples : les structures stables (qui
n’évoluent pas dans le temps), les structures périodiques (qui évoluent de manière cyclique), les vaisseaux
(qui évoluent de manière périodique avec translation), les canons (qui créent des vaisseaux à intervalle
régulier), etc.
2
2.1
Mise en oeuvre avec Scilab
La fonction init
La grille est représentée informatiquement par une matrice carrée A de taille n dont les coefficients valent
0 si la cellule est morte et 1 si elle est vivante. Pour éviter les soucis lors du comptage des voisins sur les
bords de la matrice, on borde la matrice par des zéros.
function res=init(A)
//initialise la matrice en bordant la matrice initiale par des zeros
[l,c]=size(A)
M=zeros(l+2,c+2)
M(2:(l+1),2:(c+1))=A;
res=M;
endfunction
2.2
La fonction voisins
La fonction voisins permet de déterminer, pour chaque cellule, le nombre de voisins vivants. Elle renvoie
une matrice de même taille que la grille (bordée).
function res=voisins(M)
//prend une matrice bordee en parametre
//renvoie le nombre de voisins de chaque cellule
[l,c]=size(M);
V=zeros(l,c);
Benjamin Favetto
for i=2:(l-1)
for j=2:(l-1)
V(i,j)=sum(M((i-1):(i+1),(j-1):(j+1)))-M(i,j);
//ne pas oublier de ne pas compter la cellule elle meme
end
end
res=V;
endfunction
2.3
La fonction evolution
Elle détermine l’état suivant de chacune des cellules en fonction de l’état courant et du nombre de voisins.
On remarque que l’état d’une cellule ne change pas si elle possède deux voisins vivants, et elle est vivante si
elle possède trois voisins vivants, et morte dans le reste des cas.
function res=evolution(M,V)
// determine la configuration des cellules à l’etape suivante
// prend en paramètres une configuration et la matrice des voisins
[l,c]=size(M);
N=zeros(l,c);
for i=2:(l-1)
for j=2:(c-1)
if V(i,j)==3 then
N(i,j)=1 ;
else
if V(i,j)==2 then
N(i,j) = M(i,j) ;
else
N(i,j)=0;
end
end
end
end
res=N;
endfunction
2.4
Affichage du résultat
On utilise la fonction Matplot qui affiche directement des carrés de couleur là où la matrice contenant
la grille contient des 1, c’est à dire là où les cellules sont vivantes.
3
Commentaires et liens
De nombreux exemples d’automates cellulaires sont disponibles sur le web (automate d’Ulam, par
exemple). Le présent TP a été inspiré des documents disponibles sur les pages de
Mathieu Gentes (http://www.ann.jussieu.fr/gentes/bcpst.html)
et Sebastien Kerner (http://bcpst1.free.fr/infoBCPST1/index.html).
2