nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None)

If x is inexact, NaN is replaced by zero or by the user defined value in :None:None:`nan` keyword, infinity is replaced by the largest finite floating point values representable by x.dtype or by the user defined value in posinf keyword and -infinity is replaced by the most negative finite floating point values representable by x.dtype or by the user defined value in neginf keyword.

For complex dtypes, the above is applied to each of the real and imaginary components of x separately.

If x is not inexact, then no replacements are made.

Notes

NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity.

Parameters

x : scalar or array_like

Input data.

copy : bool, optional

Whether to create a copy of x (True) or to replace values in-place (False). The in-place operation only occurs if casting to an array does not require a copy. Default is True.

versionadded

nan : int, float, optional

Value to be used to fill NaN values. If no value is passed then NaN values will be replaced with 0.0.

versionadded

posinf : int, float, optional

Value to be used to fill positive infinity values. If no value is passed then positive infinity values will be replaced with a very large number.

versionadded

neginf : int, float, optional

Value to be used to fill negative infinity values. If no value is passed then negative infinity values will be replaced with a very small (or negative) number.

versionadded

Returns

out : ndarray

x, with the non-finite values replaced. If copy is False, this may be x itself.

Replace NaN with zero and infinity with large finite numbers (default behaviour) or with the numbers defined by the user using the :None:None:`nan`, posinf and/or neginf keywords.

See Also

isfinite

Shows which elements are finite (not NaN, not infinity)

isinf

Shows which elements are positive or negative infinity.

isnan

Shows which elements are Not a Number (NaN).

isneginf

Shows which elements are negative infinity.

isposinf

Shows which elements are positive infinity.

Examples

>>> np.nan_to_num(np.inf)
1.7976931348623157e+308

>>> np.nan_to_num(-np.inf)
-1.7976931348623157e+308

>>> np.nan_to_num(np.nan)
0.0

>>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
... np.nan_to_num(x)
array([ 1.79769313e+308, -1.79769313e+308,  0.00000000e+000, # may vary
       -1.28000000e+002,  1.28000000e+002])

>>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
array([ 3.3333333e+07,  3.3333333e+07, -9.9990000e+03, 
       -1.2800000e+02,  1.2800000e+02])

>>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
array([  1.79769313e+308,  -1.79769313e+308,   0.00000000e+000, # may vary
     -1.28000000e+002,   1.28000000e+002])

>>> np.nan_to_num(y)
array([  1.79769313e+308 +0.00000000e+000j, # may vary
         0.00000000e+000 +0.00000000e+000j,
         0.00000000e+000 +1.79769313e+308j])

>>> np.nan_to_num(y, nan=111111, posinf=222222)
array([222222.+111111.j, 111111.     +0.j, 111111.+222222.j])

See :

Local connectivity graph

Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.

Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)

SVG is more flexible but power hungry; and does not scale well to 50 + nodes.

All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them

---

GitHub : /numpy/lib/type_check.py#404
type: <class 'function'>
Commit: