dpnp.unique returns reshaped unique_inverse when axis is None

doc/reference/dtype.rst

@@ -40,10 +40,8 @@ Data type testing
    :toctree: generated/
    :nosignatures:
 
-   dpnp.issctype
+   dpnp.isdtype
    dpnp.issubdtype
-   dpnp.issubsctype
-   dpnp.issubclass_
 
 Miscellaneous
 -------------

doc/reference/dtypes_table.rst

@@ -15,35 +15,23 @@ Table below shows a list of all supported data types (dtypes) and constants of t
         - :obj:`bool <numpy.bool_>`
         - :obj:`int32 <numpy.int32>`
         - :obj:`int64 <numpy.int64>`
+        - :obj:`float32 <numpy.float32>`
+        - :obj:`float64 <numpy.float64>`
         - :obj:`complex64 <numpy.complex64>`
         - :obj:`complex128 <numpy.complex128>`
       -
         - :obj:`bool_ <numpy.bool_>`
         - :obj:`cdouble <numpy.cdouble>`
-        - :obj:`complex <numpy.complex_>`
-        - :obj:`cfloat <numpy.cfloat>`
         - :obj:`csingle <numpy.csingle>`
         - :obj:`double <numpy.double>`
-        - :obj:`float <numpy.float>`
-        - :obj:`float_ <numpy.float_>`
         - :obj:`float16 <numpy.float16>`
         - :obj:`int <numpy.int>`
         - :obj:`int_ <numpy.int_>`
         - :obj:`intc <numpy.intc>`
         - :obj:`single <numpy.single>`
-        - :obj:`singlecomplex <numpy.singlecomplex>`
       -
         - :obj:`e <numpy.e>`
         - :obj:`euler_gamma <numpy.euler_gamma>`
-        - :obj:`Inf <numpy.Inf>`
         - :obj:`inf <numpy.inf>`
-        - :obj:`Infinity <numpy.Infinity>`
-        - :obj:`infty <numpy.infty>`
-        - :obj:`NAN <numpy.NAN>`
-        - :obj:`NaN <numpy.NaN>`
         - :obj:`nan <numpy.nan>`
-        - :obj:`NINF <numpy.NINF>`
-        - :obj:`NZERO <numpy.NZERO>`
         - :obj:`pi <numpy.pi>`
-        - :obj:`PINF <numpy.PINF>`
-        - :obj:`PZERO <numpy.PZERO>`

dpnp/dpnp_array.py

@@ -678,7 +678,7 @@ def conj(self):
 
         """
 
-        if not dpnp.issubsctype(self.dtype, dpnp.complexfloating):
+        if not dpnp.issubdtype(self.dtype, dpnp.complexfloating):
             return self
         else:
             return dpnp.conjugate(self)
@@ -691,7 +691,7 @@ def conjugate(self):
 
         """
 
-        if not dpnp.issubsctype(self.dtype, dpnp.complexfloating):
+        if not dpnp.issubdtype(self.dtype, dpnp.complexfloating):
             return self
         else:
             return dpnp.conjugate(self)
@@ -965,7 +965,7 @@ def imag(self, value):
         array([1.+9.j, 3.+9.j, 5.+9.j])
 
         """
-        if dpnp.issubsctype(self.dtype, dpnp.complexfloating):
+        if dpnp.issubdtype(self.dtype, dpnp.complexfloating):
             dpnp.copyto(self._array_obj.imag, value)
         else:
             raise TypeError("array does not have imaginary part to set")
@@ -1191,7 +1191,7 @@ def real(self):
 
         """
 
-        if dpnp.issubsctype(self.dtype, dpnp.complexfloating):
+        if dpnp.issubdtype(self.dtype, dpnp.complexfloating):
             return dpnp_array._create_from_usm_ndarray(
                 dpnp.get_usm_ndarray(self).real
             )

dpnp/dpnp_iface_arraycreation.py

@@ -3266,7 +3266,7 @@ def tri(
     /,
     M=None,
     k=0,
-    dtype=dpnp.float,
+    dtype=float,
     *,
     device=None,
     usm_type="device",
@@ -3376,7 +3376,10 @@ def tri(
     if _k is None:
         raise TypeError(f"`k` must be a integer data type, but got {type(k)}")
 
-    _dtype = dpnp.default_float_type() if dtype in (dpnp.float, None) else dtype
+    sycl_dev = dpnp.get_normalized_queue_device(
+        sycl_queue=sycl_queue, device=device
+    ).sycl_device
+    _dtype = map_dtype_to_device(dtype, sycl_dev)
 
     if usm_type is None:
         usm_type = "device"

dpnp/dpnp_iface_logic.py

@@ -839,7 +839,7 @@ def isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False):
     _b += atol
     result = less_equal(dpnp.abs(a - b), _b)
 
-    # Handle "Inf" values: they are treated as equal if they are in the same
+    # Handle "inf" values: they are treated as equal if they are in the same
     # place and of the same sign in both arrays
     result &= isfinite(b)
     result |= a == b

dpnp/dpnp_iface_manipulation.py

@@ -2229,6 +2229,14 @@ def unique(
     This is done by making the specified axis the first dimension of the array
     (move the axis to the first dimension to keep the order of the other axes)
     and then flattening the subarrays in C order.
+    If NaN values are in the input array, a single NaN is put to the end of the
+    sorted unique values.
+    Also for complex arrays all NaN values are considered equivalent (no matter
+    whether the NaN is in the real or imaginary part). As the representant for
+    the returned array the smallest one in the lexicographical order is chosen.
+    For multi-dimensional inputs, `unique_inverse` is reshaped such that the
+    input can be reconstructed using
+    ``dpnp.take(unique, unique_inverse, axis=axis)``.
 
     Examples
     --------
@@ -2272,7 +2280,6 @@ def unique(
     """
 
     if axis is None:
-        ar = dpnp.ravel(ar)
         return _unique_1d(
             ar, return_index, return_inverse, return_counts, equal_nan
         )

dpnp/dpnp_iface_mathematical.py

@@ -2295,7 +2295,7 @@ def gradient(f, *varargs, axis=None, edge_order=1):
 >>> np.maximum(x1, x2)
 array([nan, nan, nan])
 
->>> np.maximum(np.array(np.Inf), 1)
+>>> np.maximum(np.array(np.inf), 1)
 array(inf)
 """
 
@@ -2375,7 +2375,7 @@ def gradient(f, *varargs, axis=None, edge_order=1):
 >>> np.minimum(x1, x2)
 array([nan, nan, nan])
 
->>> np.minimum(np.array(-np.Inf), 1)
+>>> np.minimum(np.array(-np.inf), 1)
 array(-inf)
 """
 

dpnp/dpnp_iface_nanfunctions.py

@@ -437,7 +437,7 @@ def nanmax(a, axis=None, out=None, keepdims=False, initial=None, where=True):
 
     When positive infinity and negative infinity are present:
 
-    >>> np.nanmax(np.array([1, 2, np.nan, np.NINF]))
+    >>> np.nanmax(np.array([1, 2, np.nan, -np.inf]))
     array(2.)
     >>> np.nanmax(np.array([1, 2, np.nan, np.inf]))
     array(inf)
@@ -639,7 +639,7 @@ def nanmin(a, axis=None, out=None, keepdims=False, initial=None, where=True):
 
     >>> np.nanmin(np.array([1, 2, np.nan, np.inf]))
     array(1.)
-    >>> np.nanmin(np.array([1, 2, np.nan, np.NINF]))
+    >>> np.nanmin(np.array([1, 2, np.nan, -np.inf]))
     array(-inf)
 
     """
@@ -831,7 +831,7 @@ def nansum(
     array([2.,  1.])
     >>> np.nansum(np.array([1, np.nan, np.inf]))
     array(inf)
-    >>> np.nansum(np.array([1, np.nan, np.NINF]))
+    >>> np.nansum(np.array([1, np.nan, -np.inf]))
     array(-inf)
     >>> # both +/- infinity present
     >>> np.nansum(np.array([1, np.nan, np.inf, -np.inf]))

dpnp/dpnp_iface_sorting.py

@@ -284,7 +284,7 @@ def sort_complex(a):
     """
 
     b = dpnp.sort(a)
-    if not dpnp.issubsctype(b.dtype, dpnp.complexfloating):
+    if not dpnp.issubdtype(b.dtype, dpnp.complexfloating):
         if b.dtype.char in "bhBH":
             b_dt = dpnp.complex64
         else:

dpnp/dpnp_iface_statistics.py

@@ -522,7 +522,7 @@ def max(a, axis=None, out=None, keepdims=False, initial=None, where=True):
     array([1, 3])
 
     >>> b = np.arange(5, dtype=float)
-    >>> b[2] = np.NaN
+    >>> b[2] = np.nan
     >>> np.max(b)
     array(nan)
 
@@ -736,7 +736,7 @@ def min(a, axis=None, out=None, keepdims=False, initial=None, where=True):
     array([0, 2])
 
     >>> b = np.arange(5, dtype=float)
-    >>> b[2] = np.NaN
+    >>> b[2] = np.nan
     >>> np.min(b)
     array(nan)
 

dpnp/dpnp_iface_types.py

@@ -41,29 +41,22 @@
     "bool",
     "bool_",
     "cdouble",
-    "complex_",
     "complex128",
     "complex64",
     "complexfloating",
-    "cfloat",
     "csingle",
     "double",
     "dtype",
     "e",
     "euler_gamma",
     "finfo",
-    "float",
-    "float_",
     "float16",
     "float32",
     "float64",
     "floating",
     "iinfo",
     "inexact",
-    "Inf",
     "inf",
-    "Infinity",
-    "infty",
     "int",
     "int_",
     "int32",
@@ -72,21 +65,13 @@
     "intc",
     "intp",
     "issubdtype",
-    "issubsctype",
     "is_type_supported",
-    "NAN",
-    "NaN",
     "nan",
     "newaxis",
-    "NINF",
-    "NZERO",
     "number",
     "pi",
-    "PINF",
-    "PZERO",
     "signedinteger",
     "single",
-    "singlecomplex",
 ]
 
 
@@ -97,16 +82,12 @@
 bool = numpy.bool_
 bool_ = numpy.bool_
 cdouble = numpy.cdouble
-complex_ = numpy.complex_
 complex128 = numpy.complex128
 complex64 = numpy.complex64
 complexfloating = numpy.complexfloating
-cfloat = numpy.cfloat
 csingle = numpy.csingle
 double = numpy.double
 dtype = numpy.dtype
-float = numpy.float_
-float_ = numpy.float_
 float16 = numpy.float16
 float32 = numpy.float32
 float64 = numpy.float64
@@ -122,27 +103,17 @@
 number = numpy.number
 signedinteger = numpy.signedinteger
 single = numpy.single
-singlecomplex = numpy.singlecomplex
 
 
 # =============================================================================
 # Constants (borrowed from NumPy)
 # =============================================================================
 e = numpy.e
 euler_gamma = numpy.euler_gamma
-Inf = numpy.Inf
 inf = numpy.inf
-Infinity = numpy.Infinity
-infty = numpy.infty
-NAN = numpy.NAN
-NaN = numpy.NaN
 nan = numpy.nan
 newaxis = None
-NINF = numpy.NINF
-NZERO = numpy.NZERO
 pi = numpy.pi
-PINF = numpy.PINF
-PZERO = numpy.PZERO
 
 
 # pylint: disable=redefined-outer-name
@@ -240,17 +211,6 @@ def issubdtype(arg1, arg2):
     return numpy.issubdtype(arg1, arg2)
 
 
-def issubsctype(arg1, arg2):
-    """
-    Determine if the first argument is a subclass of the second argument.
-
-    For full documentation refer to :obj:`numpy.issubsctype`.
-
-    """
-
-    return numpy.issubsctype(arg1, arg2)
-
-
 def is_type_supported(obj_type):
     """Return True if type is supported by DPNP python level."""
 

dpnp/linalg/dpnp_utils_linalg.py

@@ -997,7 +997,7 @@ def _multi_dot_matrix_chain_order(n, arrays, return_costs=False):
     for ll in range(1, n):
         for i in range(n - ll):
             j = i + ll
-            m[i, j] = dpnp.Inf
+            m[i, j] = dpnp.inf
             for k in range(i, j):
                 q = m[i, k] + m[k + 1, j] + p[i] * p[k + 1] * p[j + 1]
                 if q < m[i, j]:

tests/conftest.py

@@ -32,6 +32,11 @@
 import numpy
 import pytest
 
+if numpy.lib.NumpyVersion(numpy.__version__) >= "2.0.0b1":
+    from numpy.exceptions import ComplexWarning
+else:
+    from numpy import ComplexWarning
+
 import dpnp
 
 skip_mark = pytest.mark.skip(reason="Skipping test.")
@@ -101,7 +106,7 @@ def allow_fall_back_on_numpy(monkeypatch):
 @pytest.fixture
 def suppress_complex_warning():
     sup = numpy.testing.suppress_warnings("always")
-    sup.filter(numpy.ComplexWarning)
+    sup.filter(ComplexWarning)
     with sup:
         yield
 

tests/test_arraymanipulation.py

@@ -9,6 +9,7 @@
 )
 
 import dpnp
+from tests.third_party.cupy import testing
 
 from .helper import get_all_dtypes, get_float_complex_dtypes
 
@@ -832,6 +833,7 @@ def test_generator(self):
             dpnp.vstack(map(lambda x: x, dpnp.ones((3, 2))))
 
 
+@testing.with_requires("numpy<2.0")
 @pytest.mark.parametrize("dtype", get_all_dtypes())
 @pytest.mark.parametrize(
     "data", [[1, 2, 3], [1.0, 2.0, 3.0]], ids=["[1, 2, 3]", "[1., 2., 3.]"]
@@ -843,6 +845,7 @@ def test_asfarray(dtype, data):
     assert_array_equal(result, expected)
 
 
+@testing.with_requires("numpy<2.0")
 @pytest.mark.usefixtures("suppress_complex_warning")
 @pytest.mark.parametrize("dtype", get_all_dtypes())
 @pytest.mark.parametrize("data", [[1.0, 2.0, 3.0]], ids=["[1., 2., 3.]"])