When casting a NumPy Not-a-Number value as a boolean, it becomes True, e.g. as follows.
>>> import numpy as np
>>> bool(np.nan)
True
This is the exact opposite to what I would intuitively expect. Is there a sound principle underlying this behaviour?
(I suspect there might be as the same behaviour seems to occur in Octave.)
This is in no way NumPy-specific, but is consistent with how Python treats NaNs:
In [1]: bool(float('nan'))
Out[1]: True
The rules are spelled out in the documentation.
I think it could be reasonably argued that the truth value of NaN should be False. However, this is not how the language works right now.
True unless it is one of the specifically defined false cases (e.g., None, False, numeric zeroes, empty sequences, user-defined classes that return one of these, etc.).
bool(np.nan) evaluating to True is the cleanest way (by fiat) to handle comparisons consistently, where __bool__ may be called for similar use cases. NaN is unordered here, so they simply picked a convention to follow.Python truth-value testing states that the following values are considered False:
- zero of any numeric type, for example, 0, 0L, 0.0, 0j.
Numpy probably chose to stick with this behaviour and prevent NaN from evaluating to False in a boolean context. Note however that you can use numpy.isnan to test for NaN.
0.0 is the only falsy float value because that's what the language designers decided would be most useful. Numpy simply follows along. (It would be weird to have bool(np.nan) be False when bool(float('nan')) is True).
I think it is probably because that's how things work with integers. Admittedly, integers have no NaN or inf types of values, but I suppose that special cases aren't special enough to break the rules.
nan false as well.
numpy was part of the OP's question. I don't think that really changes anything though. It just makes sense for numpy to do what python does.
Numpy does it because Python does it, and Python does it because C does it. But why does C do it?
IEEE 754 requires that for +0 and -0 all the exponent and fraction bits are zero. For NaN the exponent is all ones and the fraction is non-zero.
As What happens when a float is cast to/from a boolean at the first principle level? describes, the comparison to zero is likely a single fast instruction. Checking for NaNs may be more expensive.
Another possible explanation is that this conversion has existed even before NaNs were introduced. It wasn't immediately updated, and now it's too late to change it.
Numpy follows the python standard for truth testing here, any numeric type evaluates to False if and only if its numerical value is zero.
Note that truth testing with NaN values can be unintuitive in other ways as well (e.g., nan == nan evaluates to False).
This is usually needed when testing variables for np.nan. While np.nan is not np.nan fails (evaluates to False), the np.isnan function works (evaluates to True, so can be used to test for np.nan):
np.isnan(np.nan)
True
You may use np.isnan(foo) to do Boolean checks on NumPy nan values.
In [1]: np.isnan(np.nan)
Out[1]: True
In [1]: not np.isnan(np.nan)
Out[1]: False
https://numpy.org/doc/stable/reference/generated/numpy.isnan.html
When any scalar value is converted to _Bool, the result is 0 if the value compares equal to 0; otherwise, the result is 1.Footnote 59 explicitly states thatNaNs do not compare equal to 0 and thus convert to 1.