Remove allclose

Author: crusaderky

docs/api-reference.md

@@ -6,7 +6,6 @@
     :nosignatures:
     :toctree: generated
 
-    allclose
     at
     atleast_nd
     cov

src/array_api_extra/__init__.py

@@ -1,6 +1,6 @@
 """Extra array functions built on top of the array API standard."""
 
-from ._delegation import allclose, isclose, pad
+from ._delegation import isclose, pad
 from ._lib._at import at
 from ._lib._funcs import (
     atleast_nd,
@@ -18,7 +18,6 @@
 # pylint: disable=duplicate-code
 __all__ = [
     "__version__",
-    "allclose",
     "at",
     "atleast_nd",
     "cov",

src/array_api_extra/_delegation.py

@@ -8,7 +8,7 @@
 from ._lib._utils._compat import array_namespace
 from ._lib._utils._typing import Array
 
-__all__ = ["allclose", "isclose", "pad"]
+__all__ = ["isclose", "pad"]
 
 
 def _delegate(xp: ModuleType, *backends: Backend) -> bool:
@@ -30,54 +30,6 @@ def _delegate(xp: ModuleType, *backends: Backend) -> bool:
     return any(backend.is_namespace(xp) for backend in backends)
 
 
-def allclose(
-    a: Array,
-    b: Array,
-    *,
-    rtol: float = 1e-05,
-    atol: float = 1e-08,
-    equal_nan: bool = False,
-    xp: ModuleType | None = None,
-) -> Array:
-    """
-    Return True if two arrays are element-wise equal within a tolerance.
-
-    This is a simple convenience reduction around `isclose`.
-
-    Parameters
-    ----------
-    a, b : Array
-        Input arrays to compare.
-    rtol : array_like, optional
-        The relative tolerance parameter.
-    atol : array_like, optional
-        The absolute tolerance parameter.
-    equal_nan : bool, optional
-        Whether to compare NaN's as equal. If True, NaN's in `a` will be considered
-        equal to NaN's in `b` in the output array.
-    xp : array_namespace, optional
-        The standard-compatible namespace for `a` and `b`. Default: infer.
-
-    Returns
-    -------
-    Array
-        A 0-dimensional boolean array, containing `True` if all `a` is elementwise close
-        to `b` and `False` otherwise.
-
-    See Also
-    --------
-    isclose
-    math.isclose
-
-    Notes
-    -----
-    If `xp` is a lazy backend (e.g. Dask, JAX), you may not be able to test the result
-    contents with ``bool(allclose(a, b))`` or ``if allclose(a, b): ...``.
-    """
-    xp = array_namespace(a, b) if xp is None else xp
-    return xp.all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan, xp=xp))
-
-
 def isclose(
     a: Array,
     b: Array,
@@ -125,7 +77,6 @@ def isclose(
 
     See Also
     --------
-    allclose
     math.isclose
 
     Notes

src/array_api_extra/_lib/_testing.py

@@ -121,12 +121,12 @@ def xp_assert_close(
     See Also
     --------
     xp_assert_equal
-    allclose
+    isclose
     numpy.testing.assert_allclose
 
     Notes
     -----
-    The default `atol` and `rtol` differ from `xpx.allclose`.
+    The default `atol` and `rtol` differ from `xp.all(xpx.allclose(a, b))`.
     """
     xp = _check_ns_shape_dtype(actual, desired)
 

tests/test_funcs.py

@@ -6,7 +6,6 @@
 import pytest
 
 from array_api_extra import (
-    allclose,
     at,
     atleast_nd,
     cov,
@@ -291,7 +290,6 @@ def test_basic(self, a: float, b: float, xp: ModuleType):
         b_xp = xp.asarray(b)
 
         xp_assert_equal(isclose(a_xp, b_xp), xp.asarray(np.isclose(a, b)))
-        xp_assert_equal(allclose(a_xp, b_xp), xp.asarray(np.allclose(a, b)))
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -328,8 +326,6 @@ def test_equal_nan(self, xp: ModuleType):
         b = xp.asarray([float("nan"), 1.0, float("nan")])
         xp_assert_equal(isclose(a, b), xp.asarray([False, False, False]))
         xp_assert_equal(isclose(a, b, equal_nan=True), xp.asarray([True, False, False]))
-        xp_assert_equal(allclose(a[:1], b[:1]), xp.asarray(False))
-        xp_assert_equal(allclose(a[:1], b[:1], equal_nan=True), xp.asarray(True))
 
     @pytest.mark.parametrize("dtype", ["float32", "complex64", "int32"])
     def test_tolerance(self, dtype: str, xp: ModuleType):
@@ -339,15 +335,10 @@ def test_tolerance(self, dtype: str, xp: ModuleType):
         xp_assert_equal(isclose(a, b), xp.asarray([False, False]))
         xp_assert_equal(isclose(a, b, atol=1), xp.asarray([True, False]))
         xp_assert_equal(isclose(a, b, rtol=0.01), xp.asarray([True, False]))
-        xp_assert_equal(allclose(a[:1], b[:1]), xp.asarray(False))
-        xp_assert_equal(allclose(a[:1], b[:1], atol=1), xp.asarray(True))
-        xp_assert_equal(allclose(a[:1], b[:1], rtol=0.01), xp.asarray(True))
 
         # Attempt to trigger division by 0 in rtol on int dtype
         xp_assert_equal(isclose(a, b, rtol=0), xp.asarray([False, False]))
         xp_assert_equal(isclose(a, b, atol=1, rtol=0), xp.asarray([True, False]))
-        xp_assert_equal(allclose(a[:1], b[:1], rtol=0), xp.asarray(False))
-        xp_assert_equal(allclose(a[:1], b[:1], atol=1, rtol=0), xp.asarray(True))
 
     def test_very_small_numbers(self, xp: ModuleType):
         a = xp.asarray([1e-9, 1e-9])
@@ -367,12 +358,6 @@ def test_bool_dtype(self, xp: ModuleType):
         xp_assert_equal(isclose(a, b, rtol=1), xp.asarray([True, True, True]))
         xp_assert_equal(isclose(a, b, rtol=2), xp.asarray([True, True, True]))
 
-        xp_assert_equal(allclose(a, b), xp.asarray(False))
-        xp_assert_equal(allclose(a, b, atol=1), xp.asarray(True))
-        xp_assert_equal(allclose(a, b, atol=2), xp.asarray(True))
-        xp_assert_equal(allclose(a, b, rtol=1), xp.asarray(True))
-        xp_assert_equal(allclose(a, b, rtol=2), xp.asarray(True))
-
         # Test broadcasting
         xp_assert_equal(
             isclose(a, xp.asarray(True), atol=1), xp.asarray([True, True, True])