how to remove positive infinity from numpy array...if it is already converted to a number?

Question

How does one remove positive infinity numbers from a numpy array once these are already converted into a number format? I am using a package which uses numpy internally, however when returning certain arrays, certain values are returned as the 1.79769313486e+308 positive infinity number.

Is there an elegant and fast way to remove these (I would like '0' in my case), or is iterating through the array the best solution?

Answer 1

First of all, 1.79769313486e+308 is not the same as +inf. The former is the largest number which can be expressed with a 64-bit float, the latter is a special float.

If you just have very large numbers in your array, then:

A[A > 1e308] = 0

is sufficient. Thet'll replace oll elements above 1e308 with 0.

It is also possible to operate with the inf's. For example:

>>> fmax = np.finfo(np.float64).max
>>> pinf = float('+inf')
>>> ninf = float('-inf')
>>> fnan = float('nan')
>>> print fmax, pinf, ninf, fnan
1.79769313486e+308 inf -inf nan

So, these are completely different things. You may compare some of them:

>>> pinf > fmax
True
>>> ninf < 0.0
True
>>> pinf == pinf
True
>>> pinf == ninf
False

This looks good! However, nan acts differently:

>>> fnan > 0
False
>>> fnan < 0
False
>>> fnan == 0
False
>>> fnan < pinf
False
>>> fnan == fnan
False

You may use positive and negativi infinities with Numpy ndarraywithout any problems. This will work:

A[A == pinf] = 0.0

But if you have nans in the array, you'll get some complaints:

>>> np.array([fnan, pinf, ninf]) < 0
RuntimeWarning: invalid value encountered in less
[False, False, True]

So, it works but complains => do not use. The same without the nan:

>>> np.array([0.0, pinf, ninf]) < 0
[False, False, True]

If you want to do something with the nans (should you have them), use numpy.isnan:

A[np.isnan(A)] = 0.0

will change all nans into zeros.

---

And -- this you did not ask -- here is one to surprise your friends (*):

>>> [float('-0.0'), 0.0] * 3
[-0.0, 0.0, -0.0, 0.0, -0.0, 0.0]

Yep, float64 (and float32) have even a separate -0.0. In calculations it acts as an ordinary zero, though:

>>> float('-0.0') == 0.0
True

(*) Depending on the kind of people you call friends.