# How to return 0 with divide by zero

Posted on

### Question :

How to return 0 with divide by zero

I’m trying to perform an element wise divide in python, but if a zero is encountered, I need the quotient to just be zero.

For example:

``````array1 = np.array([0, 1, 2])
array2 = np.array([0, 1, 1])

array1 / array2 # should be np.array([0, 1, 2])
``````

I could always just use a for-loop through my data, but to really utilize numpy’s optimizations, I need the divide function to return 0 upon divide by zero errors instead of ignoring the error.

Unless I’m missing something, it doesn’t seem numpy.seterr() can return values upon errors. Does anyone have any other suggestions on how I could get the best out of numpy while setting my own divide by zero error handling?

In numpy v1.7+, you can take advantage of the “where” option for ufuncs. You can do things in one line and you don’t have to deal with the errstate context manager.

``````>>> a = np.array([-1, 0, 1, 2, 3], dtype=float)
>>> b = np.array([ 0, 0, 0, 2, 2], dtype=float)

# If you don't pass `out` the indices where (b == 0) will be uninitialized!
>>> c = np.divide(a, b, out=np.zeros_like(a), where=b!=0)
>>> print(c)
[ 0.   0.   0.   1.   1.5]
``````

In this case, it does the divide calculation anywhere ‘where’ b does not equal zero. When b does equal zero, then it remains unchanged from whatever value you originally gave it in the ‘out’ argument.

Building on @Franck Dernoncourt’s answer, fixing -1 / 0:

``````def div0( a, b ):
""" ignore / 0, div0( [-1, 0, 1], 0 ) -> [0, 0, 0] """
with np.errstate(divide='ignore', invalid='ignore'):
c = np.true_divide( a, b )
c[ ~ np.isfinite( c )] = 0  # -inf inf NaN
return c

div0( [-1, 0, 1], 0 )
array([0, 0, 0])
``````

Building on the other answers, and improving on:

Code:

``````import numpy as np

a = np.array([0,0,1,1,2], dtype='float')
b = np.array([0,1,0,1,3], dtype='float')

with np.errstate(divide='ignore', invalid='ignore'):
c = np.true_divide(a,b)
c[c == np.inf] = 0
c = np.nan_to_num(c)

print('c: {0}'.format(c))
``````

Output:

``````c: [ 0.          0.          0.          1.          0.66666667]
``````

One-liner (throws warning)

``````np.nan_to_num(array1 / array2)
``````

Try doing it in two steps. Division first, then replace.

``````with numpy.errstate(divide='ignore'):
result = numerator / denominator
result[denominator == 0] = 0
``````

The `numpy.errstate` line is optional, and just prevents numpy from telling you about the “error” of dividing by zero, since you’re already intending to do so, and handling that case.

You can also replace based on `inf`, only if the array dtypes are floats, as per this answer:

``````>>> a = np.array([1,2,3], dtype='float')
>>> b = np.array([0,1,3], dtype='float')
>>> c = a / b
>>> c
array([ inf,   2.,   1.])
>>> c[c == np.inf] = 0
>>> c
array([ 0.,  2.,  1.])
``````

One answer I found searching a related question was to manipulate the output based upon whether the denominator was zero or not.

Suppose `arrayA` and `arrayB` have been initialized, but `arrayB` has some zeros. We could do the following if we want to compute `arrayC = arrayA / arrayB` safely.

In this case, whenever I have a divide by zero in one of the cells, I set the cell to be equal to `myOwnValue`, which in this case would be zero

``````myOwnValue = 0
arrayC = np.zeros(arrayA.shape())
indNonZeros = np.where(arrayB != 0)
indZeros = np.where(arrayB = 0)

# division in two steps: first with nonzero cells, and then zero cells
arrayC[indNonZeros] = arrayA[indNonZeros] / arrayB[indNonZeros]
arrayC[indZeros] = myOwnValue # Look at footnote
``````

Footnote: In retrospect, this line is unnecessary anyways, since `arrayC[i]` is instantiated to zero. But if were the case that `myOwnValue != 0`, this operation would do something.

``````>>> a = np.array([1,2,3], dtype='float')