Removed redundant overlap tests

Also rewrote overlap test for abs to only use a single dtype

Author: ndgrigorian

dpctl/tests/elementwise/test_abs.py

@@ -23,13 +23,7 @@
 import dpctl.tensor as dpt
 from dpctl.tests.helper import get_queue_or_skip, skip_if_dtype_not_supported
 
-from .utils import (
-    _all_dtypes,
-    _complex_fp_dtypes,
-    _no_complex_dtypes,
-    _real_fp_dtypes,
-    _usm_types,
-)
+from .utils import _all_dtypes, _complex_fp_dtypes, _real_fp_dtypes, _usm_types
 
 
 @pytest.mark.parametrize("dtype", _all_dtypes)
@@ -131,26 +125,21 @@ def test_abs_complex(dtype):
             )
 
 
-@pytest.mark.parametrize("dtype", _no_complex_dtypes)
-def test_abs_out_overlap(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    X = dpt.linspace(0, 35, 60, dtype=dtype, sycl_queue=q)
-    X = dpt.reshape(X, (3, 5, 4))
-
-    Xnp = dpt.asnumpy(X)
-    Ynp = np.abs(Xnp, out=Xnp)
+def test_abs_out_overlap():
+    get_queue_or_skip()
 
+    X = dpt.arange(-3, 3, 1, dtype="i4")
+    expected = dpt.asarray([3, 2, 1, 0, 1, 2], dtype="i4")
     Y = dpt.abs(X, out=X)
+
     assert Y is X
-    assert np.allclose(dpt.asnumpy(X), Xnp)
+    assert dpt.all(expected == X)
 
-    Ynp = np.abs(Xnp, out=Xnp[::-1])
+    X = dpt.arange(-3, 3, 1, dtype="i4")
+    expected = expected[::-1]
     Y = dpt.abs(X, out=X[::-1])
     assert Y is not X
-    assert np.allclose(dpt.asnumpy(X), Xnp)
-    assert np.allclose(dpt.asnumpy(Y), Ynp)
+    assert dpt.all(expected == X)
 
 
 @pytest.mark.parametrize("dtype", _real_fp_dtypes)

dpctl/tests/elementwise/test_exp.py

@@ -216,26 +216,3 @@ def test_exp_complex_special_cases(dtype):
     tol = 8 * dpt.finfo(dtype).resolution
     assert_allclose(dpt.asnumpy(dpt.real(Y)), np.real(Ynp), atol=tol, rtol=tol)
     assert_allclose(dpt.asnumpy(dpt.imag(Y)), np.imag(Ynp), atol=tol, rtol=tol)
-
-
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8", "c8", "c16"])
-def test_exp_out_overlap(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    X = dpt.linspace(0, 1, 15, dtype=dtype, sycl_queue=q)
-    X = dpt.reshape(X, (3, 5))
-
-    Xnp = dpt.asnumpy(X)
-    Ynp = np.exp(Xnp, out=Xnp)
-
-    Y = dpt.exp(X, out=X)
-    tol = 8 * dpt.finfo(Y.dtype).resolution
-    assert Y is X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-
-    Ynp = np.exp(Xnp, out=Xnp[::-1])
-    Y = dpt.exp(X, out=X[::-1])
-    assert Y is not X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-    assert_allclose(dpt.asnumpy(Y), Ynp, atol=tol, rtol=tol)

dpctl/tests/elementwise/test_hyperbolic.py

@@ -292,29 +292,3 @@ def test_hyper_complex_special_cases(np_call, dpt_call, dtype):
     assert_allclose(
         dpt.asnumpy(dpt.imag(dpt_call(Xc))), np.imag(Ynp), atol=tol, rtol=tol
     )
-
-
-@pytest.mark.parametrize("np_call, dpt_call", _all_funcs)
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8", "c8", "c16"])
-def test_hyper_out_overlap(np_call, dpt_call, dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    X = dpt.linspace(-np.pi / 2, np.pi / 2, 60, dtype=dtype, sycl_queue=q)
-    X = dpt.reshape(X, (3, 5, 4))
-
-    tol = 8 * dpt.finfo(dtype).resolution
-    Xnp = dpt.asnumpy(X)
-    with np.errstate(all="ignore"):
-        Ynp = np_call(Xnp, out=Xnp)
-
-    Y = dpt_call(X, out=X)
-    assert Y is X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-
-    with np.errstate(all="ignore"):
-        Ynp = np_call(Xnp, out=Xnp[::-1])
-    Y = dpt_call(X, out=X[::-1])
-    assert Y is not X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-    assert_allclose(dpt.asnumpy(Y), Ynp, atol=tol, rtol=tol)

dpctl/tests/elementwise/test_log.py

@@ -128,27 +128,3 @@ def test_log_special_cases():
     )
 
     assert_equal(dpt.asnumpy(Y), expected)
-
-
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8", "c8", "c16"])
-def test_log_out_overlap(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    X = dpt.linspace(5, 35, 60, dtype=dtype, sycl_queue=q)
-    X = dpt.reshape(X, (3, 5, 4))
-
-    Xnp = dpt.asnumpy(X)
-    Ynp = np.log(Xnp, out=Xnp)
-
-    Y = dpt.log(X, out=X)
-    assert Y is X
-
-    tol = 8 * dpt.finfo(Y.dtype).resolution
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-
-    Ynp = np.log(Xnp, out=Xnp[::-1])
-    Y = dpt.log(X, out=X[::-1])
-    assert Y is not X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-    assert_allclose(dpt.asnumpy(Y), Ynp, atol=tol, rtol=tol)

dpctl/tests/elementwise/test_round.py

@@ -213,26 +213,3 @@ def test_round_complex_special_cases(dtype):
     tol = 8 * dpt.finfo(dtype).resolution
     assert_allclose(dpt.asnumpy(dpt.real(Y)), np.real(Ynp), atol=tol, rtol=tol)
     assert_allclose(dpt.asnumpy(dpt.imag(Y)), np.imag(Ynp), atol=tol, rtol=tol)
-
-
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8", "c8", "c16"])
-def test_round_out_overlap(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    X = dpt.linspace(0, 1, 15, dtype=dtype, sycl_queue=q)
-    X = dpt.reshape(X, (3, 5))
-
-    Xnp = dpt.asnumpy(X)
-    Ynp = np.round(Xnp, out=Xnp)
-
-    Y = dpt.round(X, out=X)
-    tol = 8 * dpt.finfo(Y.dtype).resolution
-    assert Y is X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-
-    Ynp = np.round(Xnp, out=Xnp[::-1])
-    Y = dpt.round(X, out=X[::-1])
-    assert Y is not X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-    assert_allclose(dpt.asnumpy(Y), Ynp, atol=tol, rtol=tol)

dpctl/tests/elementwise/test_sqrt.py

@@ -122,30 +122,6 @@ def test_sqrt_order(dtype):
             assert_allclose(dpt.asnumpy(Y), expected_Y, atol=tol, rtol=tol)
 
 
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8", "c8", "c16"])
-def test_sqrt_out_overlap(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    X = dpt.linspace(0, 35, 60, dtype=dtype, sycl_queue=q)
-    X = dpt.reshape(X, (3, 5, 4))
-
-    Xnp = dpt.asnumpy(X)
-    Ynp = np.sqrt(Xnp, out=Xnp)
-
-    Y = dpt.sqrt(X, out=X)
-    assert Y is X
-
-    tol = 8 * dpt.finfo(Y.dtype).resolution
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-
-    Ynp = np.sqrt(Xnp, out=Xnp[::-1])
-    Y = dpt.sqrt(X, out=X[::-1])
-    assert Y is not X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-    assert_allclose(dpt.asnumpy(Y), Ynp, atol=tol, rtol=tol)
-
-
 @pytest.mark.usefixtures("suppress_invalid_numpy_warnings")
 def test_sqrt_special_cases():
     q = get_queue_or_skip()

dpctl/tests/elementwise/test_square.py

@@ -97,29 +97,3 @@ def test_square_special_cases(dtype):
             rtol=tol,
             equal_nan=True,
         )
-
-
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8", "c8", "c16"])
-def test_square_out_overlap(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    X = dpt.linspace(0, 35, 60, dtype=dtype, sycl_queue=q)
-    X = dpt.reshape(X, (3, 5, 4))
-
-    Xnp = dpt.asnumpy(X)
-    Ynp = np.square(Xnp, out=Xnp)
-
-    Y = dpt.square(X, out=X)
-    assert Y is X
-    assert np.allclose(dpt.asnumpy(X), Xnp)
-
-    X = dpt.linspace(0, 35, 60, dtype=dtype, sycl_queue=q)
-    X = dpt.reshape(X, (3, 5, 4))
-    Xnp = dpt.asnumpy(X)
-
-    Ynp = np.square(Xnp, out=Xnp[::-1])
-    Y = dpt.square(X, out=X[::-1])
-    assert Y is not X
-    assert np.allclose(dpt.asnumpy(X), Xnp)
-    assert np.allclose(dpt.asnumpy(Y), Ynp)

dpctl/tests/elementwise/test_trigonometric.py

@@ -289,35 +289,3 @@ def test_trig_complex_special_cases(np_call, dpt_call, dtype):
     assert_allclose(
         dpt.asnumpy(dpt.imag(dpt_call(Xc))), np.imag(Ynp), atol=tol, rtol=tol
     )
-
-
-@pytest.mark.parametrize("np_call, dpt_call", _all_funcs)
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8", "c8", "c16"])
-def test_trig_out_overlap(np_call, dpt_call, dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    if np_call == np.tan:
-        X = dpt.linspace(-np.pi / 2, np.pi / 2, 64, dtype=dtype, sycl_queue=q)[
-            2:-2
-        ]
-        tol = 50 * dpt.finfo(dtype).resolution
-    else:
-        X = dpt.linspace(-np.pi / 2, np.pi / 2, 60, dtype=dtype, sycl_queue=q)
-        tol = 8 * dpt.finfo(dtype).resolution
-    X = dpt.reshape(X, (3, 5, 4))
-
-    Xnp = dpt.asnumpy(X)
-    with np.errstate(all="ignore"):
-        Ynp = np_call(Xnp, out=Xnp)
-
-    Y = dpt_call(X, out=X)
-    assert Y is X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-
-    with np.errstate(all="ignore"):
-        Ynp = np_call(Xnp, out=Xnp[::-1])
-    Y = dpt_call(X, out=X[::-1])
-    assert Y is not X
-    assert_allclose(dpt.asnumpy(X), Xnp, atol=tol, rtol=tol)
-    assert_allclose(dpt.asnumpy(Y), Ynp, atol=tol, rtol=tol)