code: def nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None):
      """
      Replace NaN with zero and infinity with large finite numbers (default
      behaviour) or with the numbers defined by the user using the `nan`,
      `posinf` and/or `neginf` keywords.
  
      If `x` is inexact, NaN is replaced by zero or by the user defined value in
      `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.
  
      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:: 1.13
      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:: 1.17
      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:: 1.17
      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:: 1.17
  
  
  
      Returns
      -------
      out : ndarray
          `x`, with the non-finite values replaced. If `copy` is False, this may
          be `x` itself.
  
      See Also
      --------
      isinf : Shows which elements are positive or negative infinity.
      isneginf : Shows which elements are negative infinity.
      isposinf : Shows which elements are positive infinity.
      isnan : Shows which elements are Not a Number (NaN).
      isfinite : Shows which elements are finite (not NaN, not infinity)
  
      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.
  
      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])
      """
      x = _nx.array(x, subok=True, copy=copy)
      xtype = x.dtype.type
  
      isscalar = x.ndim == 0
  
      if not issubclass(xtype, _nx.inexact):
          return x[()] if isscalar else x
  
      iscomplex = issubclass(xtype, _nx.complexfloating)
  
      dest = (x.real, x.imag) if iscomplex else (x,)
      maxf, minf = _getmaxmin(x.real.dtype)
      if posinf is not None:
          maxf = posinf
      if neginf is not None:
          minf = neginf
      for d in dest:
          idx_nan = isnan(d)
          idx_posinf = isposinf(d)
          idx_neginf = isneginf(d)
          _nx.copyto(d, nan, where=idx_nan)
          _nx.copyto(d, maxf, where=idx_posinf)
          _nx.copyto(d, minf, where=idx_neginf)
      return x[()] if isscalar else x
  
imports: import functools
  from .._utils import set_module
  import numpy.core.numeric
  from numpy.core.numeric import asarray, asanyarray, isnan, zeros
  from numpy.core import overrides, getlimits
  from .ufunclike import isneginf, isposinf
label_desc: Use image node_id 15 for calling a global function with example usage: nan_to_num(x, copy, nan, posinf, neginf) and returns: unknown, unknown