Projet python

[B4nj]

Bonjour dans le cadre d'un projet python, je dois simuler l'évacuation d'une salle, mon programme ne fonctionne pas et je n'arrive pas à trouver l'erreur. Merci pour toute aide.

import numpy as np
import numpy.random as rd
from pylab import*


L=5
l=5
N=1 #nombre de personne
rd.seed()
piece=np.zeros((L,l),dtype=int)
for h in range(N):
    ir=rd.randint(0,L)
    jr=rd.randint(0,l)
    
    while(piece[ir,jr]==1):
        ir=rd.randint(0,L)
        jr=rd.randint(0,l)    
    piece[ir,jr]=1

porte=piece[0,0]
iporte=0
jporte=0
count=0
newpiece=piece

for i in range(L):
    for j in range(l):
        run=True
        while run:
                count=count+1  
               
                piece[iporte,jporte]=0
                for i in range(L):
                    for j in range(l):
                        if piece[i,j]==1:
                            d=np.ones(4)*10000
                            if i>0 and i+1<L and j>0 and j+1<l:
                                if piece[i-1,j]==0:
                                    d[0]=np.sqrt((i-1-iporte)**2+(j-jporte)**2) #case haut
                                if piece[i+1,j]==0:
                                    d[1]=np.sqrt((i+1-iporte)**2+(j-jporte)**2) #case bas
                                if piece[i,j-1]==0:
                                    d[2]=np.sqrt((i-iporte)**2+(j-1-jporte)**2) #case gauche
                                if piece[i,j+1]==0:
                                    d[3]=np.sqrt((i-iporte)**2+(j+1-jporte)**2) #case droite
                                print d
                                dmin=10000
                                for k in range(4):
                                    if d[k]<dmin:
                                        kmin=k
                                     else:
                                         kmin=10000
                            
                                if kmin==10000:
                                    newpiece[i,j]=1
                                else :
                                    if kmin==1:
                                        newpiece[i-1,j]=1
                                        newpiece[i,j]=0
                                    if kmin==2:
                                        newpiece[i+1,j]=1
                                        newpiece[i,j]=0
                                    if kmin==3:
                                        newpiece[i,j-1]=1
                                        newpiece[i,j]=0
                                    if kmin==4:
                                        newpiece[i,j+1]=1
                                        newpiece[i,j]=0
                                    
                                    
    
                                      
                m=0
                for i in range(L):
                    for j in range(l):
                        m=m+newpiece[i,j]
                if m==0:
                    run=False
                
print newpiece
print count

-----

[Chanur]

Bonjour,

Je ne vois pas le moyen de DEVINER ce qui ne marche pas dans un programme qu'on ne peut pas exécuter, dont on ne sait pas ce qu'il doit faire, ni ce qu'il fait effectivement !

Je ne sais pas ce que signifient nb, rd, pylab, l, L, etc.

Par contre iporte et jporte, c'est clair : ce sont des façon tordues d'écrire 0 ...

[B4nj]

J'ai modifié le code :

# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as rd
from pylab import*


L=5 #largeur
l=5 #longueur
N=1 #nombre de personne
rd.seed()
piece=np.zeros((L,l),dtype=int) # Génération d'un tableau
for h in range(N): # avec N 1 aléatoirement réparti
    ir=rd.randint(0,L)
    jr=rd.randint(0,l)
    
    while(piece[ir,jr]==1):
        ir=rd.randint(0,L)
        jr=rd.randint(0,l)    
    piece[ir,jr]=1


iporte=0
jporte=0
count=0
newpiece=piece
print newpiece


run=True
while run:
                count=count+1
                newpiece[iporte,jporte]=0
                for i in range(L):
                    for j in range(l):
                        if newpiece[i,j]==1:
                            d=np.ones(4)*10000
                            if i>0 and i+1<L and j>0 and j+1<l:
                                if newpiece[i-1,j]==0:
                                    d[0]=np.sqrt((i-1-iporte)**2+(j-jporte)**2) #case haut
                                if newpiece[i+1,j]==0:
                                    d[1]=np.sqrt((i+1-iporte)**2+(j-jporte)**2) #case bas
                                if newpiece[i,j-1]==0:
                                    d[2]=np.sqrt((i-iporte)**2+(j-1-jporte)**2) #case gauche
                                if newpiece[i,j+1]==0:
                                    d[3]=np.sqrt((i-iporte)**2+(j+1-jporte)**2) #case droite
                                
                            dmin=min(d)
                            for k in range(4):
                                if d[k]==dmin:
                                    kmin=k
                                
                            if kmin==0 and i<0:
                                        newpiece[i-1,j]=1
                                        newpiece[i,j]=0
                            if kmin==1 and i+1<L:
                                        newpiece[i+1,j]=1
                                        newpiece[i,j]=0
                            if kmin==2 and j<0:
                                        newpiece[i,j-1]=1
                                        newpiece[i,j]=0
                            if kmin==3 and j+1<l:
                                        newpiece[i,j+1]=1
                                        newpiece[i,j]=0
                        else:
                            newpiece[i,j]=0
                            
                                    
                                    
    
                                      
                m=0
                for i in range(L):
                    for j in range(l):
                        m=m+newpiece[i,j]
                if m==0:
                    run=False
                
print newpiece
print count

Alors ce programme génére un nombre N de 1 dans un tableau L,l et les répartis aléatoirement. A chaque itération, le programme calcul la distance entre la position du 1 et la position de la sortie. Il fait se déplacer le 1 dans la case la plus proche de la sortie. En théorie les 1 vont tous ce dirigé vers la sortie et le tableau va être remplie de 0, mais en réalité, les 1 ne se déplace pas et le tableau reste dans le même état et je n'arrive pas à trouver pourquoi.

[Chanur]

En même temps, iporte et jporte continuent à valoir 0 ...

[A voir en vidéo sur Futura]

[Arzhur]

En même temps, iporte et jporte continuent à valoir 0 ...

Je crois que c'est fait exprès : c'est l'emplacement de la porte de sortie qui ne bouge pas (imagine la porte qui bouge pdt un incendie )

if kmin==0 and i<0:

Ca par contre je vois pas pourquoi le i serait négatif....( ca serait pas là le pb ???)

[B4nj]

C'est bien sa iporte jporte est l'emplacement de la porte, oui il y avait bien une erreur avec i<0 que j'ai corriger mais cela ne corrige pas le problème le 1 ne bouge pas.

[Chanur]

Alors je te suggère de ne pas utiliser d'aleas, au début de ton programme (mets les en commentaire) et à la place de mettre une valeur connue (un cas simple), de réfléchir à ce que doit faire ton programme étape par étape, et de contrôler (éventuellement en ajoutant de affichages pour savoir par où on passe).

[Chanur]

et sinon, tu n'évacues les gens que s'ils sont sur une des 9 pièces centrales
(parce que "if i>0 and i+1<L and j>0 and j+1<l" à la ligne 37)

[Arzhur]

Ouais c'est ca le pb...chez moi il tourne ton algo (d'ailleurs c'est marrant ce truc)

[B4nj]

Merci beaucoup.

[B4nj]

Je deterre mon poste J'ai remarqué une faille dans mon algo, à certain moment, l'algo déplace 2 fois le 1 en une seule itération si quelqu'un à une idée j'ai cherché mais je ne vois pas...

[Arzhur]

Tu peux nous mettre ton algo ? ( il me semble que celui dans les messages n'est pas bon)

[B4nj]

# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as rd
from pylab import*


L=5 #largeur
l=5 #longueur
N=1 #nombre de personne
rd.seed()
piece=np.zeros((L,l),dtype=int) 
for h in range(N): 
    ir=rd.randint(0,L)
    jr=rd.randint(0,l)
    
    while(piece[ir,jr]==1):
        ir=rd.randint(0,L)
        jr=rd.randint(0,l)    
    piece[ir,jr]=1


iporte=0
jporte=0
count=0
newpiece=piece



run=True
while run:
                print newpiece
                count=count+1
                newpiece[iporte,jporte]=0
                for i in range(L):
                    for j in range(l):
                        if newpiece[i,j]==1:
                            d=np.ones(4)*10000
                            if i>=0 and i+1<=L and j>=0 and j+1<=l:
                                if newpiece[i-1,j]==0 and i>=1:
                                    d[0]=np.sqrt((i-1-iporte)**2+(j-jporte)**2) #case haut
                                if i<L-1 and newpiece[i+1,j]==0:
                                    d[1]=np.sqrt((i+1-iporte)**2+(j-jporte)**2) #case bas
                                if newpiece[i,j-1]==0 and j>=0:
                                    d[2]=np.sqrt((i-iporte)**2+(j-1-jporte)**2) #case gauche
                                if j<l-1 and newpiece[i,j+1]==0:
                                    d[3]=np.sqrt((i-iporte)**2+(j+1-jporte)**2) #case droite
                                
                            dmin=min(d)
                            for k in range(4):
                                if d[k]==dmin:
                                    kmin=k
                            print dmin   
                            if kmin==0:
                                        newpiece[i-1,j]=1
                                        newpiece[i,j]=0
                            if kmin==1:
                                        newpiece[i+1,j]=1
                                        newpiece[i,j]=0
                            if kmin==2 :
                                        newpiece[i,j-1]=1
                                        newpiece[i,j]=0
                            if kmin==3:
                                        newpiece[i,j+1]=1
                                        newpiece[i,j]=0
                        
                            
                                    
                                    
    
                                      
                m=0
                for i in range(L):
                    for j in range(l):
                        m=m+newpiece[i,j]
                if m==0:
                    run=False
                
                print newpiece
print count

[B4nj]

J'ai trouvé le problème, en fait quand le 1 est déplacé dans le sens de parcours de ma boucle principal il se fait redéplacer ... Il va falloir que je rajoute une condition pour qu'on ne puisse déplacer qu'une seule fois le 1.

[Chanur]

Simplement mettre des "else if" à la place des "if", non ?