Applied review comments

Author: npolina4

doc/reference/logic.rst

@@ -68,6 +68,7 @@ Comparison
    dpnp.allclose
    dpnp.isclose
    dpnp.array_equal
+   dpnp.array_equiv
    dpnp.greater
    dpnp.greater_equal
    dpnp.less

dpnp/dpnp_iface_logic.py

@@ -50,9 +50,10 @@
 import numpy
 
 import dpnp
-import dpnp.dpnp_utils as utils
 from dpnp.dpnp_algo.dpnp_elementwise_common import DPNPBinaryFunc, DPNPUnaryFunc
 
+from .dpnp_utils import get_usm_allocations
+
 __all__ = [
     "all",
     "allclose",
@@ -115,7 +116,7 @@ def all(a, /, axis=None, out=None, keepdims=False, *, where=True):
     Returns
     -------
     out : dpnp.ndarray
-        An array with a data type of `bool`
+        An array with a data type of `bool`.
         containing the results of the logical AND reduction is returned
         unless `out` is specified. Otherwise, a reference to `out` is returned.
         The result has the same shape as `a` if `axis` is not ``None``
@@ -279,7 +280,7 @@ def any(a, /, axis=None, out=None, keepdims=False, *, where=True):
     Returns
     -------
     out : dpnp.ndarray
-        An array with a data type of `bool`
+        An array with a data type of `bool`.
         containing the results of the logical OR reduction is returned
         unless `out` is specified. Otherwise, a reference to `out` is returned.
         The result has the same shape as `a` if `axis` is not ``None``
@@ -345,23 +346,26 @@ def array_equal(a1, a2, equal_nan=False):
     ``True`` if two arrays have the same shape and elements, ``False``
     otherwise.
 
+    For full documentation refer to :obj:`numpy.array_equal`.
+
     Parameters
     ----------
     a1 : {dpnp.ndarray, usm_ndarray, scalar}
-        First input array, expected to have numeric data type.
+        First input array.
         Both inputs `x1` and `x2` can not be scalars at the same time.
     a2 : {dpnp.ndarray, usm_ndarray, scalar}
-        Second input array, also expected to have numeric data type.
+        Second input array.
         Both inputs `x1` and `x2` can not be scalars at the same time.
-    equal_nan : bool
+    equal_nan : bool, optional
         Whether to compare ``NaNs`` as equal. If the dtype of `a1` and `a2` is
         complex, values will be considered equal if either the real or the
-        imaginary component of a given value is ``NaNs``.
+        imaginary component of a given value is ``NaN``.
+        Default: ``False``.
 
     Returns
     -------
     b : dpnp.ndarray
-        An array with a data type of `bool`
+        An array with a data type of `bool`.
         Returns ``True`` if the arrays are equal.
 
     See Also
@@ -379,12 +383,10 @@ def array_equal(a1, a2, equal_nan=False):
     >>> np.array_equal(a, b)
     array(True)
 
-    >>> a = np.array([1, 2])
     >>> b = np.array([1, 2, 3])
     >>> np.array_equal(a, b)
     array(False)
 
-    >>> a = np.array([1, 2])
     >>> b = np.array([1, 4])
     >>> np.array_equal(a, b)
     array(False)
@@ -397,7 +399,8 @@ def array_equal(a1, a2, equal_nan=False):
     array(True)
 
     When ``equal_nan`` is ``True``, complex values with nan components are
-    considered equal if either the real *or* the imaginary components are nan.
+    considered equal if either the real *or* the imaginary components are
+    ``NaNs``.
 
     >>> a = np.array([1 + 1j])
     >>> b = a.copy()
@@ -407,6 +410,7 @@ def array_equal(a1, a2, equal_nan=False):
     array(True)
 
     """
+
     dpnp.check_supported_arrays_type(a1, a2, scalar_type=True)
     if dpnp.isscalar(a1):
         usm_type_alloc = a2.usm_type
@@ -427,7 +431,7 @@ def array_equal(a1, a2, equal_nan=False):
             sycl_queue=sycl_queue_alloc,
         )
     else:
-        usm_type_alloc, sycl_queue_alloc = utils.get_usm_allocations([a1, a2])
+        usm_type_alloc, sycl_queue_alloc = get_usm_allocations([a1, a2])
 
     if a1.shape != a2.shape:
         return dpnp.array(
@@ -438,15 +442,14 @@ def array_equal(a1, a2, equal_nan=False):
         return (a1 == a2).all()
 
     if a1 is a2:
+        # NaN will compare equal so an array will compare equal to itself
         return dpnp.array(
             True, usm_type=usm_type_alloc, sycl_queue=sycl_queue_alloc
         )
 
-    cannot_have_nan = (
-        dpnp.issubdtype(a1, dpnp.bool) or dpnp.issubdtype(a1, dpnp.integer)
-    ) and (dpnp.issubdtype(a2, dpnp.bool) or dpnp.issubdtype(a2, dpnp.integer))
-
-    if cannot_have_nan:
+    if not (
+        dpnp.issubdtype(a1, dpnp.inexact) or dpnp.issubdtype(a2, dpnp.inexact)
+    ):
         return (a1 == a2).all()
 
     # Handling NaN values if equal_nan is True
@@ -468,19 +471,21 @@ def array_equiv(a1, a2):
     Shape consistent means they are either the same shape, or one input array
     can be broadcasted to create the same shape as the other one.
 
+    For full documentation refer to :obj:`numpy.array_equiv`.
+
     Parameters
     ----------
     a1 : {dpnp.ndarray, usm_ndarray, scalar}
-        First input array, expected to have numeric data type.
+        First input array.
         Both inputs `x1` and `x2` can not be scalars at the same time.
     a2 : {dpnp.ndarray, usm_ndarray, scalar}
-        Second input array, also expected to have numeric data type.
+        Second input array.
         Both inputs `x1` and `x2` can not be scalars at the same time.
 
     Returns
     -------
     out : dpnp.ndarray
-        An array with a data type of `bool`
+        An array with a data type of `bool`.
         ``True`` if equivalent, ``False`` otherwise.
 
     Examples
@@ -496,48 +501,28 @@ def array_equiv(a1, a2):
 
     Showing the shape equivalence:
 
-    >>> a = np.array([1, 2])
     >>> b = np.array([[1, 2], [1, 2]])
     >>> c = np.array([[1, 2, 1, 2], [1, 2, 1, 2]])
     >>> np.array_equiv(a, b)
     array(True)
     >>> np.array_equiv(a, c)
     array(False)
 
-    >>> a = np.array([1, 2])
     >>> b = np.array([[1, 2], [1, 3]])
     >>> np.array_equiv(a, b)
     array(False)
 
     """
-    dpnp.check_supported_arrays_type(a1, a2, scalar_type=True)
-    if dpnp.isscalar(a1):
-        usm_type_alloc = a2.usm_type
-        sycl_queue_alloc = a2.sycl_queue
-        a1 = dpnp.array(
-            a1,
-            dtype=dpnp.result_type(a1, a2),
-            usm_type=usm_type_alloc,
-            sycl_queue=sycl_queue_alloc,
-        )
-    elif dpnp.isscalar(a2):
-        usm_type_alloc = a1.usm_type
-        sycl_queue_alloc = a1.sycl_queue
-        a2 = dpnp.array(
-            a2,
-            dtype=dpnp.result_type(a1, a2),
-            usm_type=usm_type_alloc,
-            sycl_queue=sycl_queue_alloc,
-        )
-    else:
-        usm_type_alloc, sycl_queue_alloc = utils.get_usm_allocations([a1, a2])
 
-    try:
-        dpnp.broadcast_arrays(a1, a2)
-    except ValueError:
-        return dpnp.array(
-            False, usm_type=usm_type_alloc, sycl_queue=sycl_queue_alloc
-        )
+    dpnp.check_supported_arrays_type(a1, a2, scalar_type=True)
+    if not dpnp.isscalar(a1) and not dpnp.isscalar(a2):
+        usm_type_alloc, sycl_queue_alloc = get_usm_allocations([a1, a2])
+        try:
+            dpnp.broadcast_arrays(a1, a2)
+        except ValueError:
+            return dpnp.array(
+                False, usm_type=usm_type_alloc, sycl_queue=sycl_queue_alloc
+            )
     return (a1 == a2).all()
 
 

tests/test_logic.py

@@ -496,141 +496,47 @@ def test_isclose(dtype, rtol, atol):
     assert_allclose(dpnp_res, np_res)
 
 
-def _test_array_equal_parametrizations():
-    """
-    we pre-create arrays as we sometime want to pass the same instance
-    and sometime not. Passing the same instances may not mean the array are
-    equal, especially when containing None
-    """
-    # those are 0-d arrays, it used to be a special case
-    # where (e0 == e0).all() would raise
-    e0 = dpnp.array(0, dtype="i4")
-    e1 = dpnp.array(1, dtype="f4")
-    # x,y, nan_equal, expected_result
-    yield (e0, e0.copy(), None, True)
-    yield (e0, e0.copy(), False, True)
-    yield (e0, e0.copy(), True, True)
-
-    #
-    yield (e1, e1.copy(), None, True)
-    yield (e1, e1.copy(), False, True)
-    yield (e1, e1.copy(), True, True)
-
-    # Non-nanable – those cannot hold nans
-    a12 = dpnp.array([1, 2])
-    a12b = a12.copy()
-    a123 = dpnp.array([1, 2, 3])
-    a13 = dpnp.array([1, 3])
-    a34 = dpnp.array([3, 4])
-
-    yield (a12, a12b, None, True)
-    yield (a12, a12, None, True)
-    yield (a12, a123, None, False)
-    yield (a12, a34, None, False)
-    yield (a12, a13, None, False)
-
-    # Non-float dtype - equal_nan should have no effect,
-    yield (a123, a123, None, True)
-    yield (a123, a123, False, True)
-    yield (a123, a123, True, True)
-    yield (a123, a123.copy(), None, True)
-    yield (a123, a123.copy(), False, True)
-    yield (a123, a123.copy(), True, True)
-    yield (a123.astype("f4"), a123.astype("f4"), None, True)
-    yield (a123.astype("f4"), a123.astype("f4"), False, True)
-    yield (a123.astype("f4"), a123.astype("f4"), True, True)
-
-    # these can hold None
-    b1 = dpnp.array([1, 2, dpnp.nan])
-    b2 = dpnp.array([1, dpnp.nan, 2])
-    b3 = dpnp.array([1, 2, dpnp.inf])
-    b4 = dpnp.array(dpnp.nan)
-
-    # instances are the same
-    yield (b1, b1, None, False)
-    yield (b1, b1, False, False)
-    yield (b1, b1, True, True)
-
-    # equal but not same instance
-    yield (b1, b1.copy(), None, False)
-    yield (b1, b1.copy(), False, False)
-    yield (b1, b1.copy(), True, True)
-
-    # same once stripped of Nan
-    yield (b1, b2, None, False)
-    yield (b1, b2, False, False)
-    yield (b1, b2, True, False)
-
-    # nan's not conflated with inf's
-    yield (b1, b3, None, False)
-    yield (b1, b3, False, False)
-    yield (b1, b3, True, False)
-
-    # all Nan
-    yield (b4, b4, None, False)
-    yield (b4, b4, False, False)
-    yield (b4, b4, True, True)
-    yield (b4, b4.copy(), None, False)
-    yield (b4, b4.copy(), False, False)
-    yield (b4, b4.copy(), True, True)
-
-    # Multi-dimensional array
-    md1 = dpnp.array([[0, 1], [dpnp.nan, 1]])
-
-    yield (md1, md1, None, False)
-    yield (md1, md1, False, False)
-    yield (md1, md1, True, True)
-    yield (md1, md1.copy(), None, False)
-    yield (md1, md1.copy(), False, False)
-    yield (md1, md1.copy(), True, True)
-    # both complexes are nan+nan.j but the same instance
-    cplx1, cplx2 = [dpnp.array([dpnp.nan + dpnp.nan * 1j])] * 2
-
-    # only real or img are nan.
-    cplx3 = dpnp.array(1 + dpnp.nan * 1j)
-    cplx4 = dpnp.array(dpnp.nan + 1j)
-
-    # Complex values
-    yield (cplx1, cplx2, None, False)
-    yield (cplx1, cplx2, False, False)
-    yield (cplx1, cplx2, True, True)
-
-    # Complex values, 1+nan, nan+1j
-    yield (cplx3, cplx4, None, False)
-    yield (cplx3, cplx4, False, False)
-    yield (cplx3, cplx4, True, True)
-
-
-class TestArrayComparisons:
-    @pytest.mark.parametrize(
-        "bx,by,equal_nan,expected", _test_array_equal_parametrizations()
-    )
-    def test_array_equal_equal_nan(self, bx, by, equal_nan, expected):
-        if equal_nan is None:
-            res = dpnp.array_equal(bx, by)
-        else:
-            res = dpnp.array_equal(bx, by, equal_nan=equal_nan)
-        assert_equal(res, dpnp.array(expected))
-
-    def test_array_equiv(self):
-        res = dpnp.array_equiv(dpnp.array([1, 2]), dpnp.array([1, 2]))
-        assert res
-        res = dpnp.array_equiv(dpnp.array([1, 2]), dpnp.array([1, 2, 3]))
-        assert not res
-        res = dpnp.array_equiv(dpnp.array([1, 2]), dpnp.array([3, 4]))
-        assert not res
-        res = dpnp.array_equiv(dpnp.array([1, 2]), dpnp.array([1, 3]))
-        assert not res
-
-        res = dpnp.array_equiv(dpnp.array([1, 1]), dpnp.array([1]))
-        assert res
-        res = dpnp.array_equiv(dpnp.array([1, 1]), dpnp.array([[1], [1]]))
-        assert res
-        res = dpnp.array_equiv(dpnp.array([1, 2]), dpnp.array([2]))
-        assert not res
-        res = dpnp.array_equiv(dpnp.array([1, 2]), dpnp.array([[1], [2]]))
-        assert not res
-        res = dpnp.array_equiv(
-            dpnp.array([1, 2]), dpnp.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-        )
-        assert not res
+@pytest.mark.parametrize("a", [numpy.array([1, 2]), numpy.array([1, 1])])
+@pytest.mark.parametrize(
+    "b",
+    [
+        numpy.array([1, 2]),
+        numpy.array([1, 2, 3]),
+        numpy.array([3, 4]),
+        numpy.array([1, 3]),
+        numpy.array([1]),
+        numpy.array([[1], [1]]),
+        numpy.array([2]),
+        numpy.array([[1], [2]]),
+        numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
+    ],
+)
+def test_array_equiv(a, b):
+    result = dpnp.array_equiv(dpnp.array(a), dpnp.array(b))
+    expected = numpy.array_equiv(a, b)
+
+    assert_equal(expected, result)
+
+
+@pytest.mark.parametrize("a", [numpy.array([1, 2]), numpy.array([1, 1])])
+def test_array_equiv_scalar(a):
+    b = 1
+    result = dpnp.array_equiv(dpnp.array(a), b)
+    expected = numpy.array_equiv(a, b)
+
+    assert_equal(expected, result)
+
+
+@pytest.mark.parametrize(
+    "a",
+    [
+        numpy.array([1, 2]),
+        numpy.array([1.0, numpy.nan]),
+        numpy.array([1.0, numpy.inf]),
+    ],
+)
+def test_array_equal_same_arr(a):
+    expected = numpy.array_equal(a, a.copy())
+    b = dpnp.array(a)
+    result = dpnp.array_equal(b, b.copy())
+    assert_equal(expected, result)