address comments

Author: vtavana

dpnp/dpnp_iface.py

@@ -69,7 +69,6 @@
     "get_usm_ndarray_or_scalar",
     "is_supported_array_or_scalar",
     "is_supported_array_type",
-    "_replace_nan",
 ]
 
 from dpnp import float64, isscalar
@@ -91,6 +90,8 @@
 from dpnp.dpnp_iface_manipulation import __all__ as __all__manipulation
 from dpnp.dpnp_iface_mathematical import *
 from dpnp.dpnp_iface_mathematical import __all__ as __all__mathematical
+from dpnp.dpnp_iface_nanfunctions import *
+from dpnp.dpnp_iface_nanfunctions import __all__ as __all__nanfunctions
 from dpnp.dpnp_iface_searching import *
 from dpnp.dpnp_iface_searching import __all__ as __all__searching
 from dpnp.dpnp_iface_sorting import *
@@ -109,6 +110,7 @@
 __all__ += __all__logic
 __all__ += __all__manipulation
 __all__ += __all__mathematical
+__all__ += __all__nanfunctions
 __all__ += __all__searching
 __all__ += __all__sorting
 __all__ += __all__statistics
@@ -599,39 +601,3 @@ def is_supported_array_type(a):
     """
 
     return isinstance(a, (dpnp_array, dpt.usm_ndarray))
-
-
-def _replace_nan(a, val):
-    """
-    If `a` is of inexact type, make a copy of `a`, replace NaNs with
-    the `val` value, and return the copy together with a boolean mask
-    marking the locations where NaNs were present. If `a` is not of
-    inexact type, do nothing and return `a` together with a mask of None.
-    Note that scalars will end up as array scalars, which is important
-    for using the result as the value of the out argument in some
-    operations.
-    Parameters
-    ----------
-    a : {dpnp_array, usm_ndarray}
-        Input array.
-    val : float
-        NaN values are set to val before doing the operation.
-    Returns
-    -------
-    out : {dpnp_array}
-        If `a` is of inexact type, return a copy of `a` with the NaNs
-        replaced by the fill value, otherwise return `a`.
-    mask: {bool, None}
-        If `a` is of inexact type, return a boolean mask marking locations of
-        NaNs, otherwise return None.
-    """
-
-    dpnp.check_supported_arrays_type(a)
-    if issubclass(a.dtype.type, dpnp.inexact):
-        mask = dpnp.isnan(a)
-        a = dpnp.array(a, copy=True)
-        dpnp.copyto(a, val, where=mask)
-    else:
-        mask = None
-
-    return a, mask

dpnp/dpnp_iface_mathematical.py

@@ -104,10 +104,6 @@
     "mod",
     "modf",
     "multiply",
-    "nancumprod",
-    "nancumsum",
-    "nanprod",
-    "nansum",
     "negative",
     "positive",
     "power",
@@ -1660,174 +1656,6 @@ def multiply(
     )
 
 
-def nancumprod(x1, **kwargs):
-    """
-    Return the cumulative product of array elements over a given axis treating Not a Numbers (NaNs) as one.
-
-    For full documentation refer to :obj:`numpy.nancumprod`.
-
-    Limitations
-    -----------
-    Parameter `x` is supported as :class:`dpnp.ndarray`.
-    Keyword argument `kwargs` is currently unsupported.
-    Otherwise the function will be executed sequentially on CPU.
-    Input array data types are limited by supported DPNP :ref:`Data types`.
-
-    .. seealso:: :obj:`dpnp.cumprod` : Return the cumulative product of elements along a given axis.
-
-    Examples
-    --------
-    >>> import dpnp as np
-    >>> a = np.array([1., np.nan])
-    >>> result = np.nancumprod(a)
-    >>> [x for x in result]
-    [1.0, 1.0]
-    >>> b = np.array([[1., 2., np.nan], [4., np.nan, 6.]])
-    >>> result = np.nancumprod(b)
-    >>> [x for x in result]
-    [1.0, 2.0, 2.0, 8.0, 8.0, 48.0]
-
-
-    """
-
-    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
-    if x1_desc and not kwargs:
-        return dpnp_nancumprod(x1_desc).get_pyobj()
-
-    return call_origin(numpy.nancumprod, x1, **kwargs)
-
-
-def nancumsum(x1, **kwargs):
-    """
-    Return the cumulative sum of the elements along a given axis.
-
-    For full documentation refer to :obj:`numpy.nancumsum`.
-
-    Limitations
-    -----------
-    Parameter `x` is supported as :class:`dpnp.ndarray`.
-    Keyword argument `kwargs` is currently unsupported.
-    Otherwise the function will be executed sequentially on CPU.
-    Input array data types are limited by supported DPNP :ref:`Data types`.
-
-    See Also
-    --------
-    :obj:`dpnp.cumsum` : Return the cumulative sum of the elements along a given axis.
-
-    Examples
-    --------
-    >>> import dpnp as np
-    >>> a = np.array([1., np.nan])
-    >>> result = np.nancumsum(a)
-    >>> [x for x in result]
-    [1.0, 1.0]
-    >>> b = np.array([[1., 2., np.nan], [4., np.nan, 6.]])
-    >>> result = np.nancumprod(b)
-    >>> [x for x in result]
-    [1.0, 3.0, 3.0, 7.0, 7.0, 13.0]
-
-    """
-
-    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
-    if x1_desc and not kwargs:
-        return dpnp_nancumsum(x1_desc).get_pyobj()
-
-    return call_origin(numpy.nancumsum, x1, **kwargs)
-
-
-def nanprod(
-    a,
-    axis=None,
-    dtype=None,
-    out=None,
-    keepdims=False,
-    initial=None,
-    where=True,
-):
-    """
-    Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.
-
-    For full documentation refer to :obj:`numpy.nanprod`.
-
-    Returns
-    -------
-    out : dpnp.ndarray
-        A new array holding the result is returned unless `out` is specified, in which case it is returned.
-
-    See Also
-    --------
-    :obj:`dpnp.prod` : Returns product across array propagating NaNs.
-    :obj:`dpnp.isnan` : Test element-wise for NaN and return result as a boolean array.
-
-    Limitations
-    -----------
-    Input array is only supported as either :class:`dpnp.ndarray` or :class:`dpctl.tensor.usm_ndarray`.
-    Parameters `initial`, and `where` are only supported with their default values.
-    Otherwise the function will be executed sequentially on CPU.
-    Input array data types are limited by supported DPNP :ref:`Data types`.
-
-    Examples
-    --------
-    >>> import dpnp as np
-    >>> np.nanprod(np.array(1))
-    array(1)
-    >>> np.nanprod(np.array([1]))
-    array(1)
-    >>> np.nanprod(np.array([1, np.nan]))
-    array(1.0)
-    >>> a = np.array([[1, 2], [3, np.nan]])
-    >>> np.nanprod(a)
-    array(6.0)
-    >>> np.nanprod(a, axis=0)
-    array([3., 2.])
-
-    """
-
-    a, mask = dpnp._replace_nan(a, 1)
-
-    return dpnp.prod(
-        a,
-        axis=axis,
-        dtype=dtype,
-        out=out,
-        keepdims=keepdims,
-        initial=initial,
-        where=where,
-    )
-
-
-def nansum(x1, **kwargs):
-    """
-    Calculate sum() function treating 'Not a Numbers' (NaN) as zero.
-
-    For full documentation refer to :obj:`numpy.nansum`.
-
-    Limitations
-    -----------
-    Parameter `x1` is supported as :class:`dpnp.ndarray`.
-    Keyword argument `kwargs` is currently unsupported.
-    Otherwise the function will be executed sequentially on CPU.
-    Input array data types are limited by supported DPNP :ref:`Data types`.
-
-    Examples
-    --------
-    >>> import dpnp as np
-    >>> np.nansum(np.array([1, 2]))
-    3
-    >>> np.nansum(np.array([[1, 2], [3, 4]]))
-    10
-
-    """
-
-    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
-    if x1_desc and not kwargs:
-        result_obj = dpnp_nansum(x1_desc).get_pyobj()
-        result = dpnp.convert_single_elem_array_to_scalar(result_obj)
-        return result
-
-    return call_origin(numpy.nansum, x1, **kwargs)
-
-
 def negative(
     x,
     /,