ENH: test minimium() with python scalars

Author: ev-br

array_api_tests/dtype_helpers.py

@@ -198,6 +198,7 @@ def get_scalar_type(dtype: DataType) -> ScalarType:
 def is_scalar(x):
     return isinstance(x, (int, float, complex, bool))
 
+
 def _make_dtype_mapping_from_names(mapping: Dict[str, Any]) -> EqualityMapping:
     dtype_value_pairs = []
     for name, value in mapping.items():

array_api_tests/hypothesis_helpers.py

@@ -571,6 +571,20 @@ def two_mutual_arrays(
     )
     return arrays1, arrays2
 
+
+@composite
+def array_and_py_scalar(draw, dtypes):
+    """Draw a pair: (array, scalar) or (scalar, array)."""
+    dtype = draw(sampled_from(dtypes))
+    scalar_var = draw(scalars(just(dtype), finite=True))
+    array_var = draw(arrays(dtype, shape=shapes(min_dims=1)))
+
+    if draw(booleans()):
+        return scalar_var, array_var
+    else:
+        return array_var, scalar_var
+
+
 @composite
 def kwargs(draw, **kw):
     """

array_api_tests/test_operators_and_elementwise_functions.py

@@ -690,6 +690,31 @@ def binary_param_assert_against_refimpl(
         )
 
 
+def _convert_scalars_helper(x1, x2):
+    """Convert python scalar to arrays, record the shapes/dtypes of arrays.
+
+    For inputs being scalars or arrays, return the dtypes and shapes of array arguments,
+    and all arguments converted to arrays.
+
+    dtypes are separate to help distinguishing between 
+    `py_scalar + f32_array -> f32_array` and `f64_array + f32_array -> f64_array`
+    """
+    if dh.is_scalar(x1):
+        in_dtypes = [x2.dtype]
+        in_shapes = [x2.shape]
+        x1a, x2a = xp.asarray(x1), x2
+    elif dh.is_scalar(x2):
+        in_dtypes = [x1.dtype]
+        in_shapes = [x1.shape]
+        x1a, x2a = x1, xp.asarray(x2)
+    else:
+        in_dtypes = [x1.dtype, x2.dtype]
+        in_shapes = [x1.shape, x2.shape]
+        x1a, x2a = x1, x2
+
+    return in_dtypes, in_shapes, (x1a, x2a)
+
+
 @pytest.mark.parametrize("ctx", make_unary_params("abs", dh.numeric_dtypes))
 @given(data=st.data())
 def test_abs(ctx, data):
@@ -1468,13 +1493,27 @@ def test_maximum(x1, x2):
     binary_assert_against_refimpl("maximum", x1, x2, out, max, strict_check=True)
 
 
+def _assert_correctness_binary(name, in_dtypes, in_shapes, in_arrs, out):
+    x1a, x2a = in_arrs
+    ph.assert_dtype(name, in_dtype=in_dtypes, out_dtype=out.dtype)
+    ph.assert_result_shape(name, in_shapes=in_shapes, out_shape=out.shape)
+    binary_assert_against_refimpl(name, x1a, x2a, out, min, strict_check=True)
+
+
 @pytest.mark.min_version("2023.12")
 @given(*hh.two_mutual_arrays(dh.real_float_dtypes))
 def test_minimum(x1, x2):
     out = xp.minimum(x1, x2)
-    ph.assert_dtype("minimum", in_dtype=[x1.dtype, x2.dtype], out_dtype=out.dtype)
-    ph.assert_result_shape("minimum", in_shapes=[x1.shape, x2.shape], out_shape=out.shape)
-    binary_assert_against_refimpl("minimum", x1, x2, out, min, strict_check=True)
+    _assert_correctness_binary("minimum", [x1.dtype, x2.dtype], [x1.shape, x2.shape], (x1, x2), out)
+
+
+@pytest.mark.min_version("2024.12")
+@given(hh.array_and_py_scalar(dh.real_float_dtypes))
+def test_minimum_with_scalars(x1x2):
+    x1, x2 = x1x2
+    out = xp.minimum(x1, x2)
+    in_dtypes, in_shapes, (x1a, x2a) = _convert_scalars_helper(x1, x2)
+    _assert_correctness_binary("minimum", in_dtypes, in_shapes, (x1a, x2a), out)
 
 
 @pytest.mark.parametrize("ctx", make_binary_params("multiply", dh.numeric_dtypes))