Merge master into update_svd_cuda

Author: vlad-perevezentsev

doc/conf.py

@@ -220,6 +220,7 @@ def _can_document_member(member, *args, **kwargs):
     "python": ("https://docs.python.org/3/", None),
     "numpy": ("https://docs.scipy.org/doc/numpy/", None),
     "scipy": ("https://docs.scipy.org/doc/scipy/reference/", None),
+    "dpctl": ("https://intelpython.github.io/dpctl/latest/", None),
 }
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.

dpnp/__init__.py

@@ -49,6 +49,9 @@
         [os.getenv("PATH", ""), mypath, dpctlpath]
     )
 
+# Borrowed from DPCTL
+from dpctl.tensor import DLDeviceType
+
 from dpnp.dpnp_array import dpnp_array as ndarray
 from dpnp.dpnp_flatiter import flatiter as flatiter
 from dpnp.dpnp_iface_types import *

dpnp/dpnp_iface.py

@@ -62,7 +62,6 @@
     "check_limitations",
     "check_supported_arrays_type",
     "default_float_type",
-    "from_dlpack",
     "get_dpnp_descriptor",
     "get_include",
     "get_normalized_queue_device",
@@ -443,60 +442,6 @@ def default_float_type(device=None, sycl_queue=None):
     return map_dtype_to_device(float64, _sycl_queue.sycl_device)
 
 
-def from_dlpack(obj, /, *, device=None, copy=None):
-    """
-    Create a dpnp array from a Python object implementing the ``__dlpack__``
-    protocol.
-
-    See https://dmlc.github.io/dlpack/latest/ for more details.
-
-    Parameters
-    ----------
-    obj : object
-        A Python object representing an array that implements the ``__dlpack__``
-        and ``__dlpack_device__`` methods.
-    device : {:class:`dpctl.SyclDevice`, :class:`dpctl.SyclQueue`,
-              :class:`dpctl.tensor.Device`, tuple, None}, optional
-        Array API concept of a device where the output array is to be placed.
-        ``device`` can be ``None``, an oneAPI filter selector string,
-        an instance of :class:`dpctl.SyclDevice` corresponding to
-        a non-partitioned SYCL device, an instance of :class:`dpctl.SyclQueue`,
-        a :class:`dpctl.tensor.Device` object returned by
-        :attr:`dpctl.tensor.usm_ndarray.device`, or a 2-tuple matching
-        the format of the output of the ``__dlpack_device__`` method,
-        an integer enumerator representing the device type followed by
-        an integer representing the index of the device.
-        Default: ``None``.
-    copy {bool, None}, optional
-        Boolean indicating whether or not to copy the input.
-
-        * If `copy``is ``True``, the input will always be copied.
-        * If ``False``, a ``BufferError`` will be raised if a copy is deemed
-          necessary.
-        * If ``None``, a copy will be made only if deemed necessary, otherwise,
-          the existing memory buffer will be reused.
-
-        Default: ``None``.
-
-    Returns
-    -------
-    out : dpnp_array
-        Returns a new dpnp array containing the data from another array
-        (obj) with the ``__dlpack__`` method on the same device as object.
-
-    Raises
-    ------
-    TypeError:
-        if `obj` does not implement ``__dlpack__`` method
-    ValueError:
-        if the input array resides on an unsupported device
-
-    """
-
-    usm_res = dpt.from_dlpack(obj, device=device, copy=copy)
-    return dpnp_array._create_from_usm_ndarray(usm_res)
-
-
 def get_dpnp_descriptor(
     ext_obj,
     copy_when_strides=True,

dpnp/dpnp_iface_arraycreation.py

@@ -75,6 +75,7 @@
     "fromfunction",
     "fromiter",
     "fromstring",
+    "from_dlpack",
     "full",
     "full_like",
     "geomspace",
@@ -2047,6 +2048,93 @@ def fromstring(
     )
 
 
+def from_dlpack(x, /, *, device=None, copy=None):
+    """
+    Constructs :class:`dpnp.ndarray` or :class:`numpy.ndarray` instance from
+    a Python object `x` that implements ``__dlpack__`` protocol.
+
+    For full documentation refer to :obj:`numpy.from_dlpack`.
+
+    Parameters
+    ----------
+    x : object
+        A Python object representing an array that implements the ``__dlpack__``
+        and ``__dlpack_device__`` methods.
+    device : {None, string, tuple, device}, optional
+        Device where the output array is to be placed. `device` keyword values
+        can be:
+
+        * ``None`` : The data remains on the same device.
+        * oneAPI filter selector string : SYCL device selected by filter
+          selector string.
+        * :class:`dpctl.SyclDevice` : Explicit SYCL device that must correspond
+          to a non-partitioned SYCL device.
+        * :class:`dpctl.SyclQueue` : Implies SYCL device targeted by the SYCL
+          queue.
+        * :class:`dpctl.tensor.Device` : Implies SYCL device
+          ``device.sycl_queue``. The `device` object is obtained via
+          :attr:`dpctl.tensor.usm_ndarray.device`.
+        * ``(device_type, device_id)`` : 2-tuple matching the format of the
+          output of the ``__dlpack_device__`` method: an integer enumerator
+          representing the device type followed by an integer representing
+          the index of the device. The only supported :class:`dpnp.DLDeviceType`
+          device types are ``"kDLCPU"`` and ``"kDLOneAPI"``.
+
+        Default: ``None``.
+    copy : {bool, None}, optional
+        Boolean indicating whether or not to copy the input.
+
+        * If `copy` is ``True``, the input will always be copied.
+        * If ``False``, a ``BufferError`` will be raised if a copy is deemed
+          necessary.
+        * If ``None``, a copy will be made only if deemed necessary, otherwise,
+          the existing memory buffer will be reused.
+
+        Default: ``None``.
+
+    Returns
+    -------
+    out : {dpnp.ndarray, numpy.ndarray}
+        An array containing the data in `x`. When `copy` is ``None`` or
+        ``False``, this may be a view into the original memory.
+        The type of the returned object depends on where the data backing up
+        input object `x` resides. If it resides in a USM allocation on a SYCL
+        device, the type :class:`dpnp.ndarray` is returned, otherwise if it
+        resides on ``"kDLCPU"`` device the type is :class:`numpy.ndarray`, and
+        otherwise an exception is raised.
+
+    Raises
+    ------
+    TypeError
+        if `obj` does not implement ``__dlpack__`` method
+    ValueError
+        if data of the input object resides on an unsupported device
+
+    Notes
+    -----
+    If the return type is :class:`dpnp.ndarray`, the associated SYCL queue is
+    derived from the `device` keyword. When `device` keyword value has type
+    :class:`dpctl.SyclQueue`, the explicit queue instance is used, when `device`
+    keyword value has type :class:`dpctl.tensor.Device`, the
+    ``device.sycl_queue`` is used. In all other cases, the cached SYCL queue
+    corresponding to the implied SYCL device is used.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> import numpy
+    >>> x = numpy.arange(10)
+    >>> # create a view of the numpy array "x" in dpnp:
+    >>> y = np.from_dlpack(x)
+
+    """
+
+    result = dpt.from_dlpack(x, device=device, copy=copy)
+    if isinstance(result, dpt.usm_ndarray):
+        return dpnp_array._create_from_usm_ndarray(result)
+    return result
+
+
 def full(
     shape,
     fill_value,

dpnp/dpnp_iface_nanfunctions.py

@@ -40,6 +40,7 @@
 import warnings
 
 import dpnp
+from dpnp.dpnp_utils.dpnp_utils_statistics import dpnp_median
 
 __all__ = [
     "nanargmax",
@@ -48,6 +49,7 @@
     "nancumsum",
     "nanmax",
     "nanmean",
+    "nanmedian",
     "nanmin",
     "nanprod",
     "nanstd",
@@ -568,6 +570,107 @@ def nanmean(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True):
     return avg
 
 
+def nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=False):
+    """
+    Compute the median along the specified axis, while ignoring NaNs.
+
+    For full documentation refer to :obj:`numpy.nanmedian`.
+
+    Parameters
+    ----------
+    a : {dpnp.ndarray, usm_ndarray}
+        Input array.
+    axis : {None, int, tuple or list of ints}, optional
+        Axis or axes along which the medians are computed. The default,
+        ``axis=None``, will compute the median along a flattened version of
+        the array. If a sequence of axes, the array is first flattened along
+        the given axes, then the median is computed along the resulting
+        flattened axis.
+        Default: ``None``.
+    out : {None, dpnp.ndarray, usm_ndarray}, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type (of the calculated
+        values) will be cast if necessary.
+        Default: ``None``.
+    overwrite_input : bool, optional
+       If ``True``, then allow use of memory of input array `a` for
+       calculations. The input array will be modified by the call to
+       :obj:`dpnp.nanmedian`. This will save memory when you do not need to
+       preserve the contents of the input array. Treat the input as undefined,
+       but it will probably be fully or partially sorted.
+       Default: ``False``.
+    keepdims : bool, optional
+        If ``True``, the reduced axes (dimensions) are included in the result
+        as singleton dimensions, so that the returned array remains
+        compatible with the input array according to Array Broadcasting
+        rules. Otherwise, if ``False``, the reduced axes are not included in
+        the returned array.
+        Default: ``False``.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        A new array holding the result. If `a` has a floating-point data type,
+        the returned array will have the same data type as `a`. If `a` has a
+        boolean or integral data type, the returned array will have the
+        default floating point data type for the device where input array `a`
+        is allocated.
+
+    See Also
+    --------
+    :obj:`dpnp.mean` : Compute the arithmetic mean along the specified axis.
+    :obj:`dpnp.median` : Compute the median along the specified axis.
+    :obj:`dpnp.percentile` : Compute the q-th percentile of the data
+                             along the specified axis.
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the median of ``V`` is the
+    middle value of a sorted copy of ``V``, ``V_sorted`` - i.e.,
+    ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the
+    two middle values of ``V_sorted`` when ``N`` is even.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([[10.0, 7, 4], [3, 2, 1]])
+    >>> a[0, 1] = np.nan
+    >>> a
+    array([[10., nan,  4.],
+           [ 3.,  2.,  1.]])
+    >>> np.median(a)
+    array(nan)
+    >>> np.nanmedian(a)
+    array(3.)
+
+    >>> np.nanmedian(a, axis=0)
+    array([6.5, 2., 2.5])
+    >>> np.nanmedian(a, axis=1)
+    array([7., 2.])
+
+    >>> b = a.copy()
+    >>> np.nanmedian(b, axis=1, overwrite_input=True)
+    array([7., 2.])
+    >>> assert not np.all(a==b)
+    >>> b = a.copy()
+    >>> np.nanmedian(b, axis=None, overwrite_input=True)
+    array(3.)
+    >>> assert not np.all(a==b)
+
+    """
+
+    dpnp.check_supported_arrays_type(a)
+    ignore_nan = False
+    if dpnp.issubdtype(a.dtype, dpnp.inexact):
+        mask = dpnp.isnan(a)
+        if dpnp.any(mask):
+            ignore_nan = True
+
+    return dpnp_median(
+        a, axis, out, overwrite_input, keepdims, ignore_nan=ignore_nan
+    )
+
+
 def nanmin(a, axis=None, out=None, keepdims=False, initial=None, where=True):
     """
     Return the minimum of an array or minimum along an axis, ignoring any NaNs.