diff --git a/dpnp/tests/test_binary_ufuncs.py b/dpnp/tests/test_binary_ufuncs.py index 4823b5a1cd9a..1bc1ddd5b967 100644 --- a/dpnp/tests/test_binary_ufuncs.py +++ b/dpnp/tests/test_binary_ufuncs.py @@ -13,6 +13,7 @@ from .helper import ( assert_dtype_allclose, + generate_random_numpy_array, get_abs_array, get_all_dtypes, get_complex_dtypes, @@ -22,10 +23,6 @@ has_support_aspect16, numpy_version, ) -from .test_umath import ( - _get_numpy_arrays_2in_1out, - _get_output_data_type, -) """ The scope includes tests with only functions which are instances of @@ -39,7 +36,9 @@ class TestAdd: @pytest.mark.parametrize("dtype", ALL_DTYPES) def test_add(self, dtype): - a, b, expected = _get_numpy_arrays_2in_1out("add", dtype, [-5, 5, 10]) + a = generate_random_numpy_array(10, dtype) + b = generate_random_numpy_array(10, dtype) + expected = numpy.add(a, b) ia, ib = dpnp.array(a), dpnp.array(b) iout = dpnp.empty(expected.shape, dtype=dtype) @@ -139,63 +138,41 @@ def test_invalid_out(self, xp, out): assert_raises(TypeError, xp.add, a, 2, out) +@pytest.mark.parametrize("func", ["fmax", "fmin", "maximum", "minimum"]) class TestBoundFuncs: - @pytest.fixture( - params=[ - {"func_name": "fmax", "input_values": [-5, 5, 10]}, - {"func_name": "fmin", "input_values": [-5, 5, 10]}, - {"func_name": "maximum", "input_values": [-5, 5, 10]}, - {"func_name": "minimum", "input_values": [-5, 5, 10]}, - ], - ids=[ - "fmax", - "fmin", - "maximum", - "minimum", - ], - ) - def func_params(self, request): - return request.param - - @pytest.mark.parametrize( - "dtype", get_all_dtypes(no_bool=True, no_complex=True) - ) - def test_out(self, func_params, dtype): - func_name = func_params["func_name"] - input_values = func_params["input_values"] - a, b, expected = _get_numpy_arrays_2in_1out( - func_name, dtype, input_values - ) + @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True)) + def test_out(self, func, dtype): + a = generate_random_numpy_array(10, dtype) + b = generate_random_numpy_array(10, dtype) + expected = getattr(numpy, func)(a, b) ia, ib = dpnp.array(a), dpnp.array(b) iout = dpnp.empty(expected.shape, dtype=dtype) - result = getattr(dpnp, func_name)(ia, ib, out=iout) + result = getattr(dpnp, func)(ia, ib, out=iout) assert result is iout assert_dtype_allclose(result, expected) @pytest.mark.parametrize( - "dtype", get_all_dtypes(no_bool=True, no_complex=True) + "dtype", get_all_dtypes(no_none=True, no_bool=True) ) - def test_out_overlap(self, func_params, dtype): - func_name = func_params["func_name"] + def test_out_overlap(self, func, dtype): size = 15 a = numpy.arange(2 * size, dtype=dtype) ia = dpnp.array(a) - getattr(dpnp, func_name)(ia[size::], ia[::2], out=ia[:size:]) - getattr(numpy, func_name)(a[size::], a[::2], out=a[:size:]) + getattr(dpnp, func)(ia[size::], ia[::2], out=ia[:size:]) + getattr(numpy, func)(a[size::], a[::2], out=a[:size:]) assert_dtype_allclose(ia, a) @pytest.mark.parametrize("shape", [(0,), (15,), (2, 2)]) - def test_invalid_shape(self, func_params, shape): - func_name = func_params["func_name"] + def test_invalid_shape(self, func, shape): a, b = dpnp.arange(10), dpnp.arange(10) out = dpnp.empty(shape) with pytest.raises(ValueError): - getattr(dpnp, func_name)(a, b, out=out) + getattr(dpnp, func)(a, b, out=out) @pytest.mark.parametrize("xp", [dpnp, numpy]) @pytest.mark.parametrize( @@ -203,27 +180,21 @@ def test_invalid_shape(self, func_params, shape): [4, (), [], (3, 7), [2, 4]], ids=["scalar", "empty_tuple", "empty_list", "tuple", "list"], ) - def test_invalid_out(self, func_params, xp, out): - func_name = func_params["func_name"] + def test_invalid_out(self, func, xp, out): a = xp.arange(10) - assert_raises(TypeError, getattr(xp, func_name), a, 2, out) + assert_raises(TypeError, getattr(xp, func), a, 2, out) class TestDivide: @pytest.mark.usefixtures("suppress_divide_invalid_numpy_warnings") - @pytest.mark.parametrize( - "dtype", get_all_dtypes(no_none=True, no_bool=True) - ) + @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True)) def test_divide(self, dtype): - a, b, expected = _get_numpy_arrays_2in_1out( - "divide", dtype, [-5, 5, 10] - ) + a = generate_random_numpy_array(10, dtype) + b = generate_random_numpy_array(10, dtype) + expected = numpy.divide(a, b) ia, ib = dpnp.array(a), dpnp.array(b) - if numpy.issubdtype(dtype, numpy.integer): - out_dtype = map_dtype_to_device(dpnp.float64, ia.sycl_device) - else: - out_dtype = _get_output_data_type(dtype) + out_dtype = map_dtype_to_device(expected.dtype, ia.sycl_device) iout = dpnp.empty(expected.shape, dtype=out_dtype) result = dpnp.divide(ia, ib, out=iout) @@ -318,7 +289,9 @@ def do_inplace_op(self, base, other, func): @pytest.mark.usefixtures("suppress_divide_numpy_warnings") @pytest.mark.parametrize("dtype", ALL_DTYPES) def test_basic(self, func, dtype): - a, b, expected = _get_numpy_arrays_2in_1out(func, dtype, [-5, 5, 10]) + a = generate_random_numpy_array(10, dtype) + b = generate_random_numpy_array(10, dtype) + expected = getattr(numpy, func)(a, b) ia, ib = dpnp.array(a), dpnp.array(b) iout = dpnp.empty(expected.shape, dtype=dtype) @@ -398,9 +371,9 @@ def test_invalid_out(self, func, xp, out): assert_raises(TypeError, getattr(xp, func), a, 2, out) +@pytest.mark.parametrize("func", ["fmax", "fmin"]) class TestFmaxFmin: @pytest.mark.skipif(not has_support_aspect16(), reason="no fp16 support") - @pytest.mark.parametrize("func", ["fmax", "fmin"]) def test_half(self, func): a = numpy.array([0, 1, 2, 4, 2], dtype=numpy.float16) b = numpy.array([-2, 5, 1, 4, 3], dtype=numpy.float16) @@ -415,7 +388,6 @@ def test_half(self, func): expected = getattr(numpy, func)(b, c) assert_equal(result, expected) - @pytest.mark.parametrize("func", ["fmax", "fmin"]) @pytest.mark.parametrize("dtype", get_float_dtypes()) def test_float_nans(self, func, dtype): a = numpy.array([0, numpy.nan, numpy.nan], dtype=dtype) @@ -426,7 +398,6 @@ def test_float_nans(self, func, dtype): expected = getattr(numpy, func)(a, b) assert_equal(result, expected) - @pytest.mark.parametrize("func", ["fmax", "fmin"]) @pytest.mark.parametrize("dtype", get_complex_dtypes()) @pytest.mark.parametrize( "nan_val", @@ -446,7 +417,6 @@ def test_complex_nans(self, func, dtype, nan_val): expected = getattr(numpy, func)(a, b) assert_equal(result, expected) - @pytest.mark.parametrize("func", ["fmax", "fmin"]) @pytest.mark.parametrize("dtype", get_float_dtypes(no_float16=False)) def test_precision(self, func, dtype): dtmin = numpy.finfo(dtype).min @@ -602,9 +572,9 @@ class TestMultiply: @pytest.mark.parametrize("dtype", ALL_DTYPES) def test_multiply(self, dtype): - a, b, expected = _get_numpy_arrays_2in_1out( - "multiply", dtype, [0, 10, 10] - ) + a = generate_random_numpy_array(10, dtype) + b = generate_random_numpy_array(10, dtype) + expected = numpy.multiply(a, b) ia, ib = dpnp.array(a), dpnp.array(b) iout = dpnp.empty(expected.shape, dtype=dtype) @@ -853,8 +823,9 @@ def test_basic(self, array, val, data_type, val_type): @pytest.mark.parametrize("dtype", ALL_DTYPES) def test_power(self, dtype): - numpy.random.seed(42) - a, b, expected = _get_numpy_arrays_2in_1out("power", dtype, [0, 10, 10]) + a = generate_random_numpy_array(10, dtype, low=0) + b = generate_random_numpy_array(10, dtype, low=0) + expected = numpy.power(a, b) ia, ib = dpnp.array(a), dpnp.array(b) out_dtype = numpy.int8 if dtype == numpy.bool_ else dtype @@ -1075,9 +1046,9 @@ class TestSubtract: @pytest.mark.parametrize("dtype", ALL_DTYPES) def test_add(self, dtype): - a, b, expected = _get_numpy_arrays_2in_1out( - "subtract", dtype, [-5, 5, 10] - ) + a = generate_random_numpy_array(10, dtype) + b = generate_random_numpy_array(10, dtype) + expected = numpy.subtract(a, b) ia, ib = dpnp.array(a), dpnp.array(b) iout = dpnp.empty(expected.shape, dtype=dtype) diff --git a/dpnp/tests/test_mathematical.py b/dpnp/tests/test_mathematical.py index 4d0f3919e4e5..ecb146b3f213 100644 --- a/dpnp/tests/test_mathematical.py +++ b/dpnp/tests/test_mathematical.py @@ -17,6 +17,7 @@ import dpnp from dpnp.dpnp_array import dpnp_array +from dpnp.dpnp_utils import map_dtype_to_device from .helper import ( assert_dtype_allclose, @@ -32,14 +33,33 @@ has_support_aspect64, numpy_version, ) -from .test_umath import ( - _get_numpy_arrays_1in_1out, - _get_numpy_arrays_2in_1out, - _get_output_data_type, -) from .third_party.cupy import testing +def _get_output_data_type(dtype): + """Return a data type specified by input `dtype` and device capabilities.""" + dtype_float16 = any( + dpnp.issubdtype(dtype, t) for t in (dpnp.bool, dpnp.int8, dpnp.uint8) + ) + dtype_float32 = any( + dpnp.issubdtype(dtype, t) for t in (dpnp.int16, dpnp.uint16) + ) + if dtype_float16: + out_dtype = dpnp.float16 if has_support_aspect16() else dpnp.float32 + elif dtype_float32: + out_dtype = dpnp.float32 + elif dpnp.issubdtype(dtype, dpnp.complexfloating): + out_dtype = dpnp.complex64 + if has_support_aspect64() and dtype != dpnp.complex64: + out_dtype = dpnp.complex128 + else: + out_dtype = dpnp.float32 + if has_support_aspect64() and dtype != dpnp.float32: + out_dtype = dpnp.float64 + + return out_dtype + + @pytest.mark.parametrize("deg", [True, False]) class TestAngle: def test_angle_bool(self, deg): @@ -2271,30 +2291,19 @@ def test_projection(self, dtype): assert dpnp.allclose(result, expected) +@pytest.mark.parametrize("func", ["ceil", "floor", "trunc"]) class TestRoundingFuncs: - @pytest.fixture( - params=[ - {"func_name": "ceil", "input_values": [-5, 5, 10]}, - {"func_name": "floor", "input_values": [-5, 5, 10]}, - {"func_name": "trunc", "input_values": [-5, 5, 10]}, - ], - ids=["ceil", "floor", "trunc"], - ) - def func_params(self, request): - return request.param - @pytest.mark.parametrize( "dtype", get_all_dtypes(no_none=True, no_complex=True) ) - def test_out(self, func_params, dtype): - func_name = func_params["func_name"] - input_values = func_params["input_values"] - a, expected = _get_numpy_arrays_1in_1out(func_name, dtype, input_values) + def test_out(self, func, dtype): + a = generate_random_numpy_array(10, dtype) + expected = getattr(numpy, func)(a) ia = dpnp.array(a) out_dt = numpy.int8 if dtype == dpnp.bool else dtype iout = dpnp.empty(expected.shape, dtype=out_dt) - result = getattr(dpnp, func_name)(ia, out=iout) + result = getattr(dpnp, func)(ia, out=iout) assert result is iout # numpy.ceil, numpy.floor, numpy.trunc always return float dtype for @@ -2310,23 +2319,22 @@ def test_out(self, func_params, dtype): @pytest.mark.parametrize( "dtype", get_all_dtypes(no_complex=True, no_none=True)[:-1] ) - def test_invalid_dtype(self, func_params, dtype): - func_name = func_params["func_name"] + def test_invalid_dtype(self, func, dtype): dpnp_dtype = get_all_dtypes(no_complex=True, no_none=True)[-1] ia = dpnp.arange(10, dtype=dpnp_dtype) iout = dpnp.empty(10, dtype=dtype) with pytest.raises(ValueError): - getattr(dpnp, func_name)(ia, out=iout) + getattr(dpnp, func)(ia, out=iout) @pytest.mark.parametrize( "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15,)", "(2, 2)"] ) - def test_invalid_shape(self, func_params, shape): - func_name = func_params["func_name"] + def test_invalid_shape(self, func, shape): ia = dpnp.arange(10, dtype=dpnp.float32) iout = dpnp.empty(shape, dtype=dpnp.float32) - assert_raises(ValueError, getattr(dpnp, func_name), ia, out=iout) + + assert_raises(ValueError, getattr(dpnp, func), ia, out=iout) class TestHypot: @@ -2334,10 +2342,12 @@ class TestHypot: "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True) ) def test_hypot(self, dtype): - a, b, expected = _get_numpy_arrays_2in_1out("hypot", dtype, [0, 10, 10]) + a = generate_random_numpy_array(10, dtype, low=0) + b = generate_random_numpy_array(10, dtype, low=0) + expected = numpy.hypot(a, b) ia, ib = dpnp.array(a), dpnp.array(b) - out_dt = _get_output_data_type(dtype) + out_dt = map_dtype_to_device(expected.dtype, ia.sycl_device) iout = dpnp.empty(expected.shape, dtype=out_dt) result = dpnp.hypot(ia, ib, out=iout) diff --git a/dpnp/tests/test_umath.py b/dpnp/tests/test_umath.py index 526586564da6..2d3b18c20bc7 100644 --- a/dpnp/tests/test_umath.py +++ b/dpnp/tests/test_umath.py @@ -9,9 +9,11 @@ ) import dpnp +from dpnp.dpnp_utils import map_dtype_to_device from .helper import ( assert_dtype_allclose, + generate_random_numpy_array, get_abs_array, get_all_dtypes, get_float_complex_dtypes, @@ -73,7 +75,6 @@ def get_id(val): return val.__str__() -@pytest.mark.usefixtures("allow_fall_back_on_numpy") @pytest.mark.usefixtures("suppress_divide_invalid_numpy_warnings") @pytest.mark.parametrize("test_cases", test_cases, ids=get_id) def test_umaths(test_cases): @@ -108,123 +109,42 @@ def test_umaths(test_cases): assert_allclose(result, expected, rtol=1e-6) -def _get_numpy_arrays_1in_1out(func_name, dtype, range): - """ - Return a sample array and an output array. - - Create an appropriate array specified by `dtype` and `range` which is used as - an input for a function specified by `func_name` to obtain the output. - """ - low = range[0] - high = range[1] - size = range[2] - if dtype == dpnp.bool: - np_array = numpy.arange(2, dtype=dtype) - result = getattr(numpy, func_name)(np_array) - elif dpnp.issubdtype(dtype, dpnp.complexfloating): - a = numpy.random.uniform(low=low, high=high, size=size) - b = numpy.random.uniform(low=low, high=high, size=size) - np_array = numpy.array(a + 1j * b, dtype=dtype) - result = getattr(numpy, func_name)(np_array) - else: - a = numpy.random.uniform(low=low, high=high, size=size) - np_array = numpy.array(a, dtype=dtype) - result = getattr(numpy, func_name)(np_array) - - return np_array, result - - -def _get_numpy_arrays_2in_1out(func_name, dtype, range): - """ - Return two sample arrays and an output array. - - Create two appropriate arrays specified by `dtype` and `range` which are - used as inputs for a function specified by `func_name` to obtain the output. - """ - low = range[0] - high = range[1] - size = range[2] - if dtype == dpnp.bool: - np_array1 = numpy.arange(2, dtype=dtype) - np_array2 = numpy.arange(2, dtype=dtype) - result = getattr(numpy, func_name)(np_array1, np_array2) - elif dpnp.issubdtype(dtype, dpnp.complexfloating): - a = numpy.random.uniform(low=low, high=high, size=size) - b = numpy.random.uniform(low=low, high=high, size=size) - np_array1 = numpy.array(a + 1j * b, dtype=dtype) - a = numpy.random.uniform(low=low, high=high, size=size) - b = numpy.random.uniform(low=low, high=high, size=size) - np_array2 = numpy.array(a + 1j * b, dtype=dtype) - result = getattr(numpy, func_name)(np_array1, np_array2) - else: - a = numpy.random.uniform(low=low, high=high, size=size) - np_array1 = numpy.array(a, dtype=dtype) - a = numpy.random.uniform(low=low, high=high, size=size) - np_array2 = numpy.array(a, dtype=dtype) - result = getattr(numpy, func_name)(np_array1, np_array2) - - return np_array1, np_array2, result - - -def _get_output_data_type(dtype): - """Return a data type specified by input `dtype` and device capabilities.""" - dtype_float16 = any( - dpnp.issubdtype(dtype, t) for t in (dpnp.bool, dpnp.int8, dpnp.uint8) - ) - dtype_float32 = any( - dpnp.issubdtype(dtype, t) for t in (dpnp.int16, dpnp.uint16) - ) - if dtype_float16: - out_dtype = dpnp.float16 if has_support_aspect16() else dpnp.float32 - elif dtype_float32: - out_dtype = dpnp.float32 - elif dpnp.issubdtype(dtype, dpnp.complexfloating): - out_dtype = dpnp.complex64 - if has_support_aspect64() and dtype != dpnp.complex64: - out_dtype = dpnp.complex128 - else: - out_dtype = dpnp.float32 - if has_support_aspect64() and dtype != dpnp.float32: - out_dtype = dpnp.float64 - - return out_dtype - - class TestArctan2: - @pytest.mark.parametrize("dtype", get_all_dtypes(no_complex=True)) + @pytest.mark.parametrize( + "dtype", get_all_dtypes(no_none=True, no_complex=True) + ) def test_arctan2(self, dtype): - np_array1, np_array2, expected = _get_numpy_arrays_2in_1out( - "arctan2", dtype, [0, 10, 10] - ) + a = generate_random_numpy_array(10, dtype, low=0) + b = generate_random_numpy_array(10, dtype, low=0) + expected = numpy.arctan2(a, b) - dp_array1 = dpnp.array(np_array1) - dp_array2 = dpnp.array(np_array2) - out_dtype = _get_output_data_type(dtype) - dp_out = dpnp.empty(expected.shape, dtype=out_dtype) - result = dpnp.arctan2(dp_array1, dp_array2, out=dp_out) + ia, ib = dpnp.array(a), dpnp.array(b) + dt_out = map_dtype_to_device(expected.dtype, ia.sycl_device) + iout = dpnp.empty(expected.shape, dtype=dt_out) - assert result is dp_out + result = dpnp.arctan2(ia, ib, out=iout) + assert result is iout assert_dtype_allclose(result, expected) @pytest.mark.parametrize( - "dtype", get_all_dtypes(no_complex=True, no_none=True)[:-1] + "dt_out", get_all_dtypes(no_none=True, no_complex=True)[:-1] ) - def test_invalid_dtype(self, dtype): - dpnp_dtype = get_all_dtypes(no_complex=True, no_none=True)[-1] - dp_array = dpnp.arange(10, dtype=dpnp_dtype) - dp_out = dpnp.empty(10, dtype=dtype) + def test_invalid_dtype(self, dt_out): + dt_in = get_all_dtypes(no_none=True, no_complex=True)[-1] + a = dpnp.arange(10, dtype=dt_in) + iout = dpnp.empty(10, dtype=dt_out) with pytest.raises(ValueError): - dpnp.arctan2(dp_array, dp_array, out=dp_out) + dpnp.arctan2(a, a, out=iout) @pytest.mark.parametrize( - "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"] + "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15,)", "(2, 2)"] ) def test_invalid_shape(self, shape): - dp_array = dpnp.arange(10) - dp_out = dpnp.empty(shape) + a = dpnp.arange(10) + iout = dpnp.empty(shape) with pytest.raises(ValueError): - dpnp.arctan2(dp_array, dp_array, out=dp_out) + dpnp.arctan2(a, a, out=iout) def test_alias(self): x = dpnp.array([-1, +1, +1, -1]) @@ -235,77 +155,41 @@ def test_alias(self): assert_array_equal(res1, res2) -class TestCbrt: - @pytest.mark.parametrize("dtype", get_all_dtypes(no_complex=True)) - def test_cbrt(self, dtype): - np_array, expected = _get_numpy_arrays_1in_1out( - "cbrt", dtype, [-5, 5, 10] - ) - - dp_array = dpnp.array(np_array) - out_dtype = _get_output_data_type(dtype) - dp_out = dpnp.empty(expected.shape, dtype=out_dtype) - result = dpnp.cbrt(dp_array, out=dp_out) - - assert result is dp_out - assert_dtype_allclose(result, expected) - - @pytest.mark.parametrize( - "dtype", get_all_dtypes(no_complex=True, no_none=True)[:-1] - ) - def test_invalid_dtype(self, dtype): - dpnp_dtype = get_all_dtypes(no_complex=True, no_none=True)[-1] - dp_array = dpnp.arange(10, dtype=dpnp_dtype) - dp_out = dpnp.empty(10, dtype=dtype) - - with pytest.raises(ValueError): - dpnp.cbrt(dp_array, out=dp_out) - +class TestCopySign: @pytest.mark.parametrize( - "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"] + "dtype", get_all_dtypes(no_none=True, no_complex=True) ) - def test_invalid_shape(self, shape): - dp_array = dpnp.arange(10) - dp_out = dpnp.empty(shape) - - with pytest.raises(ValueError): - dpnp.cbrt(dp_array, out=dp_out) - - -class TestCopySign: - @pytest.mark.parametrize("dtype", get_all_dtypes(no_complex=True)) def test_copysign(self, dtype): - np_array1, np_array2, expected = _get_numpy_arrays_2in_1out( - "copysign", dtype, [0, 10, 10] - ) + a = generate_random_numpy_array(10, dtype, low=0) + b = generate_random_numpy_array(10, dtype, low=0) + expected = numpy.copysign(a, b) - dp_array1 = dpnp.array(np_array1) - dp_array2 = dpnp.array(np_array2) - out_dtype = _get_output_data_type(dtype) - dp_out = dpnp.empty(expected.shape, dtype=out_dtype) - result = dpnp.copysign(dp_array1, dp_array2, out=dp_out) + ia, ib = dpnp.array(a), dpnp.array(b) + dt_out = map_dtype_to_device(expected.dtype, ia.sycl_device) + iout = dpnp.empty(expected.shape, dtype=dt_out) + result = dpnp.copysign(ia, ib, out=iout) - assert result is dp_out + assert result is iout assert_dtype_allclose(result, expected) @pytest.mark.parametrize( - "dtype", get_all_dtypes(no_complex=True, no_none=True)[:-1] + "dt_out", get_all_dtypes(no_none=True, no_complex=True)[:-1] ) - def test_invalid_dtype(self, dtype): - dpnp_dtype = get_all_dtypes(no_complex=True, no_none=True)[-1] - dp_array = dpnp.arange(10, dtype=dpnp_dtype) - dp_out = dpnp.empty(10, dtype=dtype) + def test_invalid_dtype(self, dt_out): + dt_in = get_all_dtypes(no_none=True, no_complex=True)[-1] + a = dpnp.arange(10, dtype=dt_in) + iout = dpnp.empty(10, dtype=dt_out) with pytest.raises(ValueError): - dpnp.copysign(dp_array, dp_array, out=dp_out) + dpnp.copysign(a, a, out=iout) @pytest.mark.parametrize( - "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"] + "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15,)", "(2, 2)"] ) def test_invalid_shape(self, shape): - dp_array = dpnp.arange(10) - dp_out = dpnp.empty(shape) + a = dpnp.arange(10) + iout = dpnp.empty(shape) with pytest.raises(ValueError): - dpnp.copysign(dp_array, dp_array, out=dp_out) + dpnp.copysign(a, a, out=iout) class TestDegrees: @@ -391,39 +275,40 @@ def test_nan_infs_base(self, exp_val, dtype): class TestLogAddExp: - @pytest.mark.parametrize("dtype", get_all_dtypes(no_complex=True)) + @pytest.mark.parametrize( + "dtype", get_all_dtypes(no_none=True, no_complex=True) + ) def test_logaddexp(self, dtype): - np_array1, np_array2, expected = _get_numpy_arrays_2in_1out( - "logaddexp", dtype, [0, 10, 10] - ) + a = generate_random_numpy_array(10, dtype, low=0) + b = generate_random_numpy_array(10, dtype, low=0) + expected = numpy.logaddexp(a, b) - dp_array1 = dpnp.array(np_array1) - dp_array2 = dpnp.array(np_array2) - out_dtype = _get_output_data_type(dtype) - dp_out = dpnp.empty(expected.shape, dtype=out_dtype) - result = dpnp.logaddexp(dp_array1, dp_array2, out=dp_out) + ia, ib = dpnp.array(a), dpnp.array(b) + dt_out = map_dtype_to_device(expected.dtype, ia.sycl_device) + iout = dpnp.empty(expected.shape, dtype=dt_out) + result = dpnp.logaddexp(ia, ib, out=iout) - assert result is dp_out + assert result is iout assert_dtype_allclose(result, expected) @pytest.mark.parametrize( - "dtype", get_all_dtypes(no_complex=True, no_none=True)[:-1] + "dt_out", get_all_dtypes(no_none=True, no_complex=True)[:-1] ) - def test_invalid_dtype(self, dtype): - dpnp_dtype = get_all_dtypes(no_complex=True, no_none=True)[-1] - dp_array = dpnp.arange(10, dtype=dpnp_dtype) - dp_out = dpnp.empty(10, dtype=dtype) + def test_invalid_dtype(self, dt_out): + dt_in = get_all_dtypes(no_none=True, no_complex=True)[-1] + a = dpnp.arange(10, dtype=dt_in) + iout = dpnp.empty(10, dtype=dt_out) with pytest.raises(ValueError): - dpnp.logaddexp(dp_array, dp_array, out=dp_out) + dpnp.logaddexp(a, a, out=iout) @pytest.mark.parametrize( - "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"] + "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15,)", "(2, 2)"] ) def test_invalid_shape(self, shape): - dp_array = dpnp.arange(10) - dp_out = dpnp.empty(shape) + a = dpnp.arange(10) + iout = dpnp.empty(shape) with pytest.raises(ValueError): - dpnp.logaddexp(dp_array, dp_array, out=dp_out) + dpnp.logaddexp(a, a, out=iout) @pytest.mark.usefixtures("suppress_invalid_numpy_warnings") @pytest.mark.parametrize( @@ -538,152 +423,120 @@ class TestReciprocal: @pytest.mark.usefixtures("suppress_divide_numpy_warnings") @pytest.mark.parametrize("dtype", get_float_complex_dtypes()) def test_reciprocal(self, dtype): - np_array, expected = _get_numpy_arrays_1in_1out( - "reciprocal", dtype, [-5, 5, 10] - ) + a = generate_random_numpy_array(10, dtype) + expected = numpy.reciprocal(a) - dp_array = dpnp.array(np_array) - out_dtype = _get_output_data_type(dtype) - dp_out = dpnp.empty(expected.shape, dtype=out_dtype) - result = dpnp.reciprocal(dp_array, out=dp_out) + ia = dpnp.array(a) + dt_out = map_dtype_to_device(expected.dtype, ia.sycl_device) + iout = dpnp.empty(expected.shape, dtype=dt_out) + result = dpnp.reciprocal(ia, out=iout) - assert result is dp_out + assert result is iout assert_dtype_allclose(result, expected) - @pytest.mark.parametrize("dtype", get_float_complex_dtypes()[:-1]) - def test_invalid_dtype(self, dtype): - dpnp_dtype = get_float_complex_dtypes()[-1] - dp_array = dpnp.arange(10, dtype=dpnp_dtype) - dp_out = dpnp.empty(10, dtype=dtype) - - with pytest.raises(ValueError): - dpnp.reciprocal(dp_array, out=dp_out) + @pytest.mark.parametrize("dt_out", get_float_complex_dtypes()[:-1]) + def test_invalid_dtype(self, dt_out): + dt_in = get_float_complex_dtypes()[-1] + a = dpnp.arange(10, dtype=dt_in) + iout = dpnp.empty(10, dtype=dt_out) + assert_raises(ValueError, dpnp.reciprocal, a, out=iout) @pytest.mark.parametrize( - "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"] + "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15,)", "(2, 2)"] ) def test_invalid_shape(self, shape): - dp_array = dpnp.arange(10) - dp_out = dpnp.empty(shape) + a = dpnp.arange(10) + iout = dpnp.empty(shape) + assert_raises(ValueError, dpnp.reciprocal, a, out=iout) - with pytest.raises(ValueError): - dpnp.reciprocal(dp_array, out=dp_out) +class TestRsqrtCbrt: + @pytest.fixture( + params=[ + {"func": "cbrt", "values": [-10, 10]}, + {"func": "rsqrt", "values": [0, 10]}, + ], + ids=["cbrt", "rsqrt"], + ) + def func_params(self, request): + return request.param -class TestRsqrt: @pytest.mark.usefixtures("suppress_divide_numpy_warnings") - @pytest.mark.parametrize("dtype", get_all_dtypes(no_complex=True)) - def test_rsqrt(self, dtype): - np_array, expected = _get_numpy_arrays_1in_1out( - "sqrt", dtype, [0, 10, 10] + @pytest.mark.parametrize( + "dtype", get_all_dtypes(no_none=True, no_complex=True) + ) + def test_basic(self, func_params, dtype): + func = func_params["func"] + values = func_params["values"] + a = generate_random_numpy_array( + 10, dtype, low=values[0], high=values[1] ) - expected = numpy.reciprocal(expected) - - dp_array = dpnp.array(np_array) - out_dtype = _get_output_data_type(dtype) - dp_out = dpnp.empty(expected.shape, dtype=out_dtype) - result = dpnp.rsqrt(dp_array, out=dp_out) + if func == "rsqrt": + expected = numpy.reciprocal(numpy.sqrt(a)) + else: + expected = getattr(numpy, func)(a) - assert result is dp_out + ia = dpnp.array(a) + dt_out = map_dtype_to_device(expected.dtype, ia.sycl_device) + iout = dpnp.empty(expected.shape, dtype=dt_out) + result = getattr(dpnp, func)(ia, out=iout) + assert result is iout assert_dtype_allclose(result, expected) @pytest.mark.parametrize( - "dtype", get_all_dtypes(no_complex=True, no_none=True)[:-1] + "dt_out", get_all_dtypes(no_none=True, no_complex=True)[:-1] ) - def test_invalid_dtype(self, dtype): - dpnp_dtype = get_all_dtypes(no_complex=True, no_none=True)[-1] - dp_array = dpnp.arange(10, dtype=dpnp_dtype) - dp_out = dpnp.empty(10, dtype=dtype) - - with pytest.raises(ValueError): - dpnp.rsqrt(dp_array, out=dp_out) + def test_invalid_dtype(self, func_params, dt_out): + func = func_params["func"] + dt_in = get_all_dtypes(no_none=True, no_complex=True)[-1] + a = dpnp.arange(10, dtype=dt_in) + iout = dpnp.empty(10, dtype=dt_out) + assert_raises(ValueError, getattr(dpnp, func), a, out=iout) @pytest.mark.parametrize( - "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"] + "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15,)", "(2, 2)"] ) - def test_invalid_shape(self, shape): - dp_array = dpnp.arange(10) - dp_out = dpnp.empty(shape) - with pytest.raises(ValueError): - dpnp.rsqrt(dp_array, out=dp_out) + def test_invalid_shape(self, func_params, shape): + func = func_params["func"] + a = dpnp.arange(10) + iout = dpnp.empty(shape) + assert_raises(ValueError, getattr(dpnp, func), a, out=iout) @pytest.mark.parametrize( "out", [4, (), [], (3, 7), [2, 4]], ids=["4", "()", "[]", "(3, 7)", "[2, 4]"], ) - def test_invalid_out(self, out): + def test_invalid_out(self, func_params, out): + func = func_params["func"] a = dpnp.arange(10) - assert_raises(TypeError, dpnp.rsqrt, a, out) - - -class TestSquare: - @pytest.mark.parametrize("dtype", get_all_dtypes()) - def test_square(self, dtype): - np_array, expected = _get_numpy_arrays_1in_1out( - "square", dtype, [-5, 5, 10] - ) - - dp_array = dpnp.array(np_array) - out_dtype = numpy.int8 if dtype == dpnp.bool else dtype - dp_out = dpnp.empty(expected.shape, dtype=out_dtype) - result = dpnp.square(dp_array, out=dp_out) - - assert result is dp_out - assert_dtype_allclose(result, expected) - - @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True)[:-1]) - def test_invalid_dtype(self, dtype): - dpnp_dtype = get_all_dtypes(no_none=True)[-1] - dp_array = dpnp.arange(10, dtype=dpnp_dtype) - dp_out = dpnp.empty(10, dtype=dtype) - - with pytest.raises(ValueError): - dpnp.square(dp_array, out=dp_out) - - @pytest.mark.parametrize( - "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"] - ) - def test_invalid_shape(self, shape): - dp_array = dpnp.arange(10) - dp_out = dpnp.empty(shape) - with pytest.raises(ValueError): - dpnp.square(dp_array, out=dp_out) - - @pytest.mark.parametrize("xp", [dpnp, numpy]) - @pytest.mark.parametrize( - "out", - [4, (), [], (3, 7), [2, 4]], - ids=["scalar", "empty_tuple", "empty_list", "tuple", "list"], - ) - def test_invalid_out(self, xp, out): - a = xp.arange(10) - assert_raises(TypeError, xp.square, a, out) + assert_raises(TypeError, getattr(dpnp, func), a, out) class TestUmath: @pytest.fixture( params=[ - {"func_name": "arccos", "input_values": [-1, 1, 10]}, - {"func_name": "arccosh", "input_values": [1, 10, 10]}, - {"func_name": "arcsin", "input_values": [-1, 1, 10]}, - {"func_name": "arcsinh", "input_values": [-5, 5, 10]}, - {"func_name": "arctan", "input_values": [-5, 5, 10]}, - {"func_name": "arctanh", "input_values": [-1, 1, 10]}, - {"func_name": "cos", "input_values": [-5, 5, 10]}, - {"func_name": "cosh", "input_values": [-5, 5, 10]}, - {"func_name": "exp", "input_values": [-3, 8, 10]}, - {"func_name": "exp2", "input_values": [-5, 5, 10]}, - {"func_name": "expm1", "input_values": [-5, 5, 10]}, - {"func_name": "log", "input_values": [0, 10, 10]}, - {"func_name": "log10", "input_values": [0, 10, 10]}, - {"func_name": "log2", "input_values": [0, 10, 10]}, - {"func_name": "log1p", "input_values": [0, 10, 10]}, - {"func_name": "sin", "input_values": [-5, 5, 10]}, - {"func_name": "sinh", "input_values": [-5, 5, 10]}, - {"func_name": "sqrt", "input_values": [0, 10, 10]}, - {"func_name": "tan", "input_values": [-1.5, 1.5, 10]}, - {"func_name": "tanh", "input_values": [-5, 5, 10]}, + {"func": "arccos", "values": [-1, 1]}, + {"func": "arccosh", "values": [1, 10]}, + {"func": "arcsin", "values": [-1, 1]}, + {"func": "arcsinh", "values": [-5, 5]}, + {"func": "arctan", "values": [-5, 5]}, + {"func": "arctanh", "values": [-1, 1]}, + {"func": "cos", "values": [-5, 5]}, + {"func": "cosh", "values": [-5, 5]}, + {"func": "exp", "values": [-3, 8]}, + {"func": "exp2", "values": [-5, 5]}, + {"func": "expm1", "values": [-5, 5]}, + {"func": "log", "values": [0, 10]}, + {"func": "log10", "values": [0, 10]}, + {"func": "log2", "values": [0, 10]}, + {"func": "log1p", "values": [0, 10]}, + {"func": "sin", "values": [-5, 5]}, + {"func": "sinh", "values": [-5, 5]}, + {"func": "sqrt", "values": [0, 10]}, + {"func": "square", "values": [-10, 10]}, + {"func": "tan", "values": [-1.5, 1.5]}, + {"func": "tanh", "values": [-5, 5]}, ], ids=[ "arccos", @@ -704,6 +557,7 @@ class TestUmath: "sin", "sinh", "sqrt", + "square", "tan", "tanh", ], @@ -713,41 +567,40 @@ def func_params(self, request): @pytest.mark.filterwarnings("ignore:overflow encountered:RuntimeWarning") @pytest.mark.usefixtures("suppress_divide_invalid_numpy_warnings") - @pytest.mark.parametrize("dtype", get_all_dtypes()) - def test_out(self, func_params, dtype): - func_name = func_params["func_name"] - input_values = func_params["input_values"] - np_array, expected = _get_numpy_arrays_1in_1out( - func_name, dtype, input_values + @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True)) + def test_basic(self, func_params, dtype): + func = func_params["func"] + values = func_params["values"] + a = generate_random_numpy_array( + 10, dtype, low=values[0], high=values[1] ) + expected = getattr(numpy, func)(a) - dp_array = dpnp.array(np_array) - out_dtype = _get_output_data_type(dtype) - dp_out = dpnp.empty(expected.shape, dtype=out_dtype) - result = getattr(dpnp, func_name)(dp_array, out=dp_out) + ia = dpnp.array(a) + dt_out = map_dtype_to_device(expected.dtype, ia.sycl_device) + iout = dpnp.empty(expected.shape, dtype=dt_out) + result = getattr(dpnp, func)(ia, out=iout) - assert result is dp_out + assert result is iout assert_dtype_allclose(result, expected) - @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True)[:-1]) - def test_invalid_dtype(self, func_params, dtype): - func_name = func_params["func_name"] - dpnp_dtype = get_all_dtypes(no_none=True)[-1] - dp_array = dpnp.arange(10, dtype=dpnp_dtype) - dp_out = dpnp.empty(10, dtype=dtype) - - with pytest.raises(ValueError): - getattr(dpnp, func_name)(dp_array, out=dp_out) + @pytest.mark.parametrize("dt_out", get_all_dtypes(no_none=True)[:-1]) + def test_invalid_dtype(self, func_params, dt_out): + func = func_params["func"] + dt_in = get_all_dtypes(no_none=True)[-1] + a = dpnp.arange(10, dtype=dt_in) + iout = dpnp.empty(10, dtype=dt_out) + assert_raises(ValueError, getattr(dpnp, func), a, out=iout) + @pytest.mark.parametrize("xp", [dpnp, numpy]) @pytest.mark.parametrize( - "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15, )", "(2,2)"] + "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15,)", "(2, 2)"] ) - def test_invalid_shape(self, func_params, shape): - func_name = func_params["func_name"] - dp_array = dpnp.arange(10) - dp_out = dpnp.empty(shape) - with pytest.raises(ValueError): - getattr(dpnp, func_name)(dp_array, out=dp_out) + def test_invalid_shape(self, xp, func_params, shape): + func = func_params["func"] + a = xp.arange(10) + iout = xp.empty(shape) + assert_raises(ValueError, getattr(xp, func), a, out=iout) @pytest.mark.parametrize("xp", [dpnp, numpy]) @pytest.mark.parametrize( @@ -756,9 +609,9 @@ def test_invalid_shape(self, func_params, shape): ids=["scalar", "empty_tuple", "empty_list", "tuple", "list"], ) def test_invalid_out(self, func_params, xp, out): - func_name = func_params["func_name"] + func = func_params["func"] a = xp.arange(10) - assert_raises(TypeError, getattr(xp, func_name), a, out) + assert_raises(TypeError, getattr(xp, func), a, out) def test_trigonometric_hyperbolic_aliases():