float_dtypes -> real_float_dtypes

Better reflect the specs naming convention and avoid confusion with complex

Author: honno

array_api_tests/dtype_helpers.py

@@ -14,15 +14,15 @@
     "uint_names",
     "int_names",
     "all_int_names",
-    "float_names",
+    "real_float_names",
     "real_names",
     "complex_names",
     "numeric_names",
     "dtype_names",
     "int_dtypes",
     "uint_dtypes",
     "all_int_dtypes",
-    "float_dtypes",
+    "real_float_dtypes",
     "real_dtypes",
     "numeric_dtypes",
     "all_dtypes",
@@ -98,8 +98,8 @@ def __repr__(self):
 uint_names = ("uint8", "uint16", "uint32", "uint64")
 int_names = ("int8", "int16", "int32", "int64")
 all_int_names = uint_names + int_names
-float_names = ("float32", "float64")
-real_names = uint_names + int_names + float_names
+real_float_names = ("float32", "float64")
+real_names = uint_names + int_names + real_float_names
 complex_names = ("complex64", "complex128")
 numeric_names = real_names + complex_names
 dtype_names = ("bool",) + numeric_names
@@ -128,15 +128,15 @@ def _make_dtype_tuple_from_names(names: List[str]) -> Tuple[DataType]:
 
 uint_dtypes = _make_dtype_tuple_from_names(uint_names)
 int_dtypes = _make_dtype_tuple_from_names(int_names)
-float_dtypes = _make_dtype_tuple_from_names(float_names)
+real_float_dtypes = _make_dtype_tuple_from_names(real_float_names)
 all_int_dtypes = uint_dtypes + int_dtypes
-real_dtypes = all_int_dtypes + float_dtypes
+real_dtypes = all_int_dtypes + real_float_dtypes
 complex_dtypes = _make_dtype_tuple_from_names(complex_names)
 numeric_dtypes = real_dtypes
 if api_version > "2021.12":
     numeric_dtypes += complex_dtypes
 all_dtypes = (xp.bool,) + numeric_dtypes
-all_float_dtypes = float_dtypes
+all_float_dtypes = real_float_dtypes
 if api_version > "2021.12":
     all_float_dtypes += complex_dtypes
 bool_and_all_int_dtypes = (xp.bool,) + all_int_dtypes
@@ -147,7 +147,7 @@ def _make_dtype_tuple_from_names(names: List[str]) -> Tuple[DataType]:
     "signed integer": int_dtypes,
     "unsigned integer": uint_dtypes,
     "integral": all_int_dtypes,
-    "real floating": float_dtypes,
+    "real floating": real_float_dtypes,
     "complex floating": complex_dtypes,
     "numeric": numeric_dtypes,
 }
@@ -164,7 +164,7 @@ def is_float_dtype(dtype):
     # See https://github.com/numpy/numpy/issues/18434
     if dtype is None:
         return False
-    valid_dtypes = float_dtypes
+    valid_dtypes = real_float_dtypes
     if api_version > "2021.12":
         valid_dtypes += complex_dtypes
     return dtype in valid_dtypes
@@ -173,7 +173,7 @@ def is_float_dtype(dtype):
 def get_scalar_type(dtype: DataType) -> ScalarType:
     if dtype in all_int_dtypes:
         return int
-    elif dtype in float_dtypes:
+    elif dtype in real_float_dtypes:
         return float
     elif dtype in complex_dtypes:
         return complex
@@ -245,7 +245,7 @@ class MinMax(NamedTuple):
     if default_int not in int_dtypes:
         warn(f"inferred default int is {default_int!r}, which is not an int")
     default_float = xp.asarray(float()).dtype
-    if default_float not in float_dtypes:
+    if default_float not in real_float_dtypes:
         warn(f"inferred default float is {default_float!r}, which is not a float")
     if api_version > "2021.12":
         default_complex = xp.asarray(complex()).dtype
@@ -346,7 +346,7 @@ def result_type(*dtypes: DataType):
 category_to_dtypes = {
     "boolean": (xp.bool,),
     "integer": all_int_dtypes,
-    "floating-point": float_dtypes,
+    "floating-point": real_float_dtypes,
     "numeric": numeric_dtypes,
     "integer or boolean": bool_and_all_int_dtypes,
 }
@@ -360,7 +360,7 @@ def result_type(*dtypes: DataType):
         dtypes = category_to_dtypes[dtype_category]
         func_in_dtypes[name] = dtypes
 # See https://github.com/data-apis/array-api/pull/413
-func_in_dtypes["expm1"] = float_dtypes
+func_in_dtypes["expm1"] = real_float_dtypes
 
 
 func_returns_bool = {
@@ -500,7 +500,7 @@ def result_type(*dtypes: DataType):
 func_in_dtypes["__bool__"] = (xp.bool,)
 func_in_dtypes["__int__"] = all_int_dtypes
 func_in_dtypes["__index__"] = all_int_dtypes
-func_in_dtypes["__float__"] = float_dtypes
+func_in_dtypes["__float__"] = real_float_dtypes
 func_in_dtypes["from_dlpack"] = numeric_dtypes
 func_in_dtypes["__dlpack__"] = numeric_dtypes
 

array_api_tests/hypothesis_helpers.py

@@ -39,7 +39,7 @@
 shared_dtypes = shared(dtypes, key="dtype")
 shared_floating_dtypes = shared(floating_dtypes, key="dtype")
 
-_dtype_categories = [(xp.bool,), dh.uint_dtypes, dh.int_dtypes, dh.float_dtypes, dh.complex_dtypes]
+_dtype_categories = [(xp.bool,), dh.uint_dtypes, dh.int_dtypes, dh.real_float_dtypes, dh.complex_dtypes]
 _sorted_dtypes = [d for category in _dtype_categories for d in category]
 
 def _dtypes_sorter(dtype_pair: Tuple[DataType, DataType]):

array_api_tests/meta/test_hypothesis_helpers.py

@@ -15,7 +15,7 @@
 UNDEFINED_DTYPES = any(isinstance(d, _UndefinedStub) for d in dh.all_dtypes)
 pytestmark = [pytest.mark.skipif(UNDEFINED_DTYPES, reason="undefined dtypes")]
 
-@given(hh.mutually_promotable_dtypes(dtypes=dh.float_dtypes))
+@given(hh.mutually_promotable_dtypes(dtypes=dh.real_float_dtypes))
 def test_mutually_promotable_dtypes(pair):
     assert pair in (
         (xp.float32, xp.float32),

array_api_tests/pytest_helpers.py

@@ -446,7 +446,7 @@ def assert_array_elements(
     dh.result_type(out.dtype, expected.dtype)  # sanity check
     assert_shape(func_name, out_shape=out.shape, expected=expected.shape, kw=kw)  # sanity check
     f_func = f"[{func_name}({fmt_kw(kw)})]"
-    if out.dtype in dh.float_dtypes:
+    if out.dtype in dh.real_float_dtypes:
         for idx in sh.ndindex(out.shape):
             at_out = out[idx]
             at_expected = expected[idx]

array_api_tests/test_array_object.py

@@ -255,7 +255,7 @@ def make_scalar_casting_param(
     [make_scalar_casting_param("__bool__", "bool", bool)]
     + [make_scalar_casting_param("__int__", n, int) for n in dh.all_int_names]
     + [make_scalar_casting_param("__index__", n, int) for n in dh.all_int_names]
-    + [make_scalar_casting_param("__float__", n, float) for n in dh.float_names],
+    + [make_scalar_casting_param("__float__", n, float) for n in dh.real_float_names],
 )
 @given(data=st.data())
 def test_scalar_casting(method_name, dtype_name, stype, data):

array_api_tests/test_data_type_functions.py

@@ -124,7 +124,7 @@ def test_can_cast(_from, to, data):
         expected = to == xp.bool
     else:
         same_family = None
-        for dtypes in [dh.all_int_dtypes, dh.float_dtypes, dh.complex_dtypes]:
+        for dtypes in [dh.all_int_dtypes, dh.real_float_dtypes, dh.complex_dtypes]:
             if _from in dtypes:
                 same_family = to in dtypes
                 break
@@ -142,7 +142,7 @@ def test_can_cast(_from, to, data):
         assert out == expected, f"{out=}, but should be {expected} {f_func}"
 
 
-@pytest.mark.parametrize("dtype_name", dh.float_names)
+@pytest.mark.parametrize("dtype_name", dh.real_float_names)
 def test_finfo(dtype_name):
     try:
         dtype = getattr(_xp, dtype_name)

array_api_tests/test_operators_and_elementwise_functions.py

@@ -776,7 +776,7 @@ def test_atan(x):
     unary_assert_against_refimpl("atan", x, out, math.atan)
 
 
-@given(*hh.two_mutual_arrays(dh.float_dtypes))
+@given(*hh.two_mutual_arrays(dh.real_float_dtypes))
 def test_atan2(x1, x2):
     out = xp.atan2(x1, x2)
     ph.assert_dtype("atan2", in_dtype=[x1.dtype, x2.dtype], out_dtype=out.dtype)
@@ -1204,7 +1204,7 @@ def logaddexp(l: float, r: float) -> float:
     return math.log(math.exp(l) + math.exp(r))
 
 
-@given(*hh.two_mutual_arrays(dh.float_dtypes))
+@given(*hh.two_mutual_arrays(dh.real_float_dtypes))
 def test_logaddexp(x1, x2):
     out = xp.logaddexp(x1, x2)
     ph.assert_dtype("logaddexp", in_dtype=[x1.dtype, x2.dtype], out_dtype=out.dtype)

array_api_tests/test_special_cases.py

@@ -1231,7 +1231,7 @@ def test_unary(func_name, func, case, x, data):
 
 
 x1_strat, x2_strat = hh.two_mutual_arrays(
-    dtypes=dh.float_dtypes,
+    dtypes=dh.real_float_dtypes,
     two_shapes=hh.mutually_broadcastable_shapes(2, min_side=1),
 )
 
@@ -1277,7 +1277,7 @@ def test_binary(func_name, func, case, x1, x2, data):
 
 @pytest.mark.parametrize("iop_name, iop, case", iop_params)
 @given(
-    oneway_dtypes=hh.oneway_promotable_dtypes(dh.float_dtypes),
+    oneway_dtypes=hh.oneway_promotable_dtypes(dh.real_float_dtypes),
     oneway_shapes=hh.oneway_broadcastable_shapes(),
     data=st.data(),
 )