CODEWITHSUNDEEP
pythonnumpyperformancenumerical
kame
kame

Reputation: 21970

Speed up a program that calculate the average of the neighbors in a huge array

I have a problem with the speed of my program. I want to calculate the average of four neighbors in a huge array. Here is a part of my code. Do you have any ideas how to change the last line? Or should I use another array?

for a in np.arange(100000):
    for x in np.arange(size):
        for y in np.arange(size):
            if unchangeableflag[x*size+y] == 0:
                vnew[x*size+y] = (v[(x+1)*size+y] + v[(x-1)*size+y] + v[x*size+y+1] + v[x*size+y-1]) / 4.0

Upvotes: 2

Views: 1515

Answers (3)

Benjamin
Benjamin

Reputation: 11860

You should consider using SciPy's convolution filter or the generic_filter. This is still computationally intensive, but way faster than looping. Normally, when doing this type of averaging, the central element is also included. Note that these solutions also apply to multi-dimensional arrays.

from scipy import ndimage
footprint = scipy.array([[0,0.25,0],[0.25,0,0.25],[0,0.25,0]])
filtered_array = scipy.convolve(array, footprint)

OR

from scipy import ndimage
def myfunction(window):
    return (window[0,1] + window[1,0] + window[1,2] + window[2,1]) / 4
filtered_array = scipy.generic_filter(array, myfunction, size=3)

Upvotes: 3

Sven Marnach
Sven Marnach

Reputation: 601709

You would not need the loop at all. Assuming v, vnew and unchangeableflag are 1-d arrays with size*size entries, you can do

v = v.reshape(size, size)
vnew = vnew.reshape(size, size)
unchangeableflag = unchangeableflag.reshape(size, size)
average = v[1:-1, 2:]
average += v[1:-1, :-2] 
average += v[2:, 1:-1]
average += v[-2:, 1:-1]
average /= 4.0
vnew[1:-1, 1:-1][unchangeableflag[1:-1, 1:-1] == 0] = average

But what are you actually trying to achieve? This looks suspiciously like you could get away with some application of the discrete Laplacian.

(Note that this assumes that v contains floating point numbers. If the dtype of `v´ is sime integral type, you need a slight modification.)

Upvotes: 4

VGE
VGE

Reputation: 4191

I am unsure but you can remove some invariant.

for a in np.arange(100000):
    for x in np.arange(size):
        for y in np.arange(size):
            t = x*size+y
            if unchangeableflag[t] == 0:
                vnew[t] = (v[t+size] + v[t-size] + v[t+1] + v[t-1]) / 4.0

Upvotes: 1

Related Questions