From e2ec12b254054144e158557d8300edd179d1109f Mon Sep 17 00:00:00 2001 From: Vahid Tavanashad Date: Fri, 14 Feb 2025 06:59:07 -0800 Subject: [PATCH 1/2] update test_sycl_queue.py --- dpnp/tests/test_sycl_queue.py | 1587 ++++++++------------------------- 1 file changed, 356 insertions(+), 1231 deletions(-) diff --git a/dpnp/tests/test_sycl_queue.py b/dpnp/tests/test_sycl_queue.py index eb3d01c86cdc..a6975d0373fb 100644 --- a/dpnp/tests/test_sycl_queue.py +++ b/dpnp/tests/test_sycl_queue.py @@ -6,37 +6,23 @@ import numpy import pytest from dpctl.utils import ExecutionPlacementError -from numpy.testing import assert_allclose, assert_array_equal, assert_raises +from numpy.testing import assert_array_equal, assert_raises import dpnp from dpnp.dpnp_array import dpnp_array from dpnp.dpnp_utils import get_usm_allocations -from .helper import ( - assert_dtype_allclose, - generate_random_numpy_array, - get_all_dtypes, - is_win_platform, -) +from .helper import generate_random_numpy_array, get_all_dtypes, is_win_platform -list_of_backend_str = [ - "cuda", - "host", - "level_zero", - "opencl", -] +list_of_backend_str = ["cuda", "host", "level_zero", "opencl"] -list_of_device_type_str = [ - "host", - "gpu", - "cpu", -] +list_of_device_type_str = ["host", "gpu", "cpu"] available_devices = [ d for d in dpctl.get_devices() if not getattr(d, "has_aspect_host", False) ] -valid_devices = [] +valid_dev = [] for device in available_devices: if device.default_selector_score < 0: pass @@ -48,7 +34,7 @@ # due to reported crash on Windows: CMPLRLLVM-55640 pass else: - valid_devices.append(device) + valid_dev.append(device) def assert_sycl_queue_equal(result, expected): @@ -61,37 +47,6 @@ def assert_sycl_queue_equal(result, expected): assert exec_queue is not None -def vvsort(val, vec, size, xp): - val_kwargs = {} - if hasattr(val, "sycl_queue"): - val_kwargs["sycl_queue"] = getattr(val, "sycl_queue", None) - - vec_kwargs = {} - if hasattr(vec, "sycl_queue"): - vec_kwargs["sycl_queue"] = getattr(vec, "sycl_queue", None) - - for i in range(size): - imax = i - for j in range(i + 1, size): - unravel_imax = numpy.unravel_index(imax, val.shape) - unravel_j = numpy.unravel_index(j, val.shape) - if xp.abs(val[unravel_imax]) < xp.abs(val[unravel_j]): - imax = j - - unravel_i = numpy.unravel_index(i, val.shape) - unravel_imax = numpy.unravel_index(imax, val.shape) - - # swap elements in val array - temp = xp.array(val[unravel_i], dtype=vec.dtype, **val_kwargs) - val[unravel_i] = val[unravel_imax] - val[unravel_imax] = temp - - # swap corresponding columns in vec matrix - temp = xp.array(vec[:, i], dtype=val.dtype, **vec_kwargs) - vec[:, i] = vec[:, imax] - vec[:, imax] = temp - - @pytest.mark.parametrize( "func, arg, kwargs", [ @@ -119,42 +74,28 @@ def vvsort(val, vec, size, xp): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_array_creation(func, arg, kwargs, device): dpnp_kwargs = dict(kwargs) dpnp_kwargs["device"] = device - dpnp_array = getattr(dpnp, func)(*arg, **dpnp_kwargs) - - numpy_kwargs = dict(kwargs) - numpy_kwargs["dtype"] = dpnp_array.dtype - numpy_array = getattr(numpy, func)(*arg, **numpy_kwargs) - - assert_dtype_allclose(dpnp_array, numpy_array) - assert dpnp_array.sycl_device == device + x = getattr(dpnp, func)(*arg, **dpnp_kwargs) + assert x.sycl_device == device @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_empty(device): - dpnp_array = dpnp.empty((2, 2), device=device) - assert dpnp_array.sycl_device == device + x = dpnp.empty((2, 2), device=device) + assert x.sycl_device == device @pytest.mark.parametrize( - "device_x", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_x", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( - "device_y", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_y", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_empty_like(device_x, device_y): x = dpnp.array([1, 2, 3], device=device_x) @@ -186,20 +127,12 @@ def test_empty_like(device_x, device_y): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_array_creation_follow_device(func, args, kwargs, device): - x_orig = numpy.array([1, 2, 3, 4]) - numpy_args = [eval(val, {"x0": x_orig}) for val in args] - y_orig = getattr(numpy, func)(*numpy_args, **kwargs) - x = dpnp.array([1, 2, 3, 4], device=device) dpnp_args = [eval(val, {"x0": x}) for val in args] - y = getattr(dpnp, func)(*dpnp_args, **kwargs) - assert_allclose(y_orig, y, rtol=1e-04) assert_sycl_queue_equal(y.sycl_queue, x.sycl_queue) @@ -208,18 +141,11 @@ def test_array_creation_follow_device(func, args, kwargs, device): reason="numpy.logspace supports a non-scalar base argument since 1.25.0", ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_array_creation_follow_device_logspace_base(device): - x_orig = numpy.array([1, 2, 3, 4]) - y_orig = numpy.logspace(0, 8, 4, base=x_orig[1:3]) - x = dpnp.array([1, 2, 3, 4], device=device) y = dpnp.logspace(0, 8, 4, base=x[1:3]) - - assert_allclose(y_orig, y, rtol=1e-04) assert_sycl_queue_equal(y.sycl_queue, x.sycl_queue) @@ -231,20 +157,12 @@ def test_array_creation_follow_device_logspace_base(device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_array_creation_follow_device_2d_array(func, args, kwargs, device): - x_orig = numpy.arange(9).reshape(3, 3) - numpy_args = [eval(val, {"x0": x_orig}) for val in args] - y_orig = getattr(numpy, func)(*numpy_args, **kwargs) - x = dpnp.arange(9, device=device).reshape(3, 3) dpnp_args = [eval(val, {"x0": x}) for val in args] - y = getattr(dpnp, func)(*dpnp_args, **kwargs) - assert_allclose(y_orig, y) assert_sycl_queue_equal(y.sycl_queue, x.sycl_queue) @@ -263,23 +181,15 @@ def test_array_creation_follow_device_2d_array(func, args, kwargs, device): ], ) @pytest.mark.parametrize( - "device_x", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_x", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( - "device_y", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_y", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_array_creation_cross_device(func, args, kwargs, device_x, device_y): if func == "linspace" and is_win_platform(): pytest.skip("CPU driver experiences an instability on Windows.") - x_orig = numpy.array([1, 2, 3, 4]) - numpy_args = [eval(val, {"x0": x_orig}) for val in args] - y_orig = getattr(numpy, func)(*numpy_args, **kwargs) - x = dpnp.array([1, 2, 3, 4], device=device_x) dpnp_args = [eval(val, {"x0": x}) for val in args] @@ -289,7 +199,6 @@ def test_array_creation_cross_device(func, args, kwargs, device_x, device_y): dpnp_kwargs["device"] = device_y y = getattr(dpnp, func)(*dpnp_args, **dpnp_kwargs) - assert_allclose(y_orig, y) assert_sycl_queue_equal(y.sycl_queue, x.to_device(device_y).sycl_queue) @@ -302,14 +211,10 @@ def test_array_creation_cross_device(func, args, kwargs, device_x, device_y): ], ) @pytest.mark.parametrize( - "device_x", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_x", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( - "device_y", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_y", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_array_creation_cross_device_2d_array( func, args, kwargs, device_x, device_y @@ -317,10 +222,6 @@ def test_array_creation_cross_device_2d_array( if func == "linspace" and is_win_platform(): pytest.skip("CPU driver experiences an instability on Windows.") - x_orig = numpy.arange(9).reshape(3, 3) - numpy_args = [eval(val, {"x0": x_orig}) for val in args] - y_orig = getattr(numpy, func)(*numpy_args, **kwargs) - x = dpnp.arange(9, device=device_x).reshape(3, 3) dpnp_args = [eval(val, {"x0": x}) for val in args] @@ -330,15 +231,12 @@ def test_array_creation_cross_device_2d_array( dpnp_kwargs["device"] = device_y y = getattr(dpnp, func)(*dpnp_args, **dpnp_kwargs) - assert_allclose(y_orig, y) assert_sycl_queue_equal(y.sycl_queue, x.to_device(device_y).sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_array_creation_from_file(device): with tempfile.TemporaryFile() as fh: @@ -346,19 +244,13 @@ def test_array_creation_from_file(device): fh.flush() fh.seek(0) - numpy_array = numpy.fromfile(fh) - - fh.seek(0) - dpnp_array = dpnp.fromfile(fh, device=device) + x = dpnp.fromfile(fh, device=device) - assert_dtype_allclose(dpnp_array, numpy_array) - assert dpnp_array.sycl_device == device + assert x.sycl_device == device @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_array_creation_load_txt(device): with tempfile.TemporaryFile() as fh: @@ -366,28 +258,19 @@ def test_array_creation_load_txt(device): fh.flush() fh.seek(0) - numpy_array = numpy.loadtxt(fh) + x = dpnp.loadtxt(fh, device=device) - fh.seek(0) - dpnp_array = dpnp.loadtxt(fh, device=device) - - assert_dtype_allclose(dpnp_array, numpy_array) - assert dpnp_array.sycl_device == device + assert x.sycl_device == device @pytest.mark.parametrize( - "device_x", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_x", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( - "device_y", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_y", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_copy_method(device_x, device_y): x = dpnp.array([[1, 2, 3], [4, 5, 6]], device=device_x) - y = x.copy() assert_sycl_queue_equal(y.sycl_queue, x.sycl_queue) @@ -397,21 +280,16 @@ def test_copy_method(device_x, device_y): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_copy_operation(device): x = dpnp.array([[1, 2, 3], [4, 5, 6]], device=device) - y = copy.copy(x) assert_sycl_queue_equal(y.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_extract(device): x = dpnp.arange(3, device=device) @@ -423,9 +301,7 @@ def test_extract(device): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_meshgrid(device): x = dpnp.arange(100, device=device) @@ -435,7 +311,6 @@ def test_meshgrid(device): assert_sycl_queue_equal(z[1].sycl_queue, y.sycl_queue) -@pytest.mark.usefixtures("allow_fall_back_on_numpy") @pytest.mark.parametrize( "func,data", [ @@ -465,11 +340,12 @@ def test_meshgrid(device): pytest.param("cosh", [-5.0, -3.5, 0.0, 3.5, 5.0]), pytest.param("cov", [[0, 1, 2], [2, 1, 0]]), pytest.param("count_nonzero", [3, 0, 2, -1.2]), + pytest.param("cumlogsumexp", [[1, 2, 3], [4, 5, 6]]), pytest.param("cumprod", [[1, 2, 3], [4, 5, 6]]), pytest.param("cumsum", [[1, 2, 3], [4, 5, 6]]), pytest.param("cumulative_prod", [1, 2, 3, 4, 5, 6]), pytest.param("cumulative_sum", [1, 2, 3, 4, 5, 6]), - pytest.param("degrees", [numpy.pi, numpy.pi / 2, 0]), + pytest.param("degrees", [dpnp.pi, dpnp.pi / 2, 0]), pytest.param("diagonal", [[[1, 2], [3, 4]]]), pytest.param("diff", [1.0, 2.0, 4.0, 7.0, 0.0]), pytest.param("ediff1d", [1.0, 2.0, 4.0, 7.0, 0.0]), @@ -492,6 +368,7 @@ def test_meshgrid(device): pytest.param("log10", [1.0, 2.0, 4.0, 7.0]), pytest.param("log1p", [1.0e-10, 1.0, 2.0, 4.0, 7.0]), pytest.param("log2", [1.0, 2.0, 4.0, 7.0]), + pytest.param("logsumexp", [1.0, 2.0, 4.0, 7.0]), pytest.param("max", [1.0, 2.0, 4.0, 7.0]), pytest.param("mean", [1.0, 2.0, 4.0, 7.0]), pytest.param("median", [1.0, 2.0, 4.0, 7.0]), @@ -511,6 +388,10 @@ def test_meshgrid(device): pytest.param("negative", [1.0, 0.0, -1.0]), pytest.param("positive", [1.0, 0.0, -1.0]), pytest.param("prod", [1.0, 2.0]), + pytest.param( + "proj", + [complex(1, 2), complex(dpnp.inf, -1), complex(0, -dpnp.inf)], + ), pytest.param("ptp", [1.0, 2.0, 4.0, 7.0]), pytest.param("radians", [180, 90, 45, 0]), pytest.param( @@ -518,7 +399,9 @@ def test_meshgrid(device): ), pytest.param("real_if_close", [2.1 + 4e-15j, 5.2 + 3e-16j]), pytest.param("reciprocal", [1.0, 2.0, 4.0, 7.0]), + pytest.param("reduce_hypot", [1.0, 2.0, 4.0, 7.0]), pytest.param("rot90", [[1, 2], [3, 4]]), + pytest.param("rsqrt", [1.0, 8.0, 27.0]), pytest.param("sign", [-5.0, 0.0, 4.5]), pytest.param("signbit", [-5.0, 0.0, 4.5]), pytest.param( @@ -548,165 +431,20 @@ def test_meshgrid(device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_1in_1out(func, data, device): x = dpnp.array(data, device=device) result = getattr(dpnp, func)(x) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) - if ( - func == "trapezoid" - and numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0" - ): - # `trapezoid` is available from NumPy 2.0 - func = "trapz" - - if ( - func in ["cumulative_prod", "cumulative_sum"] - and numpy.lib.NumpyVersion(numpy.__version__) < "2.1.0" - ): - pytest.skip( - "cumulative_prod and cumulative_sum are available from NumPy 2.1" - ) - - x_orig = dpnp.asnumpy(x) - expected = getattr(numpy, func)(x_orig) - assert_dtype_allclose(result, expected) - - expected_queue = x.sycl_queue - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, expected_queue) - - -@pytest.mark.parametrize( - "op", - [ - "all", - "any", - "isfinite", - "isinf", - "isnan", - "isneginf", - "isposinf", - "logical_not", - ], -) -@pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], -) -def test_logic_op_1in(op, device): - x = dpnp.array( - [-dpnp.inf, -1.0, 0.0, 1.0, dpnp.inf, dpnp.nan], device=device - ) - result = getattr(dpnp, op)(x) - - x_orig = dpnp.asnumpy(x) - expected = getattr(numpy, op)(x_orig) - assert_dtype_allclose(result, expected) - - expected_queue = x.sycl_queue - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, expected_queue) - - -@pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], -) -def test_proj(device): - X = [ - complex(1, 2), - complex(dpnp.inf, -1), - complex(0, -dpnp.inf), - complex(-dpnp.inf, dpnp.nan), - ] - Y = [ - complex(1, 2), - complex(dpnp.inf, -0.0), - complex(dpnp.inf, -0.0), - complex(dpnp.inf, 0.0), - ] - - x = dpnp.array(X, device=device) - result = dpnp.proj(x) - expected = dpnp.array(Y) - assert_allclose(result, expected) - - expected_queue = x.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) - - -@pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], -) -def test_rsqrt(device): - X = [1.0, 8.0, 27.0] - x = dpnp.array(X, device=device) - result = dpnp.rsqrt(x) - expected = 1 / numpy.sqrt(x.asnumpy()) - assert_allclose(result, expected) - - expected_queue = x.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) - - -@pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], -) -def test_logsumexp(device): - x = dpnp.arange(10, device=device) - result = dpnp.logsumexp(x) - expected = numpy.logaddexp.reduce(x.asnumpy()) - assert_dtype_allclose(result, expected) - - expected_queue = x.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) - - -@pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], -) -def test_cumlogsumexp(device): - x = dpnp.arange(10, device=device) - result = dpnp.cumlogsumexp(x) - expected = numpy.logaddexp.accumulate(x.asnumpy()) - assert_dtype_allclose(result, expected) - - expected_queue = x.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) - - -@pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], -) -def test_reduce_hypot(device): - x = dpnp.arange(10, device=device) - result = dpnp.reduce_hypot(x) - expected = numpy.hypot.reduce(x.asnumpy()) - assert_dtype_allclose(result, expected) - - expected_queue = x.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + out = dpnp.empty_like(result) + try: + # some functions do not support out kwarg + getattr(dpnp, func)(x, out=out) + assert_sycl_queue_equal(out.sycl_queue, x.sycl_queue) + except TypeError: + pass @pytest.mark.parametrize( @@ -835,30 +573,48 @@ def test_reduce_hypot(device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_2in_1out(func, data1, data2, device): x1 = dpnp.array(data1, device=device) x2 = dpnp.array(data2, device=device) result = getattr(dpnp, func)(x1, x2) - if ( - func == "trapezoid" - and numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0" - ): - # `trapezoid` is available from NumPy 2.0 - func = "trapz" + assert_sycl_queue_equal(result.sycl_queue, x1.sycl_queue) + assert_sycl_queue_equal(result.sycl_queue, x2.sycl_queue) - x1_orig = numpy.array(data1) - x2_orig = numpy.array(data2) - expected = getattr(numpy, func)(x1_orig, x2_orig) + out = dpnp.empty_like(result) + try: + # some function do not support out kwarg + getattr(dpnp, func)(x1, x2, out=out) + assert_sycl_queue_equal(out.sycl_queue, x1.sycl_queue) + assert_sycl_queue_equal(out.sycl_queue, x2.sycl_queue) + except TypeError: + pass - assert_dtype_allclose(result, expected) - assert_sycl_queue_equal(result.sycl_queue, x1.sycl_queue) - assert_sycl_queue_equal(result.sycl_queue, x2.sycl_queue) +@pytest.mark.parametrize( + "op", + [ + "all", + "any", + "isfinite", + "isinf", + "isnan", + "isneginf", + "isposinf", + "logical_not", + ], +) +@pytest.mark.parametrize( + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] +) +def test_logic_op_1in(op, device): + x = dpnp.array( + [-dpnp.inf, -1.0, 0.0, 1.0, dpnp.inf, dpnp.nan], device=device + ) + result = getattr(dpnp, op)(x) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( @@ -879,9 +635,7 @@ def test_2in_1out(func, data1, data2, device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_logic_op_2in(op, device): x1 = dpnp.array( @@ -901,12 +655,6 @@ def test_logic_op_2in(op, device): x2 = x2[:-1] result = getattr(dpnp, op)(x1, x2) - x1_orig = dpnp.asnumpy(x1) - x2_orig = dpnp.asnumpy(x2) - expected = getattr(numpy, op)(x1_orig, x2_orig) - - assert_dtype_allclose(result, expected) - assert_sycl_queue_equal(result.sycl_queue, x1.sycl_queue) assert_sycl_queue_equal(result.sycl_queue, x2.sycl_queue) @@ -918,18 +666,12 @@ def test_logic_op_2in(op, device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_2in_with_scalar_1out(func, data, scalar, device): - x1_orig = numpy.array(data) - expected = getattr(numpy, func)(x1_orig, scalar) - x1 = dpnp.array(data, device=device) result = getattr(dpnp, func)(x1, scalar) - assert_allclose(result, expected) assert_sycl_queue_equal(result.sycl_queue, x1.sycl_queue) @@ -958,25 +700,14 @@ def test_2in_with_scalar_1out(func, data, scalar, device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) -def test_broadcasting(func, data1, data2, device): - x1_orig = numpy.array(data1) - x2_orig = numpy.array(data2) - expected = getattr(numpy, func)(x1_orig, x2_orig) - +def test_2in_broadcasting(func, data1, data2, device): x1 = dpnp.array(data1, device=device) x2 = dpnp.array(data2, device=device) result = getattr(dpnp, func)(x1, x2) - assert_array_equal(result, expected) - - expected_queue = x1.sycl_queue - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, expected_queue) + assert_sycl_queue_equal(result.sycl_queue, x1.sycl_queue) @pytest.mark.parametrize( @@ -997,9 +728,7 @@ def test_broadcasting(func, data1, data2, device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_2in_1out_diff_queue_but_equal_context(func, device): x1 = dpnp.arange(10) @@ -1009,9 +738,7 @@ def test_2in_1out_diff_queue_but_equal_context(func, device): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( "shape1, shape2", @@ -1049,9 +776,7 @@ def test_matmul(device, shape1, shape2): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( "shape1, shape2", @@ -1074,9 +799,7 @@ def test_matvec(device, shape1, shape2): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( "shape1, shape2", @@ -1099,9 +822,7 @@ def test_vecdot(device, shape1, shape2): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( "shape1, shape2", @@ -1148,9 +869,7 @@ def test_vecmat(device, shape1, shape2): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize("usm_type", ["host", "device", "shared"]) def test_random(func, args, kwargs, device, usm_type): @@ -1193,9 +912,7 @@ def test_random(func, args, kwargs, device, usm_type): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize("usm_type", ["host", "device", "shared"]) def test_random_state(func, args, kwargs, device, usm_type): @@ -1220,210 +937,66 @@ def test_random_state(func, args, kwargs, device, usm_type): assert_sycl_queue_equal(res_array.sycl_queue, sycl_queue) -@pytest.mark.usefixtures("allow_fall_back_on_numpy") -@pytest.mark.parametrize( - "func,data", - [ - pytest.param("sqrt", [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), - ], -) -@pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], -) -def test_out_1in_1out(func, data, device): - x_orig = numpy.array(data) - np_out = getattr(numpy, func)(x_orig) - expected = numpy.empty_like(np_out) - getattr(numpy, func)(x_orig, out=expected) - - x = dpnp.array(data, device=device) - dp_out = getattr(dpnp, func)(x) - result = dpnp.empty_like(dp_out) - getattr(dpnp, func)(x, out=result) - - assert_allclose(result, expected) - - assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) - - -@pytest.mark.usefixtures("allow_fall_back_on_numpy") -@pytest.mark.parametrize( - "func,data1,data2", - [ - pytest.param( - "add", - [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], - [0.0, 1.0, 2.0, 0.0, 1.0, 2.0, 0.0, 1.0, 2.0], - ), - pytest.param("copysign", [0.0, 1.0, 2.0], [-1.0, 0.0, 1.0]), - pytest.param( - "divide", [0.0, 1.0, 2.0, 3.0, 4.0], [4.0, 4.0, 4.0, 4.0, 4.0] - ), - # dpnp.dot has 3 different implementations based on input arrays dtype - # checking all of them - pytest.param("dot", [3.0, 4.0, 5.0], [1.0, 2.0, 3.0]), - pytest.param("dot", [3, 4, 5], [1, 2, 3]), - pytest.param("dot", [3 + 2j, 4 + 1j, 5], [1, 2 + 3j, 3]), - pytest.param( - "floor_divide", [1.0, 2.0, 3.0, 4.0], [2.5, 2.5, 2.5, 2.5] - ), - pytest.param( - "fmod", - [-3.0, -2.0, -1.0, 1.0, 2.0, 3.0], - [2.0, 2.0, 2.0, 2.0, 2.0, 2.0], - ), - pytest.param("maximum", [2.0, 3.0, 4.0], [1.0, 5.0, 2.0]), - pytest.param("minimum", [2.0, 3.0, 4.0], [1.0, 5.0, 2.0]), - pytest.param( - "multiply", - [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], - [0.0, 1.0, 2.0, 0.0, 1.0, 2.0, 0.0, 1.0, 2.0], - ), - pytest.param( - "power", - [0.0, 1.0, 2.0, 3.0, 4.0, 5.0], - [1.0, 2.0, 3.0, 3.0, 2.0, 1.0], - ), - pytest.param( - "remainder", - [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], - [5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0], - ), - pytest.param( - "subtract", - [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], - [0.0, 1.0, 2.0, 0.0, 1.0, 2.0, 0.0, 1.0, 2.0], - ), - ], -) -@pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], -) -def test_out_2in_1out(func, data1, data2, device): - x1_orig = numpy.array(data1) - x2_orig = numpy.array(data2) - np_out = getattr(numpy, func)(x1_orig, x2_orig) - expected = numpy.empty_like(np_out) - getattr(numpy, func)(x1_orig, x2_orig, out=expected) - - x1 = dpnp.array(data1, device=device) - x2 = dpnp.array(data2, device=device) - dp_out = getattr(dpnp, func)(x1, x2) - result = dpnp.empty_like(dp_out) - getattr(dpnp, func)(x1, x2, out=result) - - assert_allclose(result, expected) - - assert_sycl_queue_equal(result.sycl_queue, x1.sycl_queue) - assert_sycl_queue_equal(result.sycl_queue, x2.sycl_queue) - - @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_modf(device): - data = [0, 3.5] - - x_orig = numpy.array(data) - expected1, expected2 = numpy.modf(x_orig) - - x = dpnp.array(data, device=device) + x = dpnp.array([0, 3.5], device=device) result1, result2 = dpnp.modf(x) - assert_array_equal(result1, expected1) - assert_array_equal(result2, expected2) - expected_queue = x.sycl_queue - result1_queue = result1.sycl_queue - result2_queue = result2.sycl_queue - - assert_sycl_queue_equal(result1_queue, expected_queue) - assert_sycl_queue_equal(result2_queue, expected_queue) + assert_sycl_queue_equal(result1.sycl_queue, expected_queue) + assert_sycl_queue_equal(result2.sycl_queue, expected_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_multi_dot(device): - numpy_array_list = [] - dpnp_array_list = [] + array_list = [] for num_array in [3, 5]: # number of arrays in multi_dot - for _ in range(num_array): # creat arrays one by one - a = numpy.random.rand(10, 10) - b = dpnp.array(a, device=device) + for _ in range(num_array): # create arrays one by one + a = dpnp.random.rand(10, 10, device=device) + array_list.append(a) - numpy_array_list.append(a) - dpnp_array_list.append(b) - - result = dpnp.linalg.multi_dot(dpnp_array_list) - expected = numpy.linalg.multi_dot(numpy_array_list) - assert_dtype_allclose(result, expected) - - _, exec_q = get_usm_allocations(dpnp_array_list) + result = dpnp.linalg.multi_dot(array_list) + _, exec_q = get_usm_allocations(array_list) assert_sycl_queue_equal(result.sycl_queue, exec_q) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_einsum(device): - numpy_array_list = [] - dpnp_array_list = [] - for _ in range(3): # creat arrays one by one - a = numpy.random.rand(10, 10) - b = dpnp.array(a, device=device) - - numpy_array_list.append(a) - dpnp_array_list.append(b) + array_list = [] + for _ in range(3): # create arrays one by one + a = dpnp.random.rand(10, 10, device=device) + array_list.append(a) - result = dpnp.einsum("ij,jk,kl->il", *dpnp_array_list) - expected = numpy.einsum("ij,jk,kl->il", *numpy_array_list) - assert_dtype_allclose(result, expected) - - _, exec_q = get_usm_allocations(dpnp_array_list) + result = dpnp.einsum("ij,jk,kl->il", *array_list) + _, exec_q = get_usm_allocations(array_list) assert_sycl_queue_equal(result.sycl_queue, exec_q) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_out_multi_dot(device): - numpy_array_list = [] - dpnp_array_list = [] + array_list = [] for num_array in [3, 5]: # number of arrays in multi_dot - for _ in range(num_array): # creat arrays one by one - a = numpy.random.rand(10, 10) - b = dpnp.array(a, device=device) - - numpy_array_list.append(a) - dpnp_array_list.append(b) + for _ in range(num_array): # create arrays one by one + a = dpnp.random.rand(10, 10, device=device) + array_list.append(a) dp_out = dpnp.empty((10, 10), device=device) - result = dpnp.linalg.multi_dot(dpnp_array_list, out=dp_out) + result = dpnp.linalg.multi_dot(array_list, out=dp_out) assert result is dp_out - expected = numpy.linalg.multi_dot(numpy_array_list) - assert_dtype_allclose(result, expected) - - _, exec_q = get_usm_allocations(dpnp_array_list) + _, exec_q = get_usm_allocations(array_list) assert_sycl_queue_equal(result.sycl_queue, exec_q) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_pad(device): all_modes = [ @@ -1439,46 +1012,32 @@ def test_pad(device): "wrap", "empty", ] - dpnp_data = dpnp.arange(100, device=device) - expected_queue = dpnp_data.sycl_queue + x = dpnp.arange(100, device=device) for mode in all_modes: - result = dpnp.pad(dpnp_data, (25, 20), mode=mode) - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + result = dpnp.pad(x, (25, 20), mode=mode) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_require(device): - dpnp_data = dpnp.arange(10, device=device).reshape(2, 5) - result = dpnp.require(dpnp_data, dtype="f4", requirements=["F"]) - - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + x = dpnp.arange(10, device=device).reshape(2, 5) + result = dpnp.require(x, dtype="f4", requirements=["F"]) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) # No requirements - result = dpnp.require(dpnp_data, dtype="f4") - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + result = dpnp.require(x, dtype="f4") + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_resize(device): - dpnp_data = dpnp.arange(10, device=device) - result = dpnp.resize(dpnp_data, (2, 5)) - - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + x = dpnp.arange(10, device=device) + result = dpnp.resize(x, (2, 5)) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) class TestFft: @@ -1486,103 +1045,56 @@ class TestFft: "func", ["fft", "ifft", "rfft", "irfft", "hfft", "ihfft"] ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_fft(self, func, device): - dtype = numpy.float64 if func in ["rfft", "ihfft"] else numpy.complex128 - data = numpy.arange(20, dtype=dtype) - dpnp_data = dpnp.array(data, device=device) - - expected = getattr(numpy.fft, func)(data) - result = getattr(dpnp.fft, func)(dpnp_data) - assert_dtype_allclose(result, expected, factor=24) - - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + dtype = dpnp.float32 if func in ["rfft", "ihfft"] else dpnp.complex64 + x = dpnp.arange(20, dtype=dtype, device=device) + result = getattr(dpnp.fft, func)(x) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_fftn(self, device): - data = numpy.arange(24, dtype=numpy.complex64).reshape(2, 3, 4) - dpnp_data = dpnp.array(data, device=device) - - expected = numpy.fft.fftn(data) - result = dpnp.fft.fftn(dpnp_data) - assert_dtype_allclose(result, expected, check_only_type_kind=True) + x = dpnp.arange(24, dtype=dpnp.complex64, device=device) + x = x.reshape(2, 3, 4) - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + result = dpnp.fft.fftn(x) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) - expected = numpy.fft.ifftn(expected) result = dpnp.fft.ifftn(result) - assert_dtype_allclose(result, expected, check_only_type_kind=True) - - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_rfftn(self, device): - data = numpy.arange(24, dtype=numpy.float32).reshape(2, 3, 4) - dpnp_data = dpnp.array(data, device=device) + x = dpnp.arange(24, dtype=dpnp.float32, device=device) + x = x.reshape(2, 3, 4) - expected = numpy.fft.rfftn(data) - result = dpnp.fft.rfftn(dpnp_data) - assert_dtype_allclose(result, expected, check_only_type_kind=True) - - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + result = dpnp.fft.rfftn(x) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) - expected = numpy.fft.irfftn(expected) result = dpnp.fft.irfftn(result) - assert_dtype_allclose(result, expected, check_only_type_kind=True) - - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize("func", ["fftfreq", "rfftfreq"]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_fftfreq(self, func, device): result = getattr(dpnp.fft, func)(10, 0.5, device=device) - expected = getattr(numpy.fft, func)(10, 0.5) - - assert_dtype_allclose(result, expected) assert result.sycl_device == device @pytest.mark.parametrize("func", ["fftshift", "ifftshift"]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_fftshift(self, func, device): - dpnp_data = dpnp.fft.fftfreq(10, 0.5, device=device) - data = dpnp_data.asnumpy() - - expected = getattr(numpy.fft, func)(data) - result = getattr(dpnp.fft, func)(dpnp_data) - - assert_dtype_allclose(result, expected) - - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, expected_queue) + x = dpnp.fft.fftfreq(10, 0.5, device=device) + result = getattr(dpnp.fft, func)(x) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( @@ -1596,64 +1108,38 @@ def test_fftshift(self, func, device): ids=["2D", "3D", "Empty_2D", "Empty_3D"], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_cholesky(data, is_empty, device): if is_empty: - numpy_data = numpy.empty(data, dtype=dpnp.default_float_type(device)) + x = dpnp.empty(data, device=device) else: - numpy_data = numpy.array(data, dtype=dpnp.default_float_type(device)) - dpnp_data = dpnp.array(numpy_data, device=device) - - result = dpnp.linalg.cholesky(dpnp_data) - expected = numpy.linalg.cholesky(numpy_data) - assert_dtype_allclose(result, expected) - - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue + dtype = dpnp.default_float_type(device) + x = dpnp.array(data, dtype=dtype, device=device) - assert_sycl_queue_equal(result_queue, expected_queue) + result = dpnp.linalg.cholesky(x) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize("p", [None, -dpnp.inf, -2, -1, 1, 2, dpnp.inf, "fro"]) def test_cond(device, p): - a = generate_random_numpy_array((2, 4, 4), seed_value=42) + a = generate_random_numpy_array((2, 4, 4)) ia = dpnp.array(a, device=device) - result = dpnp.linalg.cond(ia, p=p) - expected = numpy.linalg.cond(a, p=p) - assert_dtype_allclose(result, expected) - - expected_queue = ia.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + assert_sycl_queue_equal(result.sycl_queue, ia.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_det(device): data = [[[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]]] - numpy_data = numpy.array(data) - dpnp_data = dpnp.array(data, device=device) - - result = dpnp.linalg.det(dpnp_data) - expected = numpy.linalg.det(numpy_data) - assert_allclose(expected, result) - - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, expected_queue) + x = dpnp.array(data, device=device) + result = dpnp.linalg.det(x) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( @@ -1683,9 +1169,7 @@ def test_det(device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_eigenvalue(func, shape, device): dtype = dpnp.default_float_type(device) @@ -1693,50 +1177,17 @@ def test_eigenvalue(func, shape, device): # get a symmetric array for eigh() and eigvalsh() or # non-symmetric for eig() and eigvals() is_hermitian = func in ("eigh, eigvalsh") - # Set seed_value=81 to prevent - # random generation of the input singular matrix - a = generate_random_numpy_array( - shape, dtype, hermitian=is_hermitian, seed_value=81, low=-5, high=5 - ) - dp_a = dpnp.array(a, device=device) - - expected_queue = dp_a.sycl_queue + a = generate_random_numpy_array(shape, dtype, hermitian=is_hermitian) + ia = dpnp.array(a, device=device) + expected_queue = ia.sycl_queue if func in ("eig", "eigh"): - dp_val, dp_vec = getattr(dpnp.linalg, func)(dp_a) - np_val, np_vec = getattr(numpy.linalg, func)(a) - - # Check the eigenvalue decomposition - if a.ndim == 2: - assert_allclose( - dp_a @ dp_vec, dp_vec @ dpnp.diag(dp_val), rtol=1e-5, atol=1e-5 - ) - else: # a.ndim == 3 - for i in range(a.shape[0]): - assert_allclose( - dp_a[i].dot(dp_vec[i]), - dp_val[i] * dp_vec[i], - rtol=1e-5, - atol=1e-5, - ) - assert dp_vec.shape == np_vec.shape - assert dp_vec.dtype == np_vec.dtype - - dpnp_vec_queue = dp_vec.sycl_queue - # compare queue and device - assert_sycl_queue_equal(dpnp_vec_queue, expected_queue) - + dp_val, dp_vec = getattr(dpnp.linalg, func)(ia) + assert_sycl_queue_equal(dp_vec.sycl_queue, expected_queue) else: # eighvals or eigvalsh - dp_val = getattr(dpnp.linalg, func)(dp_a) - np_val = getattr(numpy.linalg, func)(a) - - assert_allclose(dp_val, np_val, rtol=1e-05, atol=1e-05) - assert dp_val.shape == np_val.shape - assert dp_val.dtype == np_val.dtype + dp_val = getattr(dpnp.linalg, func)(ia) - dpnp_val_queue = dp_val.sycl_queue - # compare queue and device - assert_sycl_queue_equal(dpnp_val_queue, expected_queue) + assert_sycl_queue_equal(dp_val.sycl_queue, expected_queue) @pytest.mark.parametrize( @@ -1755,57 +1206,38 @@ def test_eigenvalue(func, shape, device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_inv(shape, is_empty, device): if is_empty: - numpy_x = numpy.empty(shape, dtype=dpnp.default_float_type(device)) + x = dpnp.empty(shape, device=device) else: + dtype = dpnp.default_float_type(device) count_elem = numpy.prod(shape) - numpy_x = numpy.arange( - 1, count_elem + 1, dtype=dpnp.default_float_type() - ).reshape(shape) - - dpnp_x = dpnp.array(numpy_x, device=device) - - result = dpnp.linalg.inv(dpnp_x) - expected = numpy.linalg.inv(numpy_x) - assert_dtype_allclose(result, expected) - - expected_queue = dpnp_x.sycl_queue - result_queue = result.sycl_queue + x = dpnp.arange(1, count_elem + 1, dtype=dtype, device=device).reshape( + shape + ) - assert_sycl_queue_equal(result_queue, expected_queue) + result = dpnp.linalg.inv(x) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize("n", [-1, 0, 1, 2, 3]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_matrix_power(n, device): - data = numpy.array([[1, 2], [3, 5]], dtype=dpnp.default_float_type(device)) - dp_data = dpnp.array(data, device=device) - - result = dpnp.linalg.matrix_power(dp_data, n) - expected = numpy.linalg.matrix_power(data, n) - assert_dtype_allclose(result, expected) - - expected_queue = dp_data.sycl_queue - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, expected_queue) + x = dpnp.array([[1.0, 2.0], [3.0, 5.0]], device=device) + result = dpnp.linalg.matrix_power(x, n) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( "data, tol", [ - (numpy.array([1, 2]), None), - (numpy.array([[1, 2], [3, 4]]), None), - (numpy.array([[1, 2], [3, 4]]), 1e-06), + ([1, 2], None), + ([[1, 2], [3, 4]], None), + ([[1, 2], [3, 4]], 1e-06), ], ids=[ "1-D array", @@ -1814,28 +1246,17 @@ def test_matrix_power(n, device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_matrix_rank(data, tol, device): - dp_data = dpnp.array(data, device=device) - - result = dpnp.linalg.matrix_rank(dp_data, tol=tol) - expected = numpy.linalg.matrix_rank(data, tol=tol) - assert_array_equal(expected, result) - - expected_queue = dp_data.sycl_queue - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, expected_queue) + x = dpnp.array(data, device=device) + result = dpnp.linalg.matrix_rank(x, tol=tol) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.usefixtures("suppress_divide_numpy_warnings") @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( "ord", [None, -dpnp.inf, -2, -1, 1, 2, 3, dpnp.inf, "fro", "nuc"] @@ -1846,8 +1267,7 @@ def test_matrix_rank(data, tol, device): ids=["-1", "0", "1", "(0, 1)", "(-2, -1)", "None"], ) def test_norm(device, ord, axis): - a = numpy.arange(120).reshape(2, 3, 4, 5) - ia = dpnp.array(a, device=device) + ia = dpnp.arange(120, device=device).reshape(2, 3, 4, 5) if (axis in [-1, 0, 1] and ord in ["nuc", "fro"]) or ( isinstance(axis, tuple) and ord == 3 ): @@ -1856,12 +1276,7 @@ def test_norm(device, ord, axis): pytest.skip("Improper number of dimensions to norm") else: result = dpnp.linalg.norm(ia, ord=ord, axis=axis) - expected = numpy.linalg.norm(a, ord=ord, axis=axis) - assert_dtype_allclose(result, expected) - - expected_queue = ia.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + assert_sycl_queue_equal(result.sycl_queue, ia.sycl_queue) @pytest.mark.parametrize( @@ -1881,15 +1296,9 @@ def test_norm(device, ord, axis): "(1, 0, 3)", ], ) +@pytest.mark.parametrize("mode", ["r", "raw", "complete", "reduced"]) @pytest.mark.parametrize( - "mode", - ["r", "raw", "complete", "reduced"], - ids=["r", "raw", "complete", "reduced"], -) -@pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_qr(shape, mode, device): dtype = dpnp.default_float_type(device) @@ -1904,21 +1313,15 @@ def test_qr(shape, mode, device): assert_sycl_queue_equal(dp_r_queue, expected_queue) else: dp_q, dp_r = dpnp.linalg.qr(a, mode=mode) - - dp_q_queue = dp_q.sycl_queue - dp_r_queue = dp_r.sycl_queue - - assert_sycl_queue_equal(dp_q_queue, expected_queue) - assert_sycl_queue_equal(dp_r_queue, expected_queue) + assert_sycl_queue_equal(dp_q.sycl_queue, expected_queue) + assert_sycl_queue_equal(dp_r.sycl_queue, expected_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) -@pytest.mark.parametrize("full_matrices", [True, False], ids=["True", "False"]) -@pytest.mark.parametrize("compute_uv", [True, False], ids=["True", "False"]) +@pytest.mark.parametrize("full_matrices", [True, False]) +@pytest.mark.parametrize("compute_uv", [True, False]) @pytest.mark.parametrize( "shape", [ @@ -1946,59 +1349,46 @@ def test_qr(shape, mode, device): ) def test_svd(shape, full_matrices, compute_uv, device): dtype = dpnp.default_float_type(device) - count_elems = numpy.prod(shape) - dpnp_data = dpnp.arange(count_elems, dtype=dtype, device=device).reshape( - shape - ) - expected_queue = dpnp_data.sycl_queue + x = dpnp.arange(count_elems, dtype=dtype, device=device).reshape(shape) + expected_queue = x.sycl_queue if compute_uv: dpnp_u, dpnp_s, dpnp_vt = dpnp.linalg.svd( - dpnp_data, full_matrices=full_matrices, compute_uv=compute_uv + x, full_matrices=full_matrices, compute_uv=compute_uv ) - dpnp_u_queue = dpnp_u.sycl_queue - dpnp_vt_queue = dpnp_vt.sycl_queue - dpnp_s_queue = dpnp_s.sycl_queue - - assert_sycl_queue_equal(dpnp_u_queue, expected_queue) - assert_sycl_queue_equal(dpnp_vt_queue, expected_queue) - assert_sycl_queue_equal(dpnp_s_queue, expected_queue) + assert_sycl_queue_equal(dpnp_u.sycl_queue, expected_queue) + assert_sycl_queue_equal(dpnp_vt.sycl_queue, expected_queue) + assert_sycl_queue_equal(dpnp_s.sycl_queue, expected_queue) else: dpnp_s = dpnp.linalg.svd( - dpnp_data, full_matrices=full_matrices, compute_uv=compute_uv + x, full_matrices=full_matrices, compute_uv=compute_uv ) - dpnp_s_queue = dpnp_s.sycl_queue - - assert_sycl_queue_equal(dpnp_s_queue, expected_queue) + assert_sycl_queue_equal(dpnp_s.sycl_queue, expected_queue) class TestToDevice: @pytest.mark.parametrize( - "device_from", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_from", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( - "device_to", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_to", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_basic(self, device_from, device_to): data = [1.0, 1.0, 1.0, 1.0, 1.0] x = dpnp.array(data, dtype=dpnp.float32, device=device_from) - y = x.to_device(device_to) + assert y.sycl_device == device_to assert (x.asnumpy() == y.asnumpy()).all() def test_to_queue(self): x = dpnp.full(100, 2, dtype=dpnp.int64) q_prof = dpctl.SyclQueue(x.sycl_device, property="enable_profiling") - y = x.to_device(q_prof) + assert (x.asnumpy() == y.asnumpy()).all() assert_sycl_queue_equal(y.sycl_queue, q_prof) @@ -2038,9 +1428,7 @@ def test_invalid_stream(self, stream): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( "func", @@ -2061,9 +1449,6 @@ def test_invalid_stream(self, stream): "queue_param", ["", "None", "sycl_queue"], ids=["Empty", "None", "queue"] ) def test_array_copy(device, func, device_param, queue_param): - if numpy.lib.NumpyVersion(numpy.__version__) >= "2.0.0": - pytest.skip("numpy.asfarray was removed") - data = numpy.ones(100) dpnp_data = getattr(dpnp, func)(data, device=device) @@ -2073,15 +1458,12 @@ def test_array_copy(device, func, device_param, queue_param): } result = dpnp.array(dpnp_data, **kwargs) - assert_sycl_queue_equal(result.sycl_queue, dpnp_data.sycl_queue) @pytest.mark.parametrize("copy", [True, False, None]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_array_creation_from_dpctl(copy, device): dpt_data = dpt.ones((3, 3), device=device) @@ -2093,9 +1475,7 @@ def test_array_creation_from_dpctl(copy, device): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize("arr_dtype", get_all_dtypes(no_float16=True)) @pytest.mark.parametrize("shape", [tuple(), (2,), (3, 0, 1), (2, 2, 2)]) @@ -2114,9 +1494,7 @@ def test_from_dlpack(arr_dtype, shape, device): @pytest.mark.usefixtures("suppress_invalid_numpy_warnings") @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize("arr_dtype", get_all_dtypes(no_float16=True)) def test_from_dlpack_with_dpt(arr_dtype, device): @@ -2130,9 +1508,7 @@ def test_from_dlpack_with_dpt(arr_dtype, device): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_broadcast_to(device): x = dpnp.arange(5, device=device) @@ -2152,20 +1528,13 @@ def test_broadcast_to(device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_concat_stack(func, data1, data2, device): - x1_orig = numpy.array(data1) - x2_orig = numpy.array(data2) - expected = getattr(numpy, func)((x1_orig, x2_orig)) - x1 = dpnp.array(data1, device=device) x2 = dpnp.array(data2, device=device) result = getattr(dpnp, func)((x1, x2)) - assert_allclose(result, expected) assert_sycl_queue_equal(result.sycl_queue, x1.sycl_queue) assert_sycl_queue_equal(result.sycl_queue, x2.sycl_queue) @@ -2177,9 +1546,7 @@ class TestDelete: ids=["slice", "scalar", "list"], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_delete(self, obj, device): x = dpnp.arange(5, device=device) @@ -2187,9 +1554,7 @@ def test_delete(self, obj, device): assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_obj_ndarray(self, device): x = dpnp.arange(5, device=device) @@ -2207,9 +1572,7 @@ class TestInsert: ids=["slice", "scalar", "list"], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_basic(self, obj, device): x = dpnp.arange(5, device=device) @@ -2222,9 +1585,7 @@ def test_basic(self, obj, device): ids=["slice", "scalar", "list"], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_values_ndarray(self, obj, device): x = dpnp.arange(5, device=device) @@ -2236,9 +1597,7 @@ def test_values_ndarray(self, obj, device): @pytest.mark.parametrize("values", [-2, [-1, -2]], ids=["scalar", "list"]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_obj_ndarray(self, values, device): x = dpnp.arange(5, device=device) @@ -2249,9 +1608,7 @@ def test_obj_ndarray(self, values, device): assert_sycl_queue_equal(result.sycl_queue, y.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_obj_values_ndarray(self, device): x = dpnp.arange(5, device=device) @@ -2278,55 +1635,38 @@ def test_obj_values_ndarray(self, device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_split(func, data1, device): - x1_orig = numpy.array(data1) x1 = dpnp.array(data1, device=device) - expected = getattr(numpy, func)(x1_orig, 2) result = getattr(dpnp, func)(x1, 2) - - assert_allclose(result[0], expected[0]) - assert_allclose(result[1], expected[1]) assert_sycl_queue_equal(result[0].sycl_queue, x1.sycl_queue) assert_sycl_queue_equal(result[1].sycl_queue, x1.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_apply_along_axis(device): x = dpnp.arange(9, device=device).reshape(3, 3) result = dpnp.apply_along_axis(dpnp.sum, 0, x) - assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_apply_over_axes(device): x = dpnp.arange(18, device=device).reshape(2, 3, 3) result = dpnp.apply_over_axes(dpnp.sum, x, [0, 1]) - assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device_x", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_x", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( - "device_y", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_y", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_asarray(device_x, device_y): x = dpnp.array([1, 2, 3], device=device_x) @@ -2335,9 +1675,7 @@ def test_asarray(device_x, device_y): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( "kwargs", @@ -2348,22 +1686,14 @@ def test_asarray(device_x, device_y): ], ) def test_diff_scalar_append(device, kwargs): - numpy_data = numpy.arange(7) - dpnp_data = dpnp.array(numpy_data, device=device) - - expected = numpy.diff(numpy_data, **kwargs) - result = dpnp.diff(dpnp_data, **kwargs) - assert_allclose(expected, result) + x = dpnp.arange(7, device=device) + result = dpnp.diff(x, **kwargs) - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_clip(device): x = dpnp.arange(10, device=device) @@ -2372,24 +1702,13 @@ def test_clip(device): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_take(device): - numpy_data = numpy.arange(5) - dpnp_data = dpnp.array(numpy_data, device=device) - - dpnp_ind = dpnp.array([0, 2, 4], device=device) - np_ind = dpnp_ind.asnumpy() - - result = dpnp.take(dpnp_data, dpnp_ind, axis=None) - expected = numpy.take(numpy_data, np_ind, axis=None) - assert_allclose(expected, result) - - expected_queue = dpnp_data.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + x = dpnp.arange(5, device=device) + ind = dpnp.array([0, 2, 4], device=device) + result = dpnp.take(x, ind, axis=None) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( @@ -2404,29 +1723,20 @@ def test_take(device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_take_along_axis(data, ind, axis, device): - dp_data = dpnp.array(data, device=device) - dp_ind = dpnp.array(ind, device=device) - - result = dpnp.take_along_axis(dp_data, dp_ind, axis=axis) - expected = numpy.take_along_axis(data, ind, axis=axis) - assert_allclose(expected, result) + x = dpnp.array(data, device=device) + ind = dpnp.array(ind, device=device) + result = dpnp.take_along_axis(x, ind, axis=axis) - expected_queue = dp_data.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) -@pytest.mark.parametrize("sparse", [True, False], ids=["True", "False"]) +@pytest.mark.parametrize("sparse", [True, False]) def test_indices(device, sparse): sycl_queue = dpctl.SyclQueue(device) grid = dpnp.indices((2, 3), sparse=sparse, sycl_queue=sycl_queue) @@ -2435,9 +1745,7 @@ def test_indices(device, sparse): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_nonzero(device): a = dpnp.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], device=device) @@ -2447,9 +1755,7 @@ def test_nonzero(device): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize("func", ["mgrid", "ogrid"]) def test_grid(device, func): @@ -2459,27 +1765,17 @@ def test_grid(device, func): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_where(device): - a = numpy.array([[0, 1, 2], [0, 2, 4], [0, 3, 6]]) - ia = dpnp.array(a, device=device) - + ia = dpnp.array([[0, 1, 2], [0, 2, 4], [0, 3, 6]], device=device) result = dpnp.where(ia < 4, ia, -1) - expected = numpy.where(a < 4, a, -1) - assert_allclose(expected, result) - expected_queue = ia.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + assert_sycl_queue_equal(result.sycl_queue, ia.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( "matrix, rhs", @@ -2504,20 +1800,12 @@ def test_where(device): ], ) def test_solve(matrix, rhs, device): - a_np = numpy.array(matrix) - b_np = numpy.array(rhs) + a = dpnp.array(matrix, device=device) + b = dpnp.array(rhs, device=device) + result = dpnp.linalg.solve(a, b) - a_dp = dpnp.array(a_np, device=device) - b_dp = dpnp.array(b_np, device=device) - - result = dpnp.linalg.solve(a_dp, b_dp) - expected = numpy.linalg.solve(a_np, b_np) - assert_dtype_allclose(result, expected) - - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, a_dp.sycl_queue) - assert_sycl_queue_equal(result_queue, b_dp.sycl_queue) + assert_sycl_queue_equal(result.sycl_queue, a.sycl_queue) + assert_sycl_queue_equal(result.sycl_queue, b.sycl_queue) @pytest.mark.parametrize( @@ -2536,31 +1824,22 @@ def test_solve(matrix, rhs, device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_slogdet(shape, is_empty, device): if is_empty: - numpy_x = numpy.empty(shape, dtype=dpnp.default_float_type(device)) + x = dpnp.empty(shape, device=device) else: + dtype = dpnp.default_float_type(device) count_elem = numpy.prod(shape) - numpy_x = numpy.arange( - 1, count_elem + 1, dtype=dpnp.default_float_type(device) - ).reshape(shape) - - dpnp_x = dpnp.array(numpy_x, device=device) - - sign_result, logdet_result = dpnp.linalg.slogdet(dpnp_x) - sign_expected, logdet_expected = numpy.linalg.slogdet(numpy_x) - assert_allclose(logdet_expected, logdet_result, rtol=1e-3, atol=1e-4) - assert_allclose(sign_expected, sign_result) + x = dpnp.arange(1, count_elem + 1, dtype=dtype, device=device).reshape( + shape + ) - sign_queue = sign_result.sycl_queue - logdet_queue = logdet_result.sycl_queue + sign_result, logdet_result = dpnp.linalg.slogdet(x) - assert_sycl_queue_equal(sign_queue, dpnp_x.sycl_queue) - assert_sycl_queue_equal(logdet_queue, dpnp_x.sycl_queue) + assert_sycl_queue_equal(sign_result.sycl_queue, x.sycl_queue) + assert_sycl_queue_equal(logdet_result.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( @@ -2589,83 +1868,44 @@ def test_slogdet(shape, is_empty, device): ], ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_pinv(shape, hermitian, rcond_as_array, device): dtype = dpnp.default_float_type(device) - # Set seed_value=81 to prevent - # random generation of the input singular matrix - a_np = generate_random_numpy_array( - shape, dtype, hermitian=hermitian, seed_value=81 - ) - a_dp = dpnp.array(a_np, device=device) + a = generate_random_numpy_array(shape, dtype, hermitian=hermitian) + ia = dpnp.array(a, device=device) if rcond_as_array: - rcond_np = numpy.array(1e-15) rcond_dp = dpnp.array(1e-15, device=device) - - B_result = dpnp.linalg.pinv(a_dp, rcond=rcond_dp, hermitian=hermitian) - B_expected = numpy.linalg.pinv( - a_np, rcond=rcond_np, hermitian=hermitian - ) - + result = dpnp.linalg.pinv(ia, rcond=rcond_dp, hermitian=hermitian) else: # rcond == 1e-15 by default - B_result = dpnp.linalg.pinv(a_dp, hermitian=hermitian) - B_expected = numpy.linalg.pinv(a_np, hermitian=hermitian) - - assert_allclose(B_expected, B_result, rtol=1e-3, atol=1e-4) - - B_queue = B_result.sycl_queue + result = dpnp.linalg.pinv(ia, hermitian=hermitian) - assert_sycl_queue_equal(B_queue, a_dp.sycl_queue) + assert_sycl_queue_equal(result.sycl_queue, ia.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_tensorinv(device): - a_np = numpy.eye(12).reshape(12, 4, 3) - a_dp = dpnp.array(a_np, device=device) - - result = dpnp.linalg.tensorinv(a_dp, ind=1) - expected = numpy.linalg.tensorinv(a_np, ind=1) - assert_dtype_allclose(result, expected) - - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, a_dp.sycl_queue) + a = dpnp.eye(12, device=device).reshape(12, 4, 3) + result = dpnp.linalg.tensorinv(a, ind=1) + assert_sycl_queue_equal(result.sycl_queue, a.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_tensorsolve(device): - a_np = numpy.random.randn(3, 2, 6).astype(dpnp.default_float_type()) - b_np = numpy.ones(a_np.shape[:2], dtype=a_np.dtype) - - a_dp = dpnp.array(a_np, device=device) - b_dp = dpnp.array(b_np, device=device) - - result = dpnp.linalg.tensorsolve(a_dp, b_dp) - expected = numpy.linalg.tensorsolve(a_np, b_np) - assert_dtype_allclose(result, expected) - - result_queue = result.sycl_queue - - assert_sycl_queue_equal(result_queue, a_dp.sycl_queue) + a = dpnp.random.randn(3, 2, 6, device=device) + b = dpnp.ones(a.shape[:2], device=device) + result = dpnp.linalg.tensorsolve(a, b) + assert_sycl_queue_equal(result.sycl_queue, a.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( ["m", "n", "nrhs"], @@ -2677,151 +1917,91 @@ def test_tensorsolve(device): ], ) def test_lstsq(m, n, nrhs, device): - a_np = numpy.arange(m * n).reshape(m, n).astype(dpnp.default_float_type()) - b_np = numpy.ones((m, nrhs)).astype(dpnp.default_float_type()) - - a_dp = dpnp.array(a_np, device=device) - b_dp = dpnp.array(b_np, device=device) - - result_dp = dpnp.linalg.lstsq(a_dp, b_dp) - # if rcond is not set, FutureWarning is given. - # By default Numpy uses None for calculations - result = numpy.linalg.lstsq(a_np, b_np, rcond=None) - - for param_dp, param_np in zip(result_dp, result): - assert_dtype_allclose(param_dp, param_np) + dtype = dpnp.default_float_type(device) + a = dpnp.arange(m * n, dtype=dtype, device=device) + a = a.reshape(m, n) + b = dpnp.ones((m, nrhs), device=device) + result = dpnp.linalg.lstsq(a, b) - for param_dp in result_dp: - assert_sycl_queue_equal(param_dp.sycl_queue, a_dp.sycl_queue) - assert_sycl_queue_equal(param_dp.sycl_queue, b_dp.sycl_queue) + for param in result: + param_queue = param.sycl_queue + assert_sycl_queue_equal(param_queue, a.sycl_queue) + assert_sycl_queue_equal(param_queue, b.sycl_queue) -@pytest.mark.parametrize("weights", [None, numpy.arange(7, 12)]) +@pytest.mark.parametrize("wgt", [None, numpy.arange(7, 12)]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) -def test_bincount(weights, device): - v = numpy.arange(5) - w = weights - - iv = dpnp.array(v, device=device) - iw = None if weights is None else dpnp.array(w, sycl_queue=iv.sycl_queue) - - expected_hist = numpy.bincount(v, weights=w) +def test_bincount(wgt, device): + iv = dpnp.arange(5, device=device) + iw = None if wgt is None else dpnp.array(wgt, sycl_queue=iv.sycl_queue) result_hist = dpnp.bincount(iv, weights=iw) - assert_array_equal(result_hist, expected_hist) - - hist_queue = result_hist.sycl_queue - assert_sycl_queue_equal(hist_queue, iv.sycl_queue) + assert_sycl_queue_equal(result_hist.sycl_queue, iv.sycl_queue) -@pytest.mark.parametrize("weights", [None, numpy.arange(7, 12)]) +@pytest.mark.parametrize("wgt", [None, numpy.arange(7, 12)]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) -def test_histogram(weights, device): - v = numpy.arange(5) - w = weights - - iv = dpnp.array(v, device=device) - iw = None if weights is None else dpnp.array(w, sycl_queue=iv.sycl_queue) - - expected_hist, expected_edges = numpy.histogram(v, weights=w) +def test_histogram(wgt, device): + iv = dpnp.arange(5, device=device) + iw = None if wgt is None else dpnp.array(wgt, sycl_queue=iv.sycl_queue) result_hist, result_edges = dpnp.histogram(iv, weights=iw) - assert_array_equal(result_hist, expected_hist) - assert_dtype_allclose(result_edges, expected_edges) - hist_queue = result_hist.sycl_queue - edges_queue = result_edges.sycl_queue - assert_sycl_queue_equal(hist_queue, iv.sycl_queue) - assert_sycl_queue_equal(edges_queue, iv.sycl_queue) + assert_sycl_queue_equal(result_hist.sycl_queue, iv.sycl_queue) + assert_sycl_queue_equal(result_edges.sycl_queue, iv.sycl_queue) -@pytest.mark.parametrize("weights", [None, numpy.arange(7, 12)]) +@pytest.mark.parametrize("wgt", [None, numpy.arange(7, 12)]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) -def test_histogram2d(weights, device): - x = numpy.arange(5) - y = numpy.arange(5) - w = weights - - ix = dpnp.array(x, device=device) - iy = dpnp.array(y, device=device) - iw = None if weights is None else dpnp.array(w, sycl_queue=ix.sycl_queue) - - expected_hist, expected_edges_x, expected_edges_y = numpy.histogram2d( - x, y, weights=w - ) +def test_histogram2d(wgt, device): + ix = dpnp.arange(5, device=device) + iy = dpnp.arange(5, device=device) + iw = None if wgt is None else dpnp.array(wgt, sycl_queue=ix.sycl_queue) result_hist, result_edges_x, result_edges_y = dpnp.histogram2d( ix, iy, weights=iw ) - assert_array_equal(result_hist, expected_hist) - assert_dtype_allclose(result_edges_x, expected_edges_x) - assert_dtype_allclose(result_edges_y, expected_edges_y) - hist_queue = result_hist.sycl_queue - edges_x_queue = result_edges_x.sycl_queue - edges_y_queue = result_edges_y.sycl_queue - assert_sycl_queue_equal(hist_queue, ix.sycl_queue) - assert_sycl_queue_equal(edges_x_queue, ix.sycl_queue) - assert_sycl_queue_equal(edges_y_queue, ix.sycl_queue) + assert_sycl_queue_equal(result_hist.sycl_queue, ix.sycl_queue) + assert_sycl_queue_equal(result_edges_x.sycl_queue, ix.sycl_queue) + assert_sycl_queue_equal(result_edges_y.sycl_queue, ix.sycl_queue) -@pytest.mark.parametrize("weights", [None, numpy.arange(7, 12)]) +@pytest.mark.parametrize("wgt", [None, numpy.arange(7, 12)]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) -def test_histogramdd(weights, device): - v = numpy.arange(5) - w = weights - - iv = dpnp.array(v, device=device) - iw = None if weights is None else dpnp.array(w, sycl_queue=iv.sycl_queue) - - expected_hist, expected_edges = numpy.histogramdd(v, weights=w) +def test_histogramdd(wgt, device): + iv = dpnp.arange(5, device=device) + iw = None if wgt is None else dpnp.array(wgt, sycl_queue=iv.sycl_queue) result_hist, result_edges = dpnp.histogramdd(iv, weights=iw) - assert_array_equal(result_hist, expected_hist) - for result_edge, expected_edge in zip(result_edges, expected_edges): - assert_dtype_allclose(result_edge, expected_edge) - hist_queue = result_hist.sycl_queue - assert_sycl_queue_equal(hist_queue, iv.sycl_queue) + assert_sycl_queue_equal(result_hist.sycl_queue, iv.sycl_queue) for edge in result_edges: - edges_queue = edge.sycl_queue - assert_sycl_queue_equal(edges_queue, iv.sycl_queue) + assert_sycl_queue_equal(edge.sycl_queue, iv.sycl_queue) @pytest.mark.parametrize( "func", ["tril_indices_from", "triu_indices_from", "diag_indices_from"] ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_tri_diag_indices_from(func, device): - arr = dpnp.ones((3, 3), device=device) - res = getattr(dpnp, func)(arr) + a = dpnp.ones((3, 3), device=device) + res = getattr(dpnp, func)(a) for x in res: - assert_sycl_queue_equal(x.sycl_queue, arr.sycl_queue) + assert_sycl_queue_equal(x.sycl_queue, a.sycl_queue) @pytest.mark.parametrize( "func", ["tril_indices", "triu_indices", "diag_indices"] ) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_tri_diag_indices(func, device): sycl_queue = dpctl.SyclQueue(device) @@ -2832,9 +2012,7 @@ def test_tri_diag_indices(func, device): @pytest.mark.parametrize("mask_func", ["tril", "triu"]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_mask_indices(mask_func, device): sycl_queue = dpctl.SyclQueue(device) @@ -2843,50 +2021,35 @@ def test_mask_indices(mask_func, device): assert_sycl_queue_equal(x.sycl_queue, sycl_queue) -@pytest.mark.parametrize("weights", [None, numpy.arange(7, 12)]) +@pytest.mark.parametrize("wgt", [None, numpy.arange(7, 12)]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) -def test_histogram_bin_edges(weights, device): - v = numpy.arange(5) - w = weights - - iv = dpnp.array(v, device=device) - iw = None if weights is None else dpnp.array(w, sycl_queue=iv.sycl_queue) - - expected_edges = numpy.histogram_bin_edges(v, weights=w) +def test_histogram_bin_edges(wgt, device): + iv = dpnp.arange(5, device=device) + iw = None if wgt is None else dpnp.array(wgt, sycl_queue=iv.sycl_queue) result_edges = dpnp.histogram_bin_edges(iv, weights=iw) - assert_dtype_allclose(result_edges, expected_edges) - - edges_queue = result_edges.sycl_queue - assert_sycl_queue_equal(edges_queue, iv.sycl_queue) + assert_sycl_queue_equal(result_edges.sycl_queue, iv.sycl_queue) @pytest.mark.parametrize( - "device_x", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_x", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( - "device_y", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_y", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_astype(device_x, device_y): x = dpnp.array([1, 2, 3], dtype="i4", device=device_x) y = dpnp.astype(x, dtype="f4") assert_sycl_queue_equal(y.sycl_queue, x.sycl_queue) + sycl_queue = dpctl.SyclQueue(device_y) y = dpnp.astype(x, dtype="f4", device=sycl_queue) assert_sycl_queue_equal(y.sycl_queue, sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_select(device): condlist = [dpnp.array([True, False], device=device)] @@ -2897,32 +2060,18 @@ def test_select(device): @pytest.mark.parametrize("axis", [None, 0, -1]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_unique(axis, device): - a = numpy.array([[1, 1], [2, 3]]) - ia = dpnp.array(a, device=device) - + ia = dpnp.array([[1, 1], [2, 3]], device=device) result = dpnp.unique(ia, True, True, True, axis=axis) - expected = numpy.unique(a, True, True, True, axis=axis) - if axis is None and numpy.lib.NumpyVersion(numpy.__version__) < "2.0.1": - # gh-26961: numpy.unique(..., return_inverse=True, axis=None) - # returned flatten unique_inverse till 2.0.1 version - expected = expected[:2] + (expected[2].reshape(a.shape),) + expected[3:] - for iv, v in zip(result, expected): - assert_array_equal(iv, v) - - iv_queue = iv.sycl_queue - assert_sycl_queue_equal(iv_queue, ia.sycl_queue) + for iv in result: + assert_sycl_queue_equal(iv.sycl_queue, ia.sycl_queue) -@pytest.mark.parametrize("copy", [True, False], ids=["True", "False"]) +@pytest.mark.parametrize("copy", [True, False]) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_nan_to_num(copy, device): a = dpnp.array([-dpnp.nan, -1, 0, 1, dpnp.nan], device=device) @@ -2933,9 +2082,7 @@ def test_nan_to_num(copy, device): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( ["to_end", "to_begin"], @@ -2946,9 +2093,7 @@ def test_nan_to_num(copy, device): ], ) def test_ediff1d(device, to_end, to_begin): - data = [1, 3, 5, 7] - - x = dpnp.array(data, device=device) + x = dpnp.array([1, 3, 5, 7], device=device) if to_end: to_end = dpnp.array(to_end, device=device) @@ -2956,14 +2101,11 @@ def test_ediff1d(device, to_end, to_begin): to_begin = dpnp.array(to_begin, device=device) res = dpnp.ediff1d(x, to_end=to_end, to_begin=to_begin) - assert_sycl_queue_equal(res.sycl_queue, x.sycl_queue) @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_unravel_index(device): x = dpnp.array(2, device=device) @@ -2973,9 +2115,7 @@ def test_unravel_index(device): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_ravel_index(device): x = dpnp.array([1, 0], device=device) @@ -2984,14 +2124,10 @@ def test_ravel_index(device): @pytest.mark.parametrize( - "device_0", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_0", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @pytest.mark.parametrize( - "device_1", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device_1", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_ix(device_0, device_1): x0 = dpnp.array([0, 1], device=device_0) @@ -3002,21 +2138,10 @@ def test_ix(device_0, device_1): @pytest.mark.parametrize( - "device", - valid_devices, - ids=[device.filter_string for device in valid_devices], + "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) def test_choose(device): chc = dpnp.arange(5, dtype="i4", device=device) - chc_np = dpnp.asnumpy(chc) - inds = dpnp.array([0, 1, 3], dtype="i4", device=device) - inds_np = dpnp.asnumpy(inds) - result = dpnp.choose(inds, chc) - expected = numpy.choose(inds_np, chc_np) - assert_allclose(expected, result) - - expected_queue = chc.sycl_queue - result_queue = result.sycl_queue - assert_sycl_queue_equal(result_queue, expected_queue) + assert_sycl_queue_equal(result.sycl_queue, chc.sycl_queue) From 6682db1c3cd01db934f0747e012b8cec6a502afd Mon Sep 17 00:00:00 2001 From: Vahid Tavanashad Date: Sat, 15 Feb 2025 08:51:44 -0800 Subject: [PATCH 2/2] address comments --- dpnp/tests/test_sycl_queue.py | 31 +++---------------------------- 1 file changed, 3 insertions(+), 28 deletions(-) diff --git a/dpnp/tests/test_sycl_queue.py b/dpnp/tests/test_sycl_queue.py index a6975d0373fb..acbb61bbd522 100644 --- a/dpnp/tests/test_sycl_queue.py +++ b/dpnp/tests/test_sycl_queue.py @@ -63,6 +63,7 @@ def assert_sycl_queue_equal(result, expected): pytest.param("fromstring", ["1 2"], {"dtype": int, "sep": " "}), pytest.param("full", [(2, 2)], {"fill_value": 5}), pytest.param("eye", [4, 2], {}), + pytest.param("empty", [(2, 2)], {}), pytest.param("geomspace", [1, 4, 8], {}), pytest.param("identity", [4], {}), pytest.param("linspace", [0, 4, 8], {}), @@ -83,33 +84,12 @@ def test_array_creation(func, arg, kwargs, device): assert x.sycl_device == device -@pytest.mark.parametrize( - "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] -) -def test_empty(device): - x = dpnp.empty((2, 2), device=device) - assert x.sycl_device == device - - -@pytest.mark.parametrize( - "device_x", valid_dev, ids=[dev.filter_string for dev in valid_dev] -) -@pytest.mark.parametrize( - "device_y", valid_dev, ids=[dev.filter_string for dev in valid_dev] -) -def test_empty_like(device_x, device_y): - x = dpnp.array([1, 2, 3], device=device_x) - y = dpnp.empty_like(x) - assert_sycl_queue_equal(y.sycl_queue, x.sycl_queue) - y = dpnp.empty_like(x, device=device_y) - assert_sycl_queue_equal(y.sycl_queue, x.to_device(device_y).sycl_queue) - - @pytest.mark.parametrize( "func, args, kwargs", [ pytest.param("copy", ["x0"], {}), pytest.param("diag", ["x0"], {}), + pytest.param("empty_like", ["x0"], {}), pytest.param("full_like", ["x0"], {"fill_value": 5}), pytest.param("geomspace", ["x0[0:3]", "8", "4"], {}), pytest.param("geomspace", ["1", "x0[2:4]", "4"], {}), @@ -136,10 +116,6 @@ def test_array_creation_follow_device(func, args, kwargs, device): assert_sycl_queue_equal(y.sycl_queue, x.sycl_queue) -@pytest.mark.skipif( - numpy.lib.NumpyVersion(numpy.__version__) < "1.25.0", - reason="numpy.logspace supports a non-scalar base argument since 1.25.0", -) @pytest.mark.parametrize( "device", valid_dev, ids=[dev.filter_string for dev in valid_dev] ) @@ -171,6 +147,7 @@ def test_array_creation_follow_device_2d_array(func, args, kwargs, device): [ pytest.param("copy", ["x0"], {}), pytest.param("diag", ["x0"], {}), + pytest.param("empty_like", ["x0"], {}), pytest.param("full", ["10", "x0[3]"], {}), pytest.param("full_like", ["x0"], {"fill_value": 5}), pytest.param("ones_like", ["x0"], {}), @@ -199,7 +176,6 @@ def test_array_creation_cross_device(func, args, kwargs, device_x, device_y): dpnp_kwargs["device"] = device_y y = getattr(dpnp, func)(*dpnp_args, **dpnp_kwargs) - assert_sycl_queue_equal(y.sycl_queue, x.to_device(device_y).sycl_queue) @@ -231,7 +207,6 @@ def test_array_creation_cross_device_2d_array( dpnp_kwargs["device"] = device_y y = getattr(dpnp, func)(*dpnp_args, **dpnp_kwargs) - assert_sycl_queue_equal(y.sycl_queue, x.to_device(device_y).sycl_queue)