Fix usage of "mathematical sign" in the special cases tests

It refers to the sign bit.

Author: asmeurer

array_api_tests/array_helpers.py

@@ -14,8 +14,10 @@
            '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']
+           'assert_integral', 'isodd', 'assert_isinf',
+           'positive_mathematical_sign', 'assert_positive_mathematical_sign',
+           'negative_mathematical_sign', 'assert_negative_mathematical_sign',
+           'same_sign', 'assert_same_sign']
 
 def zero(shape, dtype):
     """
@@ -194,6 +196,34 @@ def assert_isinf(x):
     """
     assert all(isinf(x)), "The input array is not infinite"
 
+def positive_mathematical_sign(x):
+    """
+    Check if x has a positive "mathematical sign"
+
+    The "mathematical sign" here means the sign bit is 0. This includes 0,
+    positive finite numbers, and positive infinity. It does not include any
+    nans, as signed nans are not required by the spec.
+
+    """
+    return logical_or(greater(x, 0), isposzero(x))
+
+def assert_positive_mathematical_sign(x):
+    assert all(positive_mathematical_sign(x)), "The input arrays do not have a positive mathematical sign"
+
+def negative_mathematical_sign(x):
+    """
+    Check if x has a negative "mathematical sign"
+
+    The "mathematical sign" here means the sign bit is 1. This includes -0,
+    negative finite numbers, and negative infinity. It does not include any
+    nans, as signed nans are not required by the spec.
+
+    """
+    return logical_or(less(x, 0), isnegzero(x))
+
+def assert_negative_mathematical_sign(x):
+    assert all(negative_mathematical_sign(x)), "The input arrays do not have a negative mathematical sign"
+
 def same_sign(x, y):
     """
     Check if x and y have the "same sign"
@@ -203,13 +233,9 @@ def same_sign(x, y):
     have the same sign. The value of this function is False if either x or y
     is nan, as signed nans are not required by the spec.
     """
-    logical_or(
-        logical_and(
-            logical_or(greater(x, 0), isposzero(x)),
-            logical_or(greater(y, 0), isposzero(y))),
-        logical_and(
-            logical_or(less(x, 0), isnegzero(x)),
-            logical_or(less(y, 0), isnegzero(y))))
+    return logical_or(
+        logical_and(positive_mathematical_sign(x), positive_mathematical_sign(y)),
+        logical_and(negative_mathematical_sign(x), negative_mathematical_sign(y)))
 
 def assert_same_sign(x, y):
     assert all(same_sign(x, y)), "The input arrays do not have the same sign"

array_api_tests/special_cases/test_divide.py

@@ -7,9 +7,10 @@
 not modify it directly.
 """
 
-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, non_zero, same_sign, zero)
+from ..array_helpers import (NaN, assert_exactly_equal, assert_negative_mathematical_sign,
+                             assert_positive_mathematical_sign, exactly_equal, greater, infinity,
+                             isfinite, isnegative, ispositive, less, logical_and, logical_not,
+                             logical_or, non_zero, same_sign, zero)
 from ..hypothesis_helpers import numeric_arrays
 from .._array_module import divide
 
@@ -273,7 +274,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), non_zero(arg1)), logical_and(isfinite(arg2), non_zero(arg2))))
-    assert_positive(res[mask])
+    assert_positive_mathematical_sign(res[mask])
 
 
 @given(numeric_arrays, numeric_arrays)
@@ -286,7 +287,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), non_zero(arg1)), logical_and(isfinite(arg2), non_zero(arg2))))
-    assert_negative(res[mask])
+    assert_negative_mathematical_sign(res[mask])
 
 # TODO: Implement REMAINING test for:
 # -   In the remaining cases, where neither `-infinity`, `+0`, `-0`, nor `NaN` is involved, the quotient must be computed and rounded to the nearest representable value according to IEEE 754-2019 and a supported rounding mode. If the magnitude is too larger to represent, the operation overflows and the result is an `infinity` of appropriate mathematical sign. If the magnitude is too small to represent, the operation underflows and the result is a zero of appropriate mathematical sign.

array_api_tests/special_cases/test_multiply.py

@@ -7,9 +7,10 @@
 not modify it directly.
 """
 
-from ..array_helpers import (NaN, assert_exactly_equal, assert_isinf, assert_negative,
-                             assert_positive, exactly_equal, infinity, isfinite, logical_and,
-                             logical_not, logical_or, non_zero, same_sign, zero)
+from ..array_helpers import (NaN, assert_exactly_equal, assert_isinf,
+                             assert_negative_mathematical_sign, assert_positive_mathematical_sign,
+                             exactly_equal, infinity, isfinite, logical_and, logical_not,
+                             logical_or, non_zero, same_sign, zero)
 from ..hypothesis_helpers import numeric_arrays
 from .._array_module import multiply
 
@@ -39,7 +40,7 @@ def test_multiply_special_cases_two_args_same_sign(arg1, arg2):
     """
     res = multiply(arg1, arg2)
     mask = same_sign(arg1, arg2)
-    assert_positive(res[mask])
+    assert_positive_mathematical_sign(res[mask])
 
 
 @given(numeric_arrays, numeric_arrays)
@@ -52,7 +53,7 @@ def test_multiply_special_cases_two_args_different_signs(arg1, arg2):
     """
     res = multiply(arg1, arg2)
     mask = logical_not(same_sign(arg1, arg2))
-    assert_negative(res[mask])
+    assert_negative_mathematical_sign(res[mask])
 
 
 @given(numeric_arrays, numeric_arrays)

generate_stubs.py

@@ -182,7 +182,7 @@ def {sig}:{doc}
 # (?|...) is a branch reset (regex module only feature). It works like (?:...)
 # except only the matched alternative is assigned group numbers, so \1, \2, and
 # so on will always refer to a single match from _value.
-_value = r"(?|`([^`]*)`|a (finite) number|a (positive \(i\.e\., greater than `0`\) finite) number|a (negative \(i\.e\., less than `0`\) finite) number|(finite)|(positive)|(negative)|(nonzero)|(?:a )?(nonzero finite) numbers?|an (integer) value|already (integer)-valued|an (odd integer) value|an implementation-dependent approximation to `([^`]*)`(?: \(rounded\))?|a (signed (?:infinity|zero)) with the mathematical sign determined by the rule already stated above|(positive) mathematical sign|(negative) mathematical sign)"
+_value = r"(?|`([^`]*)`|a (finite) number|a (positive \(i\.e\., greater than `0`\) finite) number|a (negative \(i\.e\., less than `0`\) finite) number|(finite)|(positive)|(negative)|(nonzero)|(?:a )?(nonzero finite) numbers?|an (integer) value|already (integer)-valued|an (odd integer) value|an implementation-dependent approximation to `([^`]*)`(?: \(rounded\))?|a (signed (?:infinity|zero)) with the mathematical sign determined by the rule already stated above|(positive mathematical sign)|(negative mathematical sign))"
 SPECIAL_CASE_REGEXS = dict(
     ONE_ARG_EQUAL = regex.compile(rf'^- +If `x_i` is {_value}, the result is {_value}\.$'),
     ONE_ARG_GREATER = regex.compile(rf'^- +If `x_i` is greater than {_value}, the result is {_value}\.$'),
@@ -248,7 +248,8 @@ def parse_value(value, arg):
         return value
     elif value in ['finite', 'nonzero', 'nonzero finite',
                    "integer", "odd integer", "positive",
-                   "negative"]:
+                   "negative", "positive mathematical sign",
+                   "negative mathematical sign"]:
         return value
     # There's no way to remove the parenthetical from the matching group in
     # the regular expression.
@@ -287,9 +288,15 @@ def get_mask(typ, arg, value):
     elif value == 'positive':
         _check_exactly_equal(typ, value)
         return f"ispositive({arg})"
+    elif value == 'positive mathematical sign':
+        _check_exactly_equal(typ, value)
+        return f"positive_mathematical_sign({arg})"
     elif value == 'negative':
         _check_exactly_equal(typ, value)
         return f"isnegative({arg})"
+    elif value == 'negative mathematical sign':
+        _check_exactly_equal(typ, value)
+        return f"negative_mathematical_sign({arg})"
     elif value == 'integer':
         _check_exactly_equal(typ, value)
         return f"isintegral({arg})"
@@ -311,9 +318,15 @@ def get_assert(typ, result):
     elif result == "positive":
         _check_exactly_equal(typ, result)
         return "assert_positive(res[mask])"
+    elif result == "positive mathematical sign":
+        _check_exactly_equal(typ, result)
+        return "assert_positive_mathematical_sign(res[mask])"
     elif result == "negative":
         _check_exactly_equal(typ, result)
         return "assert_negative(res[mask])"
+    elif result == "negative mathematical sign":
+        _check_exactly_equal(typ, result)
+        return "assert_negative_mathematical_sign(res[mask])"
     elif 'x_i' in result:
         return f"assert_{typ}(res[mask], {result.replace('x_i', 'arg1')}[mask])"
     elif 'x1_i' in result: