How can I vectorize the interaction of two numpy arrays

Consider two numpy arrays:

1. array a: The important feature of array a is that every pair of columns (p and q) has a row that holds values (q and p) in that order.
   For example, columns 0 and 3 hold values 3 and 0 in row 2, and columns 4 and 5 hold values 5 and 4 in row 1.

   a = np.array([[1, 0, 4, 5, 2, 3],
                 [2, 3, 0, 1, 5, 4],
                 [3, 4, 5, 0, 1, 2],
                 [4, 5, 3, 2, 0, 1],
                 [5, 2, 1, 4, 3, 0]])
   

2. array b: The first two columns show ALL column pairs (p and q) from array a. The remaining two columns are multipliers, as shown in the following: Consider array b's row 5 [1, 2, 4, -3]. We examine columns 1 and 2 of array a, and locate the values 2 and 1. Then we replace, in array a, the 2 by 2x4=8, and we replace the 1 by 1x(-3) = -3.

   b = np.array([[0, 1,  3  -1],
                 [0, 2, -1,  3],
                 [0, 3, -2,  4],
                 [0, 4, -1,  0],
                 [0, 5, -1,  4],
                 [1, 2,  4, -3],
                 [1, 3,  0, -1],
                 [1, 4,  1, -2],
                 [1, 5,  1,  1],
                 [2, 3,  1,  1],
                 [2, 4, -1,  0], 
                 [2, 5, -1,  1],
                 [3, 4,  0,  0],
                 [3, 5,  2,  1],
                 [4, 5,  1, -2]])
   

The final result would look like:

   c = np.array([[ 3, 0,-4,10, 0, 3],
                 [-2, 0, 0,-1, 5,-8],
                 [-6, 4,-5, 0,-2, 2],
                 [-4, 5, 3, 2, 0, 1],
                 [-5, 8,-3, 0, 0, 0]])       

Here is what I've been using. It works well for smaller arrays (produces the array c shown above), but my coding skills are quite rusty:

c = np.copy(a)

for brow in b:       
    arow = np.where(a[:, brow[0]] == brow[1])
    c[arow, brow[0]] = (a[arow, brow[0]])*brow[2]
    c[arow, brow[1]] = (a[arow, brow[1]])*brow[3]  
    
print(c)   

Could this be vectorized?

Here is a solution which needs dimensionality ascension. Let's define your codes in a function for comparing the performance.

def find_c(a, b):
    c = np.copy(a)
    for brow in b:       
        arow = np.where(a[:, brow[0]] == brow[1])
        c[arow, brow[0]] = (a[arow, brow[0]])*brow[2]
        c[arow, brow[1]] = (a[arow, brow[1]])*brow[3] 
    return c

And my solution which I wrote some comments for explaining :

def find_c_1(a, b):
    c = np.copy(a)
    # ascension for indexing the data
    array_find = a[:, None][:, 0, b[:, 0]].T
    # find the index corresponds the values of b[:, 1] in array
    index = np.where(array_find == b[:, 1].reshape(-1, 1))
    
    # index[1] is the index of rows , b[:, 0] is the index of columns 
    # Then the assignment of the values
    c[index[1], b[:, 0]] = c[index[1], b[:, 0]] * b[:, 2]
    c[index[1], b[:, 1]] = c[index[1], b[:, 1]] * b[:, 3]
    return c

For comparing the result :

c1 = find_c(a, b)
c2 = find_c_1(a, b)
print(np.array_equal(c1, c2))  # True

For comparing the performance:

%timeit find_c(a, b)
314 µs ± 5.92 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit find_c_1(a, b)
23.8 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)