对矩阵运算的精美索引

Question

Suppose:

A=np.array([1,2,0,-4])

B=np.array([1,1,1,1])

C=np.array([1,2,3,4])

With fancy indexing I can assign a scalar value to C wherever A > 0.

C[A > 0]= 1

But is there anyway to get something like C = B/A wherever A > 0 while preserving the original values of C for A <= 0 with fancy indexing? If I try something like

C[A > 0] =  B/A  

I get an error like:

<input>:1: RuntimeWarning: divide by zero encountered in true_divide
Traceback (most recent call last):
File "<input>", line 1, in <module>
ValueError: NumPy boolean array indexing assignment cannot assign 4 input values to the 2      output values where the mask is true

I can get the result with a for loop or making copies of A & C where:

D = np.copy(A)
E = np.copy(C) 
D[ D <= 0]= 1
E=B/A
E[A <=0] = C 
 

or set C=Run(A,B) where

def Run(A,B):
    C=np.zeros(A.shape[0],A.shape[1])
    for i in range(len(A)):
        if A[i] != O: 
            C[i] = A[i]/B[i]
        else:
            C[i] = C[i]       

But i was just wondering if there was a more direct way to do it without adding so many steps if i am looping millions of times. Thanks.

Answer 1

You can index the operands: C[A > 0] = B[A > 0] / A[A > 0] . You might want to compute A > 0 once, and reuse it, eg

mask = A > 0
C[mask] =  B[mask] / A[mask]

A more efficient alternative is to use the where parameter of np.divide or np.floor_divide . For example,

In [19]: A = np.array([1, 2, 0, -4])                                            

In [20]: B = np.array([1, 1, 1, 1])

In [21]: C = np.array([1, 2, 3, 4])

In [22]: np.floor_divide(B, A, where=A > 0, out=C)
Out[22]: array([1, 0, 3, 4])

In [23]: C        
Out[23]: array([1, 0, 3, 4])

I had to use floor_divide because all the arrays are integer arrays, and numpy.divide creates a floating point array, so that function will complain about the type mismatch if the out array is an integer array. If you want a floating point result, C should be an array of floating point values:

In [24]: C = np.array([1., 2., 3., 4.])

In [25]: np.divide(B, A, where=A > 0, out=C)
Out[25]: array([1. , 0.5, 3. , 4. ])

In [26]: C
Out[26]: array([1. , 0.5, 3. , 4. ])