Implement dpnp.array_equal and dpnp.array_equiv

Author: npolina4

dpnp/dpnp_iface.py

@@ -56,7 +56,6 @@
 
 __all__ = [
     "are_same_logical_tensors",
-    "array_equal",
     "asnumpy",
     "astype",
     "as_usm_ndarray",
@@ -173,24 +172,6 @@ def are_same_logical_tensors(ar1, ar2):
     )
 
 
-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`.
-
-    See Also
-    --------
-    :obj:`dpnp.allclose` : Returns True if two arrays are element-wise equal
-                           within a tolerance.
-    :obj:`dpnp.array_equiv` : Returns True if input arrays are shape consistent
-                              and all elements equal.
-
-    """
-
-    return numpy.array_equal(a1, a2, equal_nan=equal_nan)
-
-
 def asnumpy(a, order="C"):
     """
     Returns the NumPy array with input data.

dpnp/dpnp_iface_logic.py

@@ -57,6 +57,8 @@
     "all",
     "allclose",
     "any",
+    "array_equal",
+    "array_equiv",
     "equal",
     "greater",
     "greater_equal",
@@ -342,6 +344,158 @@ def any(a, /, axis=None, out=None, keepdims=False, *, where=True):
     return result
 
 
+def array_equal(a1, a2, equal_nan=False):
+    """
+    ``True`` if two arrays have the same shape and elements, ``False``
+    otherwise.
+
+    Parameters
+    ----------
+    a1 : {dpnp.ndarray, usm_ndarray, scalar}
+        First input array, expected to have numeric data type.
+        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.
+        Both inputs `x1` and `x2` can not be scalars at the same time.
+    equal_nan : bool
+        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``.
+
+    Returns
+    -------
+    b : dpnp.ndarray
+        An array with a data type of `bool`
+        Returns ``True`` if the arrays are equal.
+
+    See Also
+    --------
+    :obj:`dpnp.allclose`: Returns ``True`` if two arrays are element-wise equal
+                          within a tolerance.
+    :obj:`dpnp.array_equiv`: Returns ``True`` if input arrays are shape
+                             consistent and all elements equal.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([1, 2])
+    >>> b = np.array([1, 2])
+    >>> 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)
+
+    >>> a = np.array([1, np.nan])
+    >>> np.array_equal(a, a)
+    array(False)
+
+    >>> np.array_equal(a, a, equal_nan=True)
+    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.
+
+    >>> a = np.array([1 + 1j])
+    >>> b = a.copy()
+    >>> a.real = np.nan
+    >>> b.imag = np.nan
+    >>> np.array_equal(a, b, equal_nan=True)
+    array(True)
+
+    """
+    dpnp.check_supported_arrays_type(a1, a2, scalar_type=True)
+
+    if a1.shape != a2.shape:
+        return dpnp.array(False)
+
+    if not equal_nan:
+        return (a1 == a2).all()
+
+    if a1 is a2:
+        return dpnp.array(True)
+
+    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:
+        return (a1 == a2).all()
+
+    # Handling NaN values if equal_nan is True
+    a1nan, a2nan = isnan(a1), isnan(a2)
+    # NaNs occur at different locations
+    if not (a1nan == a2nan).all():
+        return dpnp.array(False)
+    # Shapes of a1, a2 and masks are guaranteed to be consistent by this point
+    return (a1[~a1nan] == a2[~a1nan]).all()
+
+
+def array_equiv(a1, a2):
+    """
+    Returns ``True`` if input arrays are shape consistent and all elements
+    equal.
+
+    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.
+
+    Parameters
+    ----------
+    a1 : {dpnp.ndarray, usm_ndarray, scalar}
+        First input array, expected to have numeric data type.
+        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.
+        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`
+        ``True`` if equivalent, ``False`` otherwise.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([1, 2])
+    >>> b = np.array([1, 2])
+    >>> c = np.array([1, 3])
+    >>> np.array_equiv(a, b)
+    array(True)
+    >>> np.array_equiv(a, c)
+    array(False)
+
+    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)
+    try:
+        dpnp.broadcast_arrays(a1, a2)
+    except ValueError:
+        return dpnp.array(False)
+    return (a1 == a2).all()
+
+
 _EQUAL_DOCSTRING = """
 Calculates equality test results for each element `x1_i` of the input array `x1`
 with the respective element `x2_i` of the input array `x2`.

tests/test_logic.py

@@ -494,3 +494,143 @@ def test_isclose(dtype, rtol, atol):
     np_res = numpy.isclose(a, b, 1e-05, 1e-08)
     dpnp_res = dpnp.isclose(dpnp_a, dpnp_b, 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

tests/third_party/cupy/logic_tests/test_comparison.py

@@ -102,7 +102,6 @@ def test_array_equal_diff_length(self, xp, dtype):
     @testing.with_requires("numpy>=1.19")
     @testing.for_float_dtypes()
     @testing.numpy_cupy_equal()
-    @pytest.mark.skip("Not supported yet")
     def test_array_equal_infinite_equal_nan(self, xp, dtype):
         nan = float("nan")
         inf = float("inf")
@@ -114,7 +113,6 @@ def test_array_equal_infinite_equal_nan(self, xp, dtype):
     @testing.with_requires("numpy>=1.19")
     @testing.for_complex_dtypes()
     @testing.numpy_cupy_equal()
-    @pytest.mark.skip("Not supported yet")
     def test_array_equal_complex_equal_nan(self, xp, dtype):
         a = xp.array([1 + 2j], dtype=dtype)
         b = a.copy()
@@ -141,7 +139,6 @@ def test_array_equal_broadcast_not_allowed(self, xp):
         return xp.array_equal(a, b)
 
 
-@pytest.mark.skip("dpnp.array_equiv() is not implemented yet")
 class TestArrayEquiv(unittest.TestCase):
 
     @testing.for_all_dtypes()