Rename the nonzero() array helper to non_zero()

nonzero() is already a spec function, and it returns something different.

Author: asmeurer

array_api_tests/array_helpers.py

@@ -8,10 +8,11 @@
 # tests from this file.
 from ._array_module import logical_not, subtract, floor, ceil, where
 
-__all__ = ['logical_and', 'logical_or', 'logical_not', 'less', 'greater', 'subtract',
-           'floor', 'ceil', 'where', 'isfinite', 'equal', 'zero', 'one', 'NaN', 'infinity', 'π',
-           'isnegzero', 'isposzero', 'exactly_equal', 'assert_exactly_equal',
-           'assert_finite', 'nonzero', 'assert_nonzero', 'ispositive',
+__all__ = ['logical_and', 'logical_or', 'logical_not', 'less', 'greater',
+           'subtract', 'floor', 'ceil', 'where', 'isfinite', 'equal', 'zero',
+           'one', 'NaN', 'infinity', 'π', 'isnegzero', 'non_zero',
+           'isposzero', 'exactly_equal', 'assert_exactly_equal',
+           'assert_finite', 'assert_non_zero', 'ispositive',
            'assert_positive', 'isnegative', 'assert_negative', 'isintegral',
            'assert_integral', 'isodd', 'assert_isinf', 'same_sign',
            'assert_same_sign']
@@ -142,11 +143,11 @@ def assert_finite(x):
     """
     assert all(isfinite(x)), "The input array is not finite"
 
-def nonzero(x):
-    not_equal(x, zero(x.dtype))
+def non_zero(x):
+    return not_equal(x, zero(x.shape, x.dtype))
 
-def assert_nonzero(x):
-    assert all(nonzero(x)), "The input array is not nonzero"
+def assert_non_zero(x):
+    assert all(non_zero(x)), "The input array is not nonzero"
 
 def ispositive(x):
     return greater(x, zero(x.shape, x.dtype))

array_api_tests/special_cases/test_add.py

@@ -8,7 +8,7 @@
 """
 
 from ..array_helpers import (NaN, assert_exactly_equal, exactly_equal, infinity, isfinite,
-                             logical_and, logical_or, nonzero, zero)
+                             logical_and, logical_or, non_zero, zero)
 from ..hypothesis_helpers import numeric_arrays
 from .._array_module import add
 
@@ -193,7 +193,7 @@ def test_add_special_cases_two_args_equal__equal_13(arg1, arg2):
 
     """
     res = add(arg1, arg2)
-    mask = logical_and(logical_and(isfinite(arg1), nonzero(arg1)), exactly_equal(arg2, -arg1))
+    mask = logical_and(logical_and(isfinite(arg1), non_zero(arg1)), exactly_equal(arg2, -arg1))
     assert_exactly_equal(res[mask], zero(arg1.shape, arg1.dtype)[mask])
 
 
@@ -206,7 +206,7 @@ def test_add_special_cases_two_args_either__equal(arg1, arg2):
 
     """
     res = add(arg1, arg2)
-    mask = logical_and(logical_or(exactly_equal(arg1, zero(arg1.shape, arg1.dtype)), exactly_equal(arg1, -zero(arg1.shape, arg1.dtype))), logical_and(isfinite(arg2), nonzero(arg2)))
+    mask = logical_and(logical_or(exactly_equal(arg1, zero(arg1.shape, arg1.dtype)), exactly_equal(arg1, -zero(arg1.shape, arg1.dtype))), logical_and(isfinite(arg2), non_zero(arg2)))
     assert_exactly_equal(res[mask], arg2[mask])
 
 
@@ -219,7 +219,7 @@ def test_add_special_cases_two_args_equal__either(arg1, arg2):
 
     """
     res = add(arg1, arg2)
-    mask = logical_and(logical_and(isfinite(arg1), nonzero(arg1)), logical_or(exactly_equal(arg2, zero(arg2.shape, arg2.dtype)), exactly_equal(arg2, -zero(arg2.shape, arg2.dtype))))
+    mask = logical_and(logical_and(isfinite(arg1), non_zero(arg1)), logical_or(exactly_equal(arg2, zero(arg2.shape, arg2.dtype)), exactly_equal(arg2, -zero(arg2.shape, arg2.dtype))))
     assert_exactly_equal(res[mask], arg1[mask])
 
 # TODO: Implement REMAINING test for:

array_api_tests/special_cases/test_divide.py

@@ -9,7 +9,7 @@
 
 from ..array_helpers import (NaN, assert_exactly_equal, assert_negative, assert_positive,
                              exactly_equal, greater, infinity, isfinite, isnegative, ispositive,
-                             less, logical_and, logical_not, logical_or, nonzero, same_sign, zero)
+                             less, logical_and, logical_not, logical_or, non_zero, same_sign, zero)
 from ..hypothesis_helpers import numeric_arrays
 from .._array_module import divide
 
@@ -272,7 +272,7 @@ def test_divide_special_cases_two_args_same_sign_both(arg1, arg2):
 
     """
     res = divide(arg1, arg2)
-    mask = logical_and(same_sign(arg1, arg2), logical_and(logical_and(isfinite(arg1), nonzero(arg1)), logical_and(isfinite(arg2), nonzero(arg2))))
+    mask = logical_and(same_sign(arg1, arg2), logical_and(logical_and(isfinite(arg1), non_zero(arg1)), logical_and(isfinite(arg2), non_zero(arg2))))
     assert_positive(res[mask])
 
 
@@ -285,7 +285,7 @@ def test_divide_special_cases_two_args_different_signs_both(arg1, arg2):
 
     """
     res = divide(arg1, arg2)
-    mask = logical_and(logical_not(same_sign(arg1, arg2)), logical_and(logical_and(isfinite(arg1), nonzero(arg1)), logical_and(isfinite(arg2), nonzero(arg2))))
+    mask = logical_and(logical_not(same_sign(arg1, arg2)), logical_and(logical_and(isfinite(arg1), non_zero(arg1)), logical_and(isfinite(arg2), non_zero(arg2))))
     assert_negative(res[mask])
 
 # TODO: Implement REMAINING test for:

array_api_tests/special_cases/test_multiply.py

@@ -9,7 +9,7 @@
 
 from ..array_helpers import (NaN, assert_exactly_equal, assert_isinf, assert_negative,
                              assert_positive, exactly_equal, infinity, isfinite, logical_and,
-                             logical_not, logical_or, nonzero, same_sign, zero)
+                             logical_not, logical_or, non_zero, same_sign, zero)
 from ..hypothesis_helpers import numeric_arrays
 from .._array_module import multiply
 
@@ -103,7 +103,7 @@ def test_multiply_special_cases_two_args_either__equal(arg1, arg2):
 
     """
     res = multiply(arg1, arg2)
-    mask = logical_and(logical_or(exactly_equal(arg1, infinity(arg1.shape, arg1.dtype)), exactly_equal(arg1, -infinity(arg1.shape, arg1.dtype))), logical_and(isfinite(arg2), nonzero(arg2)))
+    mask = logical_and(logical_or(exactly_equal(arg1, infinity(arg1.shape, arg1.dtype)), exactly_equal(arg1, -infinity(arg1.shape, arg1.dtype))), logical_and(isfinite(arg2), non_zero(arg2)))
     assert_isinf(res[mask])
 
 
@@ -116,7 +116,7 @@ def test_multiply_special_cases_two_args_equal__either(arg1, arg2):
 
     """
     res = multiply(arg1, arg2)
-    mask = logical_and(logical_and(isfinite(arg1), nonzero(arg1)), logical_or(exactly_equal(arg2, infinity(arg2.shape, arg2.dtype)), exactly_equal(arg2, -infinity(arg2.shape, arg2.dtype))))
+    mask = logical_and(logical_and(isfinite(arg1), non_zero(arg1)), logical_or(exactly_equal(arg2, infinity(arg2.shape, arg2.dtype)), exactly_equal(arg2, -infinity(arg2.shape, arg2.dtype))))
     assert_isinf(res[mask])
 
 # TODO: Implement REMAINING test for:

generate_stubs.py

@@ -274,7 +274,7 @@ def get_mask(typ, arg, value):
         return f"isfinite({arg})"
     elif value == 'nonzero':
         _check_exactly_equal(typ, value)
-        return f"nonzero({arg})"
+        return f"non_zero({arg})"
     elif value == 'positive finite':
         _check_exactly_equal(typ, value)
         return f"logical_and(isfinite({arg}), ispositive({arg}))"
@@ -283,7 +283,7 @@ def get_mask(typ, arg, value):
         return f"logical_and(isfinite({arg}), isnegative({arg}))"
     elif value == 'nonzero finite':
         _check_exactly_equal(typ, value)
-        return f"logical_and(isfinite({arg}), nonzero({arg}))"
+        return f"logical_and(isfinite({arg}), non_zero({arg}))"
     elif value == 'positive':
         _check_exactly_equal(typ, value)
         return f"ispositive({arg})"