# Multiplying a numpy array with another numpy array at a specific index

For ease of explanation I will be using 2-dimensional numpy arrays (I am using 3-dimensional arrays in my problem).

I have 2 arrays, one records the odds of something occuring at those specific coordinates. The other array is a pre-generated matrix that is used to lower the values of the first array around a central point in a pre-determined radius.

I want to automatically select points in the first matrix (henceforth A), and prevent the program to select another point that sits too close to previously selected points. So I want to multiply the values around the selected point related to the distance from said point.

E.G.:

Matrix A:

[[0, 0, 0, 0, 0, 0],
[0, 1, 2, 2, 1, 0],
[0, 2, 4, 4, 2, 0],
[0, 2, 4, 4, 2, 0],
[0, 1, 2, 2, 1, 0],
[0, 0, 0, 0, 0, 0]]

Matrix B:

[[ 1, 0.5, 1 ],
[0.5, 0, 0.5],
[ 1, 0.5, 1 ]]

Now say that index [2, 1] is selected as a point of interest. B is multiplied with A, but only with the values in a 3*3 around [2, 1]

Result:

[[0,  0,  0, 0, 0, 0],
[0, 0.5, 0, 1, 1, 0],
[0,  2,  2, 4, 2, 0],
[0,  2,  4, 4, 2, 0],
[0,  1,  2, 2, 1, 0],
[0,  0,  0, 0, 0, 0]]

This should result in the points around [2, 1] not being valuable enough to be selected as points of interest, unless the conditions are high enough to be selected anyway, hence the multiplication.

Now, I can’t seem to figure out a way to perform this specific multiplication. numpy.multiply() would repeat B so that it gets applied over the entire matrix A while I only want to apply it on a small part of A.

Another option would be looping over the affected section of Matrix A, but this requires an insane amount of time (especially in 3-dimensional matrices)

In other words, I want to apply a convolution filter without summing up the multiplication results at the end, but apply them to the underlying values of the convolved matrix (A)

Any insights on this issue are appreciated.

The easiest solution uses slicing:

A[5:8, 8:11] = np.multiply(A[5:8,8:11], B)

What this does is extract from A the 3×3 area around the selected point (here [6,9]), multiply it (element-wise) by B, and write it back at the same location.

Since you talked about convolution, if you want to use that the approach would be to create a matrix M of the same shape as A, but that is zero everywhere except at the selected point. This matrix you can convolve with B, and then multiply with A:

M = np.zeros(A.shape)
M[6,9] = 1
M = scipy.ndimage.filters.convolve(M, B)
A = np.multiply(A, M)

(or something to that extent, I did not test this variant).