Comment lisser rapidement un tableau 1000x1000 - python, tableaux, python-2.7

Nous simulons une sédimentation dans une baie française(Mont Saint Michel), pour cela, nous mettons des sédiments (représentés par des nombres) dans un tableau. Le dépôt est aléatoire dans notre matrice 1000x1000, avec une île au milieu.

À la fin du programme, nous aimerions lisser notre baie partout sauf dans l’île où les chiffres sont nuls.

Nous l’avons fait, mais c’est beaucoup trop long à exécuter. Quelqu'un peut-il nous aider à trouver un moyen d’accélérer notre programme?

for j in range (0,375):
for decale in range (250):

diff=M[749+decale][j]-M[749+decale+1][j]
if diff>=3:
M[749+decale][j]-=floor(19*diff/20)
M[749+decale+1][j]+=floor(19*diff/20)

for j in range (625,1000):  #for the S-W of the bay
for decale in range (250):

diff=M[749+decale][j]-M[749+decale+1][j]
if diff>=3:
M[749+decale][j]-=floor(19*diff/20)
M[749+decale+1][j]+=floor(19*diff/20)

for i in range (800,1000):


for decale in range (799): For the West of the bay

diff=M[i][200+decale]-M[i][200+decale+1]
if diff>=3:
M[i][200+decale]-=floor(19*diff/20)
M[i][200+decale+1]+=floor(19*diff/20)

for decale in range (799): #Idem

diff=M[i][799-decale]-M[i][799-decale-1]
if diff>=3:
M[i][799-decale]-=floor(19*diff/20)
M[i][799-decale-1]+=floor(19*diff/20)

for j in range (0,375): #Along the island
for decale in range (350):
diff=M[850-decale][j]-M[850-decale-1][j]
if diff>=3:
M[850-decale][j]-=floor(19*diff/20)
M[850-decale-1][j]+=floor(19*diff/20)

for j in range(625,1000): #Idem
for decale in range (350):
diff=M[850-decale][j]-M[850-decale-1][j]
if diff>=3:
M[850-decale][j]-=floor(19*diff/20)
M[850-decale-1][j]+=floor(19*diff/20)

for i in range (500,549): #Idem
for decale in range (500):

diff=M[i][499+decale]-M[i][499+decale+1]
if diff>=3:
M[i][499+decale]-=floor(19*diff/20)
M[i][499+decale+1]+=floor(19*diff/20)

for decale in range (500):  #Idem

diff=M[i][500-decale]-M[i][500-decale-1]
if diff>=3:
M[i][500-decale]-=floor(19*diff/20)
M[i][500-decale-1]+=floor(19*diff/20)

return M

Réponses:

Je ne peux rien dire sur l'exactitude de ces boucles. Je viens de les traduire en tableau Numpy, de sorte qu'il peut être un peu plus lisible.

import numpy as np

M = np.array(M)

diff = M[749:-1,:375]-M[750:,:375]
M[749:-1,:375][diff>=3] -= np.floor(19*diff[diff>=3]/20)
M[750:  ,:375][diff>=3] += np.floor(19*diff[diff>=3]/20)

diff = M[749:-1,625:]-M[750:,625:] # for the S-W of the bay
M[749:-1,625:][diff>=3] -= np.floor(19*diff[diff>=3]/20)
M[750:  ,625:][diff>=3] += np.floor(19*diff[diff>=3]/20)

diff = M[800:,200:-1]-M[800:,201:] # for the West of the bay
M[800:,200:-1][diff>=3] -= np.floor(19*diff[diff>=3]/20)
M[800:,201:  ][diff>=3] += np.floor(19*diff[diff>=3]/20)

diff = M[800:,1:800]-M[800:,:799] #Idem
M[800:,1:800][diff>=3] -= np.floor(19*diff[diff>=3]/20)
M[800:, :799][diff>=3] += np.floor(19*diff[diff>=3]/20)

diff = M[501:851,:375]-M[500:850,:375] #Along the island
M[501:851,:375][diff>=3] -= np.floor(19*diff[diff>=3]/20)
M[500:850,:375][diff>=3] += np.floor(19*diff[diff>=3]/20)

diff = M[501:851,625:]-M[500:850,625:] #Idem
M[501:851,625:][diff>=3] -= np.floor(19*diff[diff>=3]/20)
M[500:850,625:][diff>=3] += np.floor(19*diff[diff>=3]/20)

diff = M[500:549,499:-2]-M[500:549,500:-1] #Idem
M[500:549,499:-2][diff>=3] -= np.floor(19*diff[diff>=3]/20)
M[500:549,500:-1][diff>=3] += np.floor(19*diff[diff>=3]/20)

diff = M[500:549,1:501]-M[500:549,:500] #Idem
M[500:549,1:501][diff>=3] -= np.floor(19*diff[diff>=3]/20)
M[500:549,:500][diff>=3] += np.floor(19*diff[diff>=3]/20)