Automate cellulaire

Version imprimable

1 pièce(s) jointe(s)

Automate cellulaire

Bonjour, je suis étudiant en bioingénierie et je dois créer un automate cellulaire pour mon cours d'informatique.

J'aurais besoin d'un petit peu d'aide :oops:

L'énoncé du travail se trouve en pièce jointe.

Voici le début de mon code :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import sys
 
n=int(raw_input('Entrez votre règle en décimal\n'))
 
def dec2bin(n) :
    if n<0 or n>255 :
        return 'Nombre non compris entre 0 et 255'
    else :
        bin1 = []
        while n!=0 :
            if (n%2) ==0 :
                n=n/2
                bin1.insert (0,0)
            else :
                n = (n-1)/2
                bin1.insert (0,1)
        while len (bin1) <8 :
            bin1.insert (0,0)
    return bin1
 
bin=dec2bin(n)
 
print bin
 
lignepapa = raw_input('Entrez une liste de chiffres\n')
 
n = raw_input ('Nombres de lignes')
 
lignepapa= str(lignepapa)
 
lignepapa= list(lignepapa)
 
u = len(lignepapa)
 
def reglesautomate () :
    lignegarcon = []
    for i in range (0,u) :
        if lignepapa[int((i-1)%u)]==1 and lignepapa [i]==1 and lignepapa [int((i+1)%u)]==1 :
            lignegarcon.append (dec2bin [0])
        elif lignepapa[int((i-1)%u)]==1 and lignepapa [i]==1 and lignepapa [int((i+1%u)]==0 :
            lignegarcon.append (dec2bin [1])
        elif lignepapa[int((i-1)%u)]==1 and lignepapa [i]==0 and lignepapa [int((i+1)%u)]==1 :
            lignegarcon.append (dec2bin [2])
        elif lignepapa[int((i-1)%u)]==0 and lignepapa [i]==1 and lignepapa [int((i+1)%u)]==0 :
            lignegarcon.append (dec2bin [3])
        elif lignepapa[int((i-1)%u)]==0 and lignepapa [i]==1 and lignepapa [int((i+1)%u]==1 :
            lignegarcon.append (dec2bin [4])
        elif lignepapa[int((i-1)%u)]==0 and lignepapa [i]==1 and lignepapa [int((i+1)%u)]==0 :
            lignegarcon.append (dec2bin [5])
        elif lignepapa[int((i-1)%u)]==0 and lignepapa [i]==0 and lignepapa [int((i+1)%u)]==1 :
            lignegarcon.append (dec2bin [6])
        else :
            lignepapa [int((i-1)%u)]==0 and lignepapa [i]==0 and lignepapa [int((i+1)%u)]==0
            lignegarcon.append (dec2bin [7])
 
    return lignegarcon
 
ligneenfant= reglesautomate ()
 
print ligneenfant
 
def repeat (n,regle, lignepapa) :
    n= int (n)
    print lignepapa

J'ai plusieurs problèmes :

1) J'ai réalisé le début en utilisant "raw_input" or, on demande de pouvoir invoquer l'automate à partir du terminal. Comment faire?

2) la fin de mon code me donne une ligne de 0 et non un réel nouvel "état". Je ne comprends pas pourquoi :(

3) Comment répéter la règle sur "n" ligne filles?

Merci beaucoup d'avance !

05/12/2011, 20h54
afranck64

Bonsoir, pour usage de la balise code (le bouton <#>) vous aurez au moins 40% de lecteurs en plus.
05/12/2011, 21h02
fred1599
1) Tu peux mettre ton code entre les balises code (#) prévues à cet effet.

2) Pourquoi ne pas utiliser la force python pour transformer un décimal en binaire.

Code:

bin(154) # retourne le nombre binaire du décimal 154

3)

Citation:

3) Comment répéter la règle sur "n" ligne filles?
Code:

1 2 for n in xrange(5): # écris 5 fois l'affichage de la valeur n print n
4) Je ne comprend rien du tout à ton code, déjà parce-qu'il est pas entre les balises code et surtout il y a des lignes répétitives et je pars de principe que si ton professeur te demande de coder un automate, tu dois avoir un code simple te permettant de créer tes répétitions suivant un indice par exemple

Un truc du genre
Code:

1 2 for i, j in enumerate(lignepapa): # Action
06/12/2011, 00h07
Martin123

Premièrement, merci pour ces réponses si rapide ! :)

Alors voici ce que j'ai fait dans mon code (non fini)

Le professeur doit pouvoir lancer l'automate en tapant juste la ligne de départ, la règle de l'automate et le nombre de colonnes qu'il souhaite.

1) d'abord j'ai fait une fonction de conversion des décimals vers le binaire. Apparement je me suis cassé la tête pour rien :roll: .

2) Je demande au professeur d'entre la ligne de départ qu'il tapera au hasard. Par exemple : 1001001001010 . Le but est d'ensuite transformer cette ligne de départ grâce à la fonction en 3) et que la fonction donne une lignefille à chaque fois sur base de la ligne juste avant et pas de la ligne de départ.

3) Si je prends une règle de 30 ca me donne (en binaire) [0, 0, 0, 1, 1, 1, 1, 0] et je sais que j'ai 8 possibilités pour mes cellules (111,110,101,100,011,010,001,000). 0 = cellule vivante et 1= cellule morte. 111->0, 100 -> 1 , etc...
En gros, j'ai établis une fonction qui reprend chaque chiffre de mon nombre en binaire pour le transformer selon la règle choisie par le professeur. Elle est très répétitive et moche mais je vois pas vraiment comment faire autrement. :? (%u c'est pour rendre le tableau circulaire, je sais pas si je suis censé faire comme ca)

Merci beaucoup pour le temps accordé fred ! :)
06/12/2011, 00h32
fred1599
Ok alors sache que j'ai jamais fais de bio à haut niveau, il te faudra être explicite voir expliquer les bases pour que je puisse comprendre un peu ce que tu demandes.

Pour tes combinaisons, tu peux utiliser le module itertools

Puis un dico
Code:

1 2 3 >>> dico = {'111':1, '000':0} >>> print(dico['111']) 1
Vaut mieux faire les choses petits à petit, je veux bien t'aider, mais c'est toi qui travaille ;)
06/12/2011, 08h54
josmiley

j'ai pas compris l'histoire des règles ... quelqu'un peut m'expliquer ?

automates

Bonjour,
pour faire un automate selon ta feuille d'exercice, tu peux commencer ton programme comme il suit afin de récupérer les informations entrées par l'utilisateur
Code:

1 2 3 4 5 6 7 8 9 10 11 12 import sys try: initState = [int(x) for x in sys.argv[1]] processLen = int(sys.argv[2]) idRule = int(sys.argv[3]) except: print 'parameters error' #affiche les parametres obtenus sur l entree du programme print "%s\t%s\t%s" % (initState,processLen,idRule)
ces quelques lignes lancées avec

Code:

python script.py 001001001 10 15

permet d'avoir les variables que tu souhaite dans le bon format.

ensuite, comme le suggère ton TP, il serait judicieux de faire autant de fonction qu'il y a de règles, et une fonction qui détermine quelle règle appliquer. par exemple:

tu fais une règle bidon:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 def rule1(etat): #etat est la liste des etats de ton automate #on va generer l etat t+1 a partir de l etat donne nouvelEtat = [] for i in xrange(len(etat)): if i == 0: #cas ou on ne peut pas lire i-1 nouvelEtat.append(1) #appliquer la regle pour i elif i == len(etat)-1: nouvelEtat.append(1) #cas ou il n'y a pas de valeurs a i+1 else:#exemple de regle bidon if etat[i-1] == 0 and etat[i+1] == 1: nouvelEtat.append(1) else: nouvelEtat.append(0) return nouvelEtat
Avec au dessus, une fonction qui ordonne les règles
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 def applyRule(initState,processLen,idRule): state = initState #on dit u'on utilise la reference state for time in xrange(processLen): if idRule == 1: state = rule1(state) if idRule == 2: pass """ on transforme l etat a l instant t en l etat a l instant t+1 en construisant un nouveau resultat plutot que modifier l etat afin de considerer que l automate evolue en parallele. """ #a chaque etape, on affiche le nouvel etat print state
et enfin, une fonction qui lance le tout:
Code:

1 2 if __name__ == "__main__": applyRule(initState,processLen,idRule)
Avec ca, tu as le squelette d un automate cellulaire en python, il faut surtout que tu comprennes comment ça marche, et aussi que tu ajoutes les différentes règles qui te sont demandées.

Si ce domaine te passionne, tu pourrais regarder le Master 2 MOCAD à l'université de Lille 1 ... qui sait.

Citation:

Envoyé par utopman

ensuite, comme le suggère ton TP, il serait judicieux de faire autant de fonction qu'il y a de règles, et une fonction qui détermine quelle règle appliquer.

heu oué ...
la détermination de la règle tient en une ligne
et la génération de l'état n+1 tient en une ligne aussi

max 10 lignes pour faire un truc propre.

aller, un oneline pour le respect de la PEP ^^:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 gen = lambda etat,regle: ''.join([str(bin(regle))[2:].zfill(8)[7-int((etat[-1]+etat+etat[0])[i:i+3],2)]for i in range(len(etat))]) etat = '100101111010110' for i in range(10): etat = gen(etat,60) print(etat) '110111000111101' '001100100100011' '101010110110010' '111111101101011' '000000011011110' '000000010110001' '100000011101001' '010000010011101' '111000011010011' '000100010111010'

on me demande par MP d'expliquer le oneline que j'ai posté, autant en faire profiter tout le monde ... ;)

soit la regle 30 lut de bas en haut:
Code:

1 2 3 4 5 6 7 8 9 10 clé ( indice ) valeur '000' (0 en binaire) --> '0' ^ '001' (1 en binaire) --> '1' | '010' (2 en binaire) --> '1' | '011' (3 en binaire) --> '1' | '100' (4 en binaire) --> '1' | ça fait 30 en binaire '101' (5 en binaire) --> '0' | '110' (6 en binaire) --> '0' | '111' (7 en binaire) --> '0' |
la regle lut à l'envers tiens dans une liste ... la clé est l'indice associé à la valeur
ex:
'011' doit donner '1'
à l'indice 3 de la liste ci-dessous ('011' en décimal) on à bien un '1'
Code:

1 2 ['0','1','1','1','1','0','0','0'] <------------------------------ ça fait 30 en binaire
il suffit dinc d'inverser l'ordre des bits de la règle écrite en binaire pour obtenir une représentation exploitable ...

soit un motif:

'100101111010110'
pour donner l'illusion que c'est circulaire je copie le bit de la fin au début, et celui du début à la fin
Code:

1 2 3 |---------------| 0'100101111010110'1 |_______________|
on à un nouveau motif '01001011110101101' dont on parcours les triplets ... qui servent d'indices pour la regle.
Code:

1 2 3 4 5 6 7 8 '01001011110101101' resultat [010] -------------- 2 en binaire ['0','1','1','1','1','0','0','0'][2] --> 1 [100] ------------- 4 en binaire ['0','1','1','1','1','0','0','0'][4] --> 1 [001] ------------ 1 en binaire ['0','1','1','1','1','0','0','0'][1] --> 1 [010] ----------- 2 en binaire ['0','1','1','1','1','0','0','0'][2] --> 1 [101] ---------- 5 en binaire ['0','1','1','1','1','0','0','0'][5] --> 0 [etc] .......................................................... ...
et résultat, ben ... c'est le résultat ...

11/12/2011, 18h50
forscience

super merci beaucoup josmiley