Ich habe in Python versucht, eine doppelte Schleife über ein 2D Array (Variante 1) durch "array slice" Operationen (Variante 2) zu optimieren, stelle aber fest, dass dies nichts bringt, sondern die Rechenzeit sogar etwas größer wird.
Ich dachte eigentlich, dass man wo immer möglich slice Notation verwenden sollte, da dies schneller ist. Scheinbar kann man das aber nicht so einfach sagen.
Wann sind slice Operationen schneller bzw. von Vorteil? Leserlicher wid der Code ja nicht, aber dass er sogar langsamer wird überrascht mich nun doch ein wenig...
Der Code:
import numpy as np
import numpy.ma as ma
import time
def test():
f = np.array([
[0, 0, 0, 0, 0, 0, 0],
[0, 1, 3, 6 , 4, 2, 0],
[0, 2, 4, 7 , 6, 4, 0],
[0, 0, 0, 0, 0, 0, 0]
], dtype=float)
u = np.array([
[0, 0, 0, 0, 0, 0, 0],
[0, 0.5, 1, 0, -1, -0.5, 0],
[0, 0.7, 1.1, 0, -1, -0.4, 0],
[0, 0, 0, 0, 0, 0, 0],
], dtype=float)
# calculate : variant 1
x = np.zeros_like(f)
maxcount = 100000
start = time.time()
for count in range(maxcount):
for i in range(1,u.shape[0]-1):
for j in range(1,u.shape[1]-1):
if u[i,j] > 0:
x[i,j] = u[i,j]*(f[i,j]-f[i,j-1])
else:
x[i,j] = u[i,j]*(f[i,j+1]-f[i,j])
end = time.time()
print("used time for variant 1:", end-start)
# calculate : variant 2
y = np.zeros_like(f)
start = time.time()
for count in range(maxcount):
maskl = (u[1:-1, 1:-1] > 0)
maskr = ~maskl
diff = f[1:-1, 1:] - f[1:-1, 0:-1]
yy = (y[1:-1, 1:-1])
uu = (u[1:-1, 1:-1 ])
yy[maskl] = uu[maskl] * (diff[:, :-1])[maskl]
yy[maskr] = uu[maskr] * (diff[:, 1: ])[maskr]
end = time.time()
print("used time for variant 2:", end-start)
np.testing.assert_array_equal(x, y)
test()
Die Ausgabe:
D:\python\animation>python test.py
used time for variant 1: 1.0328729152679443
used time for variant 2: 1.3058593273162842
D:\python\animation>python test.py
used time for variant 1: 1.1189219951629639
used time for variant 2: 1.3527190685272217
D:\python\animation>python test.py
used time for variant 1: 1.066974401473999
used time for variant 2: 1.3022441864013672
