update test_umath.py (#2367)

In this PR, `test_umath.py` is updated.

Author: vtavana

dpnp/tests/test_binary_ufuncs.py

@@ -13,6 +13,7 @@
 
 from .helper import (
     assert_dtype_allclose,
+    generate_random_numpy_array,
     get_abs_array,
     get_all_dtypes,
     get_complex_dtypes,
@@ -22,10 +23,6 @@
     has_support_aspect16,
     numpy_version,
 )
-from .test_umath import (
-    _get_numpy_arrays_2in_1out,
-    _get_output_data_type,
-)
 
 """
 The scope includes tests with only functions which are instances of
@@ -39,7 +36,9 @@ class TestAdd:
 
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_add(self, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out("add", dtype, [-5, 5, 10])
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = numpy.add(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)
@@ -139,91 +138,63 @@ def test_invalid_out(self, xp, out):
         assert_raises(TypeError, xp.add, a, 2, out)
 
 
+@pytest.mark.parametrize("func", ["fmax", "fmin", "maximum", "minimum"])
 class TestBoundFuncs:
-    @pytest.fixture(
-        params=[
-            {"func_name": "fmax", "input_values": [-5, 5, 10]},
-            {"func_name": "fmin", "input_values": [-5, 5, 10]},
-            {"func_name": "maximum", "input_values": [-5, 5, 10]},
-            {"func_name": "minimum", "input_values": [-5, 5, 10]},
-        ],
-        ids=[
-            "fmax",
-            "fmin",
-            "maximum",
-            "minimum",
-        ],
-    )
-    def func_params(self, request):
-        return request.param
-
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
-    )
-    def test_out(self, func_params, dtype):
-        func_name = func_params["func_name"]
-        input_values = func_params["input_values"]
-        a, b, expected = _get_numpy_arrays_2in_1out(
-            func_name, dtype, input_values
-        )
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
+    def test_out(self, func, dtype):
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = getattr(numpy, func)(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)
-        result = getattr(dpnp, func_name)(ia, ib, out=iout)
+        result = getattr(dpnp, func)(ia, ib, out=iout)
 
         assert result is iout
         assert_dtype_allclose(result, expected)
 
     @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
+        "dtype", get_all_dtypes(no_none=True, no_bool=True)
     )
-    def test_out_overlap(self, func_params, dtype):
-        func_name = func_params["func_name"]
+    def test_out_overlap(self, func, dtype):
         size = 15
         a = numpy.arange(2 * size, dtype=dtype)
         ia = dpnp.array(a)
 
-        getattr(dpnp, func_name)(ia[size::], ia[::2], out=ia[:size:])
-        getattr(numpy, func_name)(a[size::], a[::2], out=a[:size:])
+        getattr(dpnp, func)(ia[size::], ia[::2], out=ia[:size:])
+        getattr(numpy, func)(a[size::], a[::2], out=a[:size:])
 
         assert_dtype_allclose(ia, a)
 
     @pytest.mark.parametrize("shape", [(0,), (15,), (2, 2)])
-    def test_invalid_shape(self, func_params, shape):
-        func_name = func_params["func_name"]
+    def test_invalid_shape(self, func, shape):
         a, b = dpnp.arange(10), dpnp.arange(10)
         out = dpnp.empty(shape)
 
         with pytest.raises(ValueError):
-            getattr(dpnp, func_name)(a, b, out=out)
+            getattr(dpnp, func)(a, b, out=out)
 
     @pytest.mark.parametrize("xp", [dpnp, numpy])
     @pytest.mark.parametrize(
         "out",
         [4, (), [], (3, 7), [2, 4]],
         ids=["scalar", "empty_tuple", "empty_list", "tuple", "list"],
     )
-    def test_invalid_out(self, func_params, xp, out):
-        func_name = func_params["func_name"]
+    def test_invalid_out(self, func, xp, out):
         a = xp.arange(10)
-        assert_raises(TypeError, getattr(xp, func_name), a, 2, out)
+        assert_raises(TypeError, getattr(xp, func), a, 2, out)
 
 
 class TestDivide:
     @pytest.mark.usefixtures("suppress_divide_invalid_numpy_warnings")
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_bool=True)
-    )
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     def test_divide(self, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out(
-            "divide", dtype, [-5, 5, 10]
-        )
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = numpy.divide(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
-        if numpy.issubdtype(dtype, numpy.integer):
-            out_dtype = map_dtype_to_device(dpnp.float64, ia.sycl_device)
-        else:
-            out_dtype = _get_output_data_type(dtype)
+        out_dtype = map_dtype_to_device(expected.dtype, ia.sycl_device)
         iout = dpnp.empty(expected.shape, dtype=out_dtype)
         result = dpnp.divide(ia, ib, out=iout)
 
@@ -318,7 +289,9 @@ def do_inplace_op(self, base, other, func):
     @pytest.mark.usefixtures("suppress_divide_numpy_warnings")
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_basic(self, func, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out(func, dtype, [-5, 5, 10])
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = getattr(numpy, func)(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)
@@ -398,9 +371,9 @@ def test_invalid_out(self, func, xp, out):
         assert_raises(TypeError, getattr(xp, func), a, 2, out)
 
 
+@pytest.mark.parametrize("func", ["fmax", "fmin"])
 class TestFmaxFmin:
     @pytest.mark.skipif(not has_support_aspect16(), reason="no fp16 support")
-    @pytest.mark.parametrize("func", ["fmax", "fmin"])
     def test_half(self, func):
         a = numpy.array([0, 1, 2, 4, 2], dtype=numpy.float16)
         b = numpy.array([-2, 5, 1, 4, 3], dtype=numpy.float16)
@@ -415,7 +388,6 @@ def test_half(self, func):
         expected = getattr(numpy, func)(b, c)
         assert_equal(result, expected)
 
-    @pytest.mark.parametrize("func", ["fmax", "fmin"])
     @pytest.mark.parametrize("dtype", get_float_dtypes())
     def test_float_nans(self, func, dtype):
         a = numpy.array([0, numpy.nan, numpy.nan], dtype=dtype)
@@ -426,7 +398,6 @@ def test_float_nans(self, func, dtype):
         expected = getattr(numpy, func)(a, b)
         assert_equal(result, expected)
 
-    @pytest.mark.parametrize("func", ["fmax", "fmin"])
     @pytest.mark.parametrize("dtype", get_complex_dtypes())
     @pytest.mark.parametrize(
         "nan_val",
@@ -446,7 +417,6 @@ def test_complex_nans(self, func, dtype, nan_val):
         expected = getattr(numpy, func)(a, b)
         assert_equal(result, expected)
 
-    @pytest.mark.parametrize("func", ["fmax", "fmin"])
     @pytest.mark.parametrize("dtype", get_float_dtypes(no_float16=False))
     def test_precision(self, func, dtype):
         dtmin = numpy.finfo(dtype).min
@@ -602,9 +572,9 @@ class TestMultiply:
 
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_multiply(self, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out(
-            "multiply", dtype, [0, 10, 10]
-        )
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = numpy.multiply(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)
@@ -853,8 +823,9 @@ def test_basic(self, array, val, data_type, val_type):
 
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_power(self, dtype):
-        numpy.random.seed(42)
-        a, b, expected = _get_numpy_arrays_2in_1out("power", dtype, [0, 10, 10])
+        a = generate_random_numpy_array(10, dtype, low=0)
+        b = generate_random_numpy_array(10, dtype, low=0)
+        expected = numpy.power(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         out_dtype = numpy.int8 if dtype == numpy.bool_ else dtype
@@ -1075,9 +1046,9 @@ class TestSubtract:
 
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_add(self, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out(
-            "subtract", dtype, [-5, 5, 10]
-        )
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = numpy.subtract(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)

dpnp/tests/test_mathematical.py

@@ -17,6 +17,7 @@
 
 import dpnp
 from dpnp.dpnp_array import dpnp_array
+from dpnp.dpnp_utils import map_dtype_to_device
 
 from .helper import (
     assert_dtype_allclose,
@@ -32,14 +33,33 @@
     has_support_aspect64,
     numpy_version,
 )
-from .test_umath import (
-    _get_numpy_arrays_1in_1out,
-    _get_numpy_arrays_2in_1out,
-    _get_output_data_type,
-)
 from .third_party.cupy import testing
 
 
+def _get_output_data_type(dtype):
+    """Return a data type specified by input `dtype` and device capabilities."""
+    dtype_float16 = any(
+        dpnp.issubdtype(dtype, t) for t in (dpnp.bool, dpnp.int8, dpnp.uint8)
+    )
+    dtype_float32 = any(
+        dpnp.issubdtype(dtype, t) for t in (dpnp.int16, dpnp.uint16)
+    )
+    if dtype_float16:
+        out_dtype = dpnp.float16 if has_support_aspect16() else dpnp.float32
+    elif dtype_float32:
+        out_dtype = dpnp.float32
+    elif dpnp.issubdtype(dtype, dpnp.complexfloating):
+        out_dtype = dpnp.complex64
+        if has_support_aspect64() and dtype != dpnp.complex64:
+            out_dtype = dpnp.complex128
+    else:
+        out_dtype = dpnp.float32
+        if has_support_aspect64() and dtype != dpnp.float32:
+            out_dtype = dpnp.float64
+
+    return out_dtype
+
+
 @pytest.mark.parametrize("deg", [True, False])
 class TestAngle:
     def test_angle_bool(self, deg):
@@ -2271,30 +2291,19 @@ def test_projection(self, dtype):
         assert dpnp.allclose(result, expected)
 
 
+@pytest.mark.parametrize("func", ["ceil", "floor", "trunc"])
 class TestRoundingFuncs:
-    @pytest.fixture(
-        params=[
-            {"func_name": "ceil", "input_values": [-5, 5, 10]},
-            {"func_name": "floor", "input_values": [-5, 5, 10]},
-            {"func_name": "trunc", "input_values": [-5, 5, 10]},
-        ],
-        ids=["ceil", "floor", "trunc"],
-    )
-    def func_params(self, request):
-        return request.param
-
     @pytest.mark.parametrize(
         "dtype", get_all_dtypes(no_none=True, no_complex=True)
     )
-    def test_out(self, func_params, dtype):
-        func_name = func_params["func_name"]
-        input_values = func_params["input_values"]
-        a, expected = _get_numpy_arrays_1in_1out(func_name, dtype, input_values)
+    def test_out(self, func, dtype):
+        a = generate_random_numpy_array(10, dtype)
+        expected = getattr(numpy, func)(a)
 
         ia = dpnp.array(a)
         out_dt = numpy.int8 if dtype == dpnp.bool else dtype
         iout = dpnp.empty(expected.shape, dtype=out_dt)
-        result = getattr(dpnp, func_name)(ia, out=iout)
+        result = getattr(dpnp, func)(ia, out=iout)
 
         assert result is iout
         # numpy.ceil, numpy.floor, numpy.trunc always return float dtype for
@@ -2310,34 +2319,35 @@ def test_out(self, func_params, dtype):
     @pytest.mark.parametrize(
         "dtype", get_all_dtypes(no_complex=True, no_none=True)[:-1]
     )
-    def test_invalid_dtype(self, func_params, dtype):
-        func_name = func_params["func_name"]
+    def test_invalid_dtype(self, func, dtype):
         dpnp_dtype = get_all_dtypes(no_complex=True, no_none=True)[-1]
         ia = dpnp.arange(10, dtype=dpnp_dtype)
         iout = dpnp.empty(10, dtype=dtype)
 
         with pytest.raises(ValueError):
-            getattr(dpnp, func_name)(ia, out=iout)
+            getattr(dpnp, func)(ia, out=iout)
 
     @pytest.mark.parametrize(
         "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15,)", "(2, 2)"]
     )
-    def test_invalid_shape(self, func_params, shape):
-        func_name = func_params["func_name"]
+    def test_invalid_shape(self, func, shape):
         ia = dpnp.arange(10, dtype=dpnp.float32)
         iout = dpnp.empty(shape, dtype=dpnp.float32)
-        assert_raises(ValueError, getattr(dpnp, func_name), ia, out=iout)
+
+        assert_raises(ValueError, getattr(dpnp, func), ia, out=iout)
 
 
 class TestHypot:
     @pytest.mark.parametrize(
         "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
     )
     def test_hypot(self, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out("hypot", dtype, [0, 10, 10])
+        a = generate_random_numpy_array(10, dtype, low=0)
+        b = generate_random_numpy_array(10, dtype, low=0)
+        expected = numpy.hypot(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
-        out_dt = _get_output_data_type(dtype)
+        out_dt = map_dtype_to_device(expected.dtype, ia.sycl_device)
         iout = dpnp.empty(expected.shape, dtype=out_dt)
         result = dpnp.hypot(ia, ib, out=iout)