Run generate_stubs on the latest spec

Author: asmeurer

array_api_tests/function_stubs/__init__.py

@@ -41,9 +41,9 @@
 
 __all__ += ['argmax', 'argmin', 'nonzero', 'where']
 
-from .set_functions import unique_all, unique_inverse, unique_values
+from .set_functions import unique_all, unique_counts, unique_inverse, unique_values
 
-__all__ += ['unique_all', 'unique_inverse', 'unique_values']
+__all__ += ['unique_all', 'unique_counts', 'unique_inverse', 'unique_values']
 
 from .sorting_functions import argsort, sort
 

array_api_tests/function_stubs/set_functions.py

@@ -15,10 +15,13 @@
 def unique_all(x: array, /) -> Tuple[array, array, array, array]:
     pass
 
+def unique_counts(x: array, /) -> Tuple[array, array]:
+    pass
+
 def unique_inverse(x: array, /) -> Tuple[array, array]:
     pass
 
 def unique_values(x: array, /) -> array:
     pass
 
-__all__ = ['unique_all', 'unique_inverse', 'unique_values']
+__all__ = ['unique_all', 'unique_counts', 'unique_inverse', 'unique_values']

array_api_tests/special_cases/test_ceil.py

@@ -7,15 +7,15 @@
 not modify it directly.
 """
 
-from ..array_helpers import assert_exactly_equal, isintegral
+from ..array_helpers import NaN, assert_exactly_equal, exactly_equal, infinity, isintegral, zero
 from ..hypothesis_helpers import numeric_arrays
 from .._array_module import ceil
 
 from hypothesis import given
 
 
 @given(numeric_arrays)
-def test_ceil_special_cases_one_arg_equal(arg1):
+def test_ceil_special_cases_one_arg_equal_1(arg1):
     """
     Special case test for `ceil(x, /)`:
 
@@ -25,3 +25,68 @@ def test_ceil_special_cases_one_arg_equal(arg1):
     res = ceil(arg1)
     mask = isintegral(arg1)
     assert_exactly_equal(res[mask], (arg1)[mask])
+
+
+@given(numeric_arrays)
+def test_ceil_special_cases_one_arg_equal_2(arg1):
+    """
+    Special case test for `ceil(x, /)`:
+
+        -   If `x_i` is `+infinity`, the result is `+infinity`.
+
+    """
+    res = ceil(arg1)
+    mask = exactly_equal(arg1, infinity(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (infinity(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_ceil_special_cases_one_arg_equal_3(arg1):
+    """
+    Special case test for `ceil(x, /)`:
+
+        -   If `x_i` is `-infinity`, the result is `-infinity`.
+
+    """
+    res = ceil(arg1)
+    mask = exactly_equal(arg1, -infinity(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (-infinity(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_ceil_special_cases_one_arg_equal_4(arg1):
+    """
+    Special case test for `ceil(x, /)`:
+
+        -   If `x_i` is `+0`, the result is `+0`.
+
+    """
+    res = ceil(arg1)
+    mask = exactly_equal(arg1, zero(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (zero(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_ceil_special_cases_one_arg_equal_5(arg1):
+    """
+    Special case test for `ceil(x, /)`:
+
+        -   If `x_i` is `-0`, the result is `-0`.
+
+    """
+    res = ceil(arg1)
+    mask = exactly_equal(arg1, -zero(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (-zero(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_ceil_special_cases_one_arg_equal_6(arg1):
+    """
+    Special case test for `ceil(x, /)`:
+
+        -   If `x_i` is `NaN`, the result is `NaN`.
+
+    """
+    res = ceil(arg1)
+    mask = exactly_equal(arg1, NaN(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (NaN(arg1.shape, arg1.dtype))[mask])

array_api_tests/special_cases/test_floor.py

@@ -7,15 +7,15 @@
 not modify it directly.
 """
 
-from ..array_helpers import assert_exactly_equal, isintegral
+from ..array_helpers import NaN, assert_exactly_equal, exactly_equal, infinity, isintegral, zero
 from ..hypothesis_helpers import numeric_arrays
 from .._array_module import floor
 
 from hypothesis import given
 
 
 @given(numeric_arrays)
-def test_floor_special_cases_one_arg_equal(arg1):
+def test_floor_special_cases_one_arg_equal_1(arg1):
     """
     Special case test for `floor(x, /)`:
 
@@ -25,3 +25,68 @@ def test_floor_special_cases_one_arg_equal(arg1):
     res = floor(arg1)
     mask = isintegral(arg1)
     assert_exactly_equal(res[mask], (arg1)[mask])
+
+
+@given(numeric_arrays)
+def test_floor_special_cases_one_arg_equal_2(arg1):
+    """
+    Special case test for `floor(x, /)`:
+
+        -   If `x_i` is `+infinity`, the result is `+infinity`.
+
+    """
+    res = floor(arg1)
+    mask = exactly_equal(arg1, infinity(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (infinity(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_floor_special_cases_one_arg_equal_3(arg1):
+    """
+    Special case test for `floor(x, /)`:
+
+        -   If `x_i` is `-infinity`, the result is `-infinity`.
+
+    """
+    res = floor(arg1)
+    mask = exactly_equal(arg1, -infinity(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (-infinity(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_floor_special_cases_one_arg_equal_4(arg1):
+    """
+    Special case test for `floor(x, /)`:
+
+        -   If `x_i` is `+0`, the result is `+0`.
+
+    """
+    res = floor(arg1)
+    mask = exactly_equal(arg1, zero(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (zero(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_floor_special_cases_one_arg_equal_5(arg1):
+    """
+    Special case test for `floor(x, /)`:
+
+        -   If `x_i` is `-0`, the result is `-0`.
+
+    """
+    res = floor(arg1)
+    mask = exactly_equal(arg1, -zero(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (-zero(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_floor_special_cases_one_arg_equal_6(arg1):
+    """
+    Special case test for `floor(x, /)`:
+
+        -   If `x_i` is `NaN`, the result is `NaN`.
+
+    """
+    res = floor(arg1)
+    mask = exactly_equal(arg1, NaN(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (NaN(arg1.shape, arg1.dtype))[mask])

array_api_tests/special_cases/test_round.py

@@ -7,16 +7,17 @@
 not modify it directly.
 """
 
-from ..array_helpers import (assert_exactly_equal, assert_iseven, assert_positive, ceil, equal,
-                             floor, isintegral, logical_and, not_equal, one, subtract)
+from ..array_helpers import (NaN, assert_exactly_equal, assert_iseven, assert_positive, ceil, equal,
+                             exactly_equal, floor, infinity, isintegral, logical_and, not_equal,
+                             one, subtract, zero)
 from ..hypothesis_helpers import numeric_arrays
 from .._array_module import round
 
 from hypothesis import given
 
 
 @given(numeric_arrays)
-def test_round_special_cases_one_arg_equal(arg1):
+def test_round_special_cases_one_arg_equal_1(arg1):
     """
     Special case test for `round(x, /)`:
 
@@ -28,6 +29,71 @@ def test_round_special_cases_one_arg_equal(arg1):
     assert_exactly_equal(res[mask], (arg1)[mask])
 
 
+@given(numeric_arrays)
+def test_round_special_cases_one_arg_equal_2(arg1):
+    """
+    Special case test for `round(x, /)`:
+
+        -   If `x_i` is `+infinity`, the result is `+infinity`.
+
+    """
+    res = round(arg1)
+    mask = exactly_equal(arg1, infinity(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (infinity(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_round_special_cases_one_arg_equal_3(arg1):
+    """
+    Special case test for `round(x, /)`:
+
+        -   If `x_i` is `-infinity`, the result is `-infinity`.
+
+    """
+    res = round(arg1)
+    mask = exactly_equal(arg1, -infinity(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (-infinity(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_round_special_cases_one_arg_equal_4(arg1):
+    """
+    Special case test for `round(x, /)`:
+
+        -   If `x_i` is `+0`, the result is `+0`.
+
+    """
+    res = round(arg1)
+    mask = exactly_equal(arg1, zero(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (zero(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_round_special_cases_one_arg_equal_5(arg1):
+    """
+    Special case test for `round(x, /)`:
+
+        -   If `x_i` is `-0`, the result is `-0`.
+
+    """
+    res = round(arg1)
+    mask = exactly_equal(arg1, -zero(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (-zero(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_round_special_cases_one_arg_equal_6(arg1):
+    """
+    Special case test for `round(x, /)`:
+
+        -   If `x_i` is `NaN`, the result is `NaN`.
+
+    """
+    res = round(arg1)
+    mask = exactly_equal(arg1, NaN(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (NaN(arg1.shape, arg1.dtype))[mask])
+
+
 @given(numeric_arrays)
 def test_round_special_cases_one_arg_two_integers_equally_close(arg1):
     """

array_api_tests/special_cases/test_trunc.py

@@ -7,15 +7,15 @@
 not modify it directly.
 """
 
-from ..array_helpers import assert_exactly_equal, isintegral
+from ..array_helpers import NaN, assert_exactly_equal, exactly_equal, infinity, isintegral, zero
 from ..hypothesis_helpers import numeric_arrays
 from .._array_module import trunc
 
 from hypothesis import given
 
 
 @given(numeric_arrays)
-def test_trunc_special_cases_one_arg_equal(arg1):
+def test_trunc_special_cases_one_arg_equal_1(arg1):
     """
     Special case test for `trunc(x, /)`:
 
@@ -25,3 +25,68 @@ def test_trunc_special_cases_one_arg_equal(arg1):
     res = trunc(arg1)
     mask = isintegral(arg1)
     assert_exactly_equal(res[mask], (arg1)[mask])
+
+
+@given(numeric_arrays)
+def test_trunc_special_cases_one_arg_equal_2(arg1):
+    """
+    Special case test for `trunc(x, /)`:
+
+        -   If `x_i` is `+infinity`, the result is `+infinity`.
+
+    """
+    res = trunc(arg1)
+    mask = exactly_equal(arg1, infinity(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (infinity(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_trunc_special_cases_one_arg_equal_3(arg1):
+    """
+    Special case test for `trunc(x, /)`:
+
+        -   If `x_i` is `-infinity`, the result is `-infinity`.
+
+    """
+    res = trunc(arg1)
+    mask = exactly_equal(arg1, -infinity(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (-infinity(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_trunc_special_cases_one_arg_equal_4(arg1):
+    """
+    Special case test for `trunc(x, /)`:
+
+        -   If `x_i` is `+0`, the result is `+0`.
+
+    """
+    res = trunc(arg1)
+    mask = exactly_equal(arg1, zero(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (zero(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_trunc_special_cases_one_arg_equal_5(arg1):
+    """
+    Special case test for `trunc(x, /)`:
+
+        -   If `x_i` is `-0`, the result is `-0`.
+
+    """
+    res = trunc(arg1)
+    mask = exactly_equal(arg1, -zero(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (-zero(arg1.shape, arg1.dtype))[mask])
+
+
+@given(numeric_arrays)
+def test_trunc_special_cases_one_arg_equal_6(arg1):
+    """
+    Special case test for `trunc(x, /)`:
+
+        -   If `x_i` is `NaN`, the result is `NaN`.
+
+    """
+    res = trunc(arg1)
+    mask = exactly_equal(arg1, NaN(arg1.shape, arg1.dtype))
+    assert_exactly_equal(res[mask], (NaN(arg1.shape, arg1.dtype))[mask])