new-helper-func

Author: Vahid Tavanashad

dpnp/tests/helper.py

@@ -198,8 +198,6 @@ def get_all_dtypes(
     no_float16=True,
     no_complex=False,
     no_none=False,
-    xfail_dtypes=None,
-    exclude=None,
     no_unsigned=False,
     device=None,
 ):
@@ -227,17 +225,6 @@ def get_all_dtypes(
     if not no_none:
         dtypes.append(None)
 
-    def mark_xfail(dtype):
-        if xfail_dtypes is not None and dtype in xfail_dtypes:
-            return pytest.param(dtype, marks=pytest.mark.xfail)
-        return dtype
-
-    def not_excluded(dtype):
-        if exclude is None:
-            return True
-        return dtype not in exclude
-
-    dtypes = [mark_xfail(dtype) for dtype in dtypes if not_excluded(dtype)]
     return dtypes
 
 
@@ -312,6 +299,36 @@ def get_integer_dtypes(all_int_types=False, no_unsigned=False):
     return dtypes
 
 
+def get_integer_float_dtypes(
+    all_int_types=False,
+    no_unsigned=False,
+    no_float16=True,
+    device=None,
+    xfail_dtypes=None,
+    exclude=None,
+):
+    """
+    Build a list of integer and float types supported by DPNP.
+    """
+    dtypes = get_integer_dtypes(
+        all_int_types=all_int_types, no_unsigned=no_unsigned
+    )
+    dtypes += get_float_dtypes(no_float16=no_float16, device=device)
+
+    def mark_xfail(dtype):
+        if xfail_dtypes is not None and dtype in xfail_dtypes:
+            return pytest.param(dtype, marks=pytest.mark.xfail)
+        return dtype
+
+    def not_excluded(dtype):
+        if exclude is None:
+            return True
+        return dtype not in exclude
+
+    dtypes = [mark_xfail(dtype) for dtype in dtypes if not_excluded(dtype)]
+    return dtypes
+
+
 def has_support_aspect16(device=None):
     """
     Return True if the device supports 16-bit precision floating point operations,

dpnp/tests/test_binary_ufuncs.py

@@ -20,6 +20,7 @@
     get_float_complex_dtypes,
     get_float_dtypes,
     get_integer_dtypes,
+    get_integer_float_dtypes,
     has_support_aspect16,
     numpy_version,
 )
@@ -141,7 +142,7 @@ def test_invalid_out(self, xp, out):
 @pytest.mark.parametrize("func", ["fmax", "fmin", "maximum", "minimum"])
 class TestBoundFuncs:
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
-    def test_out(self, func, dtype):
+    def test_basic(self, func, dtype):
         a = generate_random_numpy_array(10, dtype)
         b = generate_random_numpy_array(10, dtype)
         expected = getattr(numpy, func)(a, b)
@@ -278,7 +279,7 @@ def test_invalid_out(self, xp, out):
 
 @pytest.mark.parametrize("func", ["floor_divide", "remainder"])
 class TestFloorDivideRemainder:
-    ALL_DTYPES = get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
+    ALL_DTYPES = get_integer_float_dtypes()
 
     def do_inplace_op(self, base, other, func):
         if func == "floor_divide":

dpnp/tests/test_histogram.py

@@ -25,9 +25,7 @@
 
 
 class TestDigitize:
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     @pytest.mark.parametrize("right", [True, False])
     @pytest.mark.parametrize(
         "x, bins",
@@ -73,12 +71,8 @@ def test_digitize_inf(self, dtype, right):
         expected = numpy.digitize(x, bins, right=right)
         assert_dtype_allclose(result, expected)
 
-    @pytest.mark.parametrize(
-        "dtype_x", get_all_dtypes(no_bool=True, no_complex=True)
-    )
-    @pytest.mark.parametrize(
-        "dtype_bins", get_all_dtypes(no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype_x", get_integer_float_dtypes())
+    @pytest.mark.parametrize("dtype_bins", get_integer_float_dtypes())
     @pytest.mark.parametrize("right", [True, False])
     def test_digitize_diff_types(self, dtype_x, dtype_bins, right):
         x = numpy.array([1, 2, 3, 4, 5], dtype=dtype_x)
@@ -90,9 +84,7 @@ def test_digitize_diff_types(self, dtype_x, dtype_bins, right):
         expected = numpy.digitize(x, bins, right=right)
         assert_dtype_allclose(result, expected)
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     @pytest.mark.parametrize(
         "x, bins",
         [

dpnp/tests/test_linalg.py

@@ -1409,9 +1409,7 @@ def test_einsum_tensor(self):
         result = dpnp.einsum("ijij->", tensor_dp)
         assert_dtype_allclose(result, expected)
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True, no_none=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     def test_different_paths(self, dtype):
         # Simple test, designed to exercise most specialized code paths,
         # note the +0.5 for floats.  This makes sure we use a float value

dpnp/tests/test_logic.py

@@ -83,7 +83,7 @@ def check_raises(func_name, exception, *args, **kwargs):
         check_raises(func, TypeError, [0, 1, 2, 3])
 
 
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("dtype", get_integer_float_dtypes())
 def test_allclose(dtype):
     a = numpy.random.rand(10)
     b = a + numpy.random.rand(10) * 1e-8
@@ -508,7 +508,7 @@ def test_infinity_sign_errors(func):
         getattr(dpnp, func)(x, out=out)
 
 
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("dtype", get_integer_float_dtypes())
 @pytest.mark.parametrize(
     "rtol", [1e-05, dpnp.array(1e-05), dpnp.full(10, 1e-05)]
 )
@@ -549,7 +549,7 @@ def test_array_equiv(a, b):
     assert_equal(result, expected)
 
 
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("dtype", get_integer_float_dtypes())
 def test_array_equiv_dtype(dtype):
     a = numpy.array([1, 2], dtype=dtype)
     b = numpy.array([1, 2], dtype=dtype)
@@ -575,7 +575,7 @@ def test_array_equiv_scalar(a):
     assert_equal(result, expected)
 
 
-@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("dtype", get_integer_float_dtypes())
 @pytest.mark.parametrize("equal_nan", [True, False])
 def test_array_equal_dtype(dtype, equal_nan):
     a = numpy.array([1, 2], dtype=dtype)

dpnp/tests/test_manipulation.py

@@ -20,6 +20,7 @@
     get_float_complex_dtypes,
     get_float_dtypes,
     get_integer_dtypes,
+    get_integer_float_dtypes,
     has_support_aspect64,
     numpy_version,
 )
@@ -325,9 +326,7 @@ class TestCopyTo:
     ]
     testdata += [
         ([1, -1, 0], dtype)
-        for dtype in get_all_dtypes(
-            no_none=True, no_bool=True, no_complex=True, no_unsigned=True
-        )
+        for dtype in get_integer_float_dtypes(no_unsigned=True)
     ]
     testdata += [([0.1, 0.0, -0.1], dtype) for dtype in get_float_dtypes()]
     testdata += [([1j, -1j, 1 - 2j], dtype) for dtype in get_complex_dtypes()]

dpnp/tests/test_mathematical.py

@@ -29,6 +29,7 @@
     get_float_complex_dtypes,
     get_float_dtypes,
     get_integer_dtypes,
+    get_integer_float_dtypes,
     has_support_aspect16,
     has_support_aspect64,
     numpy_version,
@@ -50,9 +51,7 @@ def test_angle_bool(self, deg):
         # determined by Type Promotion Rules.
         assert_dtype_allclose(result, expected, check_only_type_kind=True)
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     def test_angle(self, dtype, deg):
         ia = dpnp.arange(10, dtype=dtype)
         a = ia.asnumpy()
@@ -134,9 +133,7 @@ def test_mode(self):
 
 
 class TestClip:
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     @pytest.mark.parametrize("order", ["C", "F", "A", "K", None])
     def test_clip(self, dtype, order):
         ia = dpnp.asarray([[1, 2, 8], [1, 6, 4], [9, 5, 1]], dtype=dtype)
@@ -148,9 +145,7 @@ def test_clip(self, dtype, order):
         assert expected.flags.c_contiguous == result.flags.c_contiguous
         assert expected.flags.f_contiguous == result.flags.f_contiguous
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     def test_clip_arrays(self, dtype):
         ia = dpnp.asarray([1, 2, 8, 1, 6, 4, 1], dtype=dtype)
         a = dpnp.asnumpy(ia)
@@ -162,9 +157,7 @@ def test_clip_arrays(self, dtype):
         expected = numpy.clip(a, min_v.asnumpy(), max_v.asnumpy())
         assert_allclose(result, expected)
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     @pytest.mark.parametrize("in_dp", [dpnp, dpt])
     @pytest.mark.parametrize("out_dp", [dpnp, dpt])
     def test_clip_out(self, dtype, in_dp, out_dp):
@@ -302,9 +295,7 @@ def test_axis_tuple(self):
         a = dpnp.ones((3, 4))
         assert_raises(TypeError, dpnp.cumlogsumexp, a, axis=(0, 1))
 
-    @pytest.mark.parametrize(
-        "in_dt", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("in_dt", get_integer_float_dtypes())
     @pytest.mark.parametrize("dt", get_all_dtypes(no_bool=True))
     def test_dtype(self, in_dt, dt):
         a = dpnp.ones(100, dtype=in_dt)
@@ -1119,9 +1110,7 @@ def test_0d(self):
         na = a.asnumpy()
         assert_dtype_allclose(dpnp.i0(a), numpy.i0(na))
 
-    @pytest.mark.parametrize(
-        "dt", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dt", get_integer_float_dtypes())
     def test_1d(self, dt):
         a = numpy.array(
             [0.49842636, 0.6969809, 0.22011976, 0.0155549, 10.0], dtype=dt
@@ -1225,30 +1214,24 @@ def test_add(self, dtype, lhs, rhs):
     def test_arctan2(self, dtype, lhs, rhs):
         self._test_mathematical("arctan2", dtype, lhs, rhs)
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     def test_copysign(self, dtype, lhs, rhs):
         self._test_mathematical("copysign", dtype, lhs, rhs)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     def test_divide(self, dtype, lhs, rhs):
         self._test_mathematical("divide", dtype, lhs, rhs)
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     def test_fmax(self, dtype, lhs, rhs):
         self._test_mathematical("fmax", dtype, lhs, rhs, check_type=False)
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     def test_fmin(self, dtype, lhs, rhs):
         self._test_mathematical("fmin", dtype, lhs, rhs, check_type=False)
 
     @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
+        "dtype", get_all_dtypes(no_none=True, no_complex=True)
     )
     def test_fmod(self, dtype, lhs, rhs):
         if rhs == 0.3 and not has_support_aspect64():
@@ -1276,9 +1259,7 @@ def test_floor_divide(self, dtype, lhs, rhs):
             "floor_divide", dtype, lhs, rhs, check_type=False
         )
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     def test_hypot(self, dtype, lhs, rhs):
         self._test_mathematical("hypot", dtype, lhs, rhs)
 
@@ -1838,12 +1819,7 @@ def test_rand(self, dt):
         expected = numpy.unwrap(a)
         assert_dtype_allclose(result, expected)
 
-    @pytest.mark.parametrize(
-        "dt",
-        get_all_dtypes(
-            no_none=True, no_bool=True, no_complex=True, no_unsigned=True
-        ),
-    )
+    @pytest.mark.parametrize("dt", get_integer_float_dtypes(no_unsigned=True))
     def test_period(self, dt):
         a = numpy.array([1, 1 + 108], dtype=dt)
         ia = dpnp.array(a)
@@ -1853,12 +1829,7 @@ def test_period(self, dt):
         expected = numpy.unwrap(a, period=107)
         assert_array_equal(result, expected)
 
-    @pytest.mark.parametrize(
-        "dt",
-        get_all_dtypes(
-            no_none=True, no_bool=True, no_complex=True, no_unsigned=True
-        ),
-    )
+    @pytest.mark.parametrize("dt", get_integer_float_dtypes(no_unsigned=True))
     def test_rand_period(self, dt):
         a = generate_random_numpy_array(10, dt, low=-100, high=100)
         ia = dpnp.array(a)
@@ -2309,9 +2280,7 @@ def test_error(self, func):
 
 
 class TestHypot:
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_integer_float_dtypes())
     def test_hypot(self, dtype):
         a = generate_random_numpy_array(10, dtype, low=0)
         b = generate_random_numpy_array(10, dtype, low=0)
@@ -2376,9 +2345,7 @@ def test_basic(self, dtype, axis, keepdims):
 
         assert_dtype_allclose(res, exp)
 
-    @pytest.mark.parametrize(
-        "in_dt", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("in_dt", get_integer_float_dtypes())
     @pytest.mark.parametrize("dt", get_all_dtypes(no_bool=True))
     def test_dtype(self, in_dt, dt):
         a = dpnp.ones(100, dtype=in_dt)
@@ -2436,9 +2403,7 @@ def test_basic(self, dtype, axis, keepdims):
 
         assert_dtype_allclose(res, exp)
 
-    @pytest.mark.parametrize(
-        "in_dt", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("in_dtype", get_integer_float_dtypes())
     @pytest.mark.parametrize("dt", get_all_dtypes(no_bool=True))
     def test_dtype(self, in_dt, dt):
         a = dpnp.ones(99, dtype=in_dt)
@@ -2467,9 +2432,7 @@ def test_out(self, in_dt, out_dt):
         assert_allclose(result, exp, rtol=1e-06)
 
 
-@pytest.mark.parametrize(
-    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
-)
+@pytest.mark.parametrize("dtype", get_integer_float_dtypes())
 def test_inplace_remainder(dtype):
     size = 21
     a = numpy.arange(size, dtype=dtype)
@@ -2481,9 +2444,7 @@ def test_inplace_remainder(dtype):
     assert_allclose(ia, a)
 
 
-@pytest.mark.parametrize(
-    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
-)
+@pytest.mark.parametrize("dtype", get_integer_float_dtypes())
 def test_inplace_floor_divide(dtype):
     size = 21
     a = numpy.arange(size, dtype=dtype)