apply review remarks

Author: vlad-perevezentsev

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -1459,6 +1459,69 @@ def dpnp_not_equal(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
+_power_docstring_ = """
+power(x1, x2, out=None, order="K")
+
+Calculates `x1_i` raised to `x2_i` for each element `x1_i` of the input array
+`x1` with the respective element `x2_i` of the input array `x2`.
+
+Args:
+    x1 (dpnp.ndarray):
+        First input array, expected to have numeric data type.
+    x2 (dpnp.ndarray):
+        Second input array, also expected to have numeric data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate. Array must have the correct
+        shape and the expected data type.
+    order ("C","F","A","K", None, optional):
+        Output array, if parameter `out` is `None`.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the result of element-wise of raising each element
+        to a specified power.
+        The data type of the returned array is determined by the Type Promotion Rules.
+"""
+
+
+def _call_pow(src1, src2, dst, sycl_queue, depends=None):
+    """A callback to register in BinaryElementwiseFunc class of dpctl.tensor"""
+
+    if depends is None:
+        depends = []
+
+    # TODO: remove this check when OneMKL is fixed on Windows
+    is_win = platform.startswith("win")
+
+    if not is_win and vmi._mkl_pow_to_call(sycl_queue, src1, src2, dst):
+        # call pybind11 extension for pow() function from OneMKL VM
+        return vmi._pow(sycl_queue, src1, src2, dst, depends)
+    return ti._pow(src1, src2, dst, sycl_queue, depends)
+
+
+pow_func = BinaryElementwiseFunc(
+    "pow", ti._pow_result_type, _call_pow, _power_docstring_
+)
+
+
+def dpnp_power(x1, x2, out=None, order="K"):
+    """
+    Invokes pow() function from pybind11 extension of OneMKL VM if possible.
+
+    Otherwise fully relies on dpctl.tensor implementation for pow() function.
+    """
+
+    # dpctl.tensor only works with usm_ndarray or scalar
+    x1_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x1)
+    x2_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x2)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = pow_func(
+        x1_usm_or_scalar, x2_usm_or_scalar, out=out_usm, order=order
+    )
+    return dpnp_array._create_from_usm_ndarray(res_usm)
+
+
 _remainder_docstring_ = """
 remainder(x1, x2, out=None, order='K')
 Calculates the remainder of division for each element `x1_i` of the input array
@@ -1645,68 +1708,6 @@ def dpnp_sign(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
-_power_docstring_ = """
-power(x1, x2, out=None, order="K")
-
-Calculates `x1_i` raised to `x2_i` for each element `x1_i` of the input array
-`x1` with the respective element `x2_i` of the input array `x2`.
-
-Args:
-    x1 (dpnp.ndarray):
-        First input array, expected to have numeric data type.
-    x2 (dpnp.ndarray):
-        Second input array, also expected to have numeric data type.
-    out ({None, dpnp.ndarray}, optional):
-        Output array to populate. Array must have the correct
-        shape and the expected data type.
-    order ("C","F","A","K", None, optional):
-        Output array, if parameter `out` is `None`.
-        Default: "K".
-Returns:
-    dpnp.ndarray:
-        An array containing the result of element-wise of raising each element
-        to a specified power.
-        The data type of the returned array is determined by the Type Promotion Rules.
-"""
-
-
-def _call_pow(src1, src2, dst, sycl_queue, depends=None):
-    """A callback to register in BinaryElementwiseFunc class of dpctl.tensor"""
-
-    if depends is None:
-        depends = []
-
-    # TODO: remove this check when OneMKL is fixed on Windows
-    is_win = platform.startswith("win")
-
-    if not is_win and vmi._mkl_pow_to_call(sycl_queue, src1, src2, dst):
-        # call pybind11 extension for pow() function from OneMKL VM
-        return vmi._pow(sycl_queue, src1, src2, dst, depends)
-    return ti._pow(src1, src2, dst, sycl_queue, depends)
-
-
-pow_func = BinaryElementwiseFunc(
-    "pow", ti._pow_result_type, _call_pow, _power_docstring_
-)
-
-
-def dpnp_power(x1, x2, out=None, order="K"):
-    """
-    Invokes pow() function from pybind11 extension of OneMKL VM if possible.
-
-    Otherwise fully relies on dpctl.tensor implementation for pow() function.
-    """
-    # dpctl.tensor only works with usm_ndarray or scalar
-    x1_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x1)
-    x2_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x2)
-    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
-
-    res_usm = pow_func(
-        x1_usm_or_scalar, x2_usm_or_scalar, out=out_usm, order=order
-    )
-    return dpnp_array._create_from_usm_ndarray(res_usm)
-
-
 _sin_docstring = """
 sin(x, out=None, order='K')
 Computes sine for each element `x_i` of input array `x`.

dpnp/dpnp_iface_mathematical.py

@@ -1611,15 +1611,29 @@ def power(
     >>> dp.power(a, 3)
     array([  0,   1,   8,  27,  64, 125])
 
+    Raise the bases to different exponents.
+
     >>> b = dp.array([1.0, 2.0, 3.0, 3.0, 2.0, 1.0])
     >>> dp.power(a, b)
     array([ 0.,  1.,  8., 27., 16.,  5.])
 
+    The effect of broadcasting.
+
     >>> c = dp.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
     >>> dp.power(a, c)
     array([[ 0,  1,  8, 27, 16,  5],
            [ 0,  1,  8, 27, 16,  5]])
 
+    The ``**`` operator can be used as a shorthand for ``power`` on
+    :class:`dpnp.ndarray`.
+
+    >>> b = dp.array([1, 2, 3, 3, 2, 1])
+    >>> a = dp.arange(6)
+    >>> a ** b
+    array([ 0,  1,  8, 27, 16,  5])
+
+    Negative values raised to a non-integral value will result in ``nan``.
+
     >>> d = dp.array([-1.0, -4.0])
     >>> dp.power(d, 1.5)
     array([nan, nan])

tests/skipped_tests_gpu.tbl

@@ -36,9 +36,6 @@ tests/test_sycl_queue.py::test_modf[level_zero:gpu:0]
 tests/test_sycl_queue.py::test_1in_1out[opencl:gpu:0-trapz-data19]
 tests/test_sycl_queue.py::test_1in_1out[opencl:cpu:0-trapz-data19]
 
-tests/test_sycl_queue.py::test_out_2in_1out[opencl:gpu:0-power-data19-data29]
-tests/test_sycl_queue.py::test_out_2in_1out[level_zero:gpu:0-power-data19-data29]
-
 tests/test_umath.py::test_umaths[('divmod', 'ii')]
 tests/test_umath.py::test_umaths[('divmod', 'll')]
 tests/test_umath.py::test_umaths[('divmod', 'ff')]

tests/test_mathematical.py

@@ -274,14 +274,22 @@ def test_op_with_scalar(array, val, func, data_type, val_type):
     val_ = val_type(val)
 
     if func == "power":
-        if val_ == 0 and numpy.issubdtype(data_type, numpy.complexfloating):
+        if (
+            val_ == 0
+            and numpy.issubdtype(data_type, numpy.complexfloating)
+            and not dpnp.all(dpnp_a)
+        ):
             pytest.skip(
                 "(0j ** 0) is different: (NaN + NaNj) in dpnp and (1 + 0j) in numpy"
             )
-        elif is_cpu_device() and data_type == dpnp.complex128:
-            # TODO: discuss the bahavior with OneMKL team
+        # TODO: Remove when #1378 (dpctl) is solved
+        elif (
+            dpnp_a.dtype == dpnp.complex128
+            and dpnp_a.size >= 8
+            and not dpnp.all(dpnp_a)
+        ):
             pytest.skip(
-                "(0j ** 5) is different: (NaN + NaNj) in dpnp and (0j) in numpy"
+                "[..., 0j ** val] is different for x.size > 8: [..., NaN + NaNj] in dpnp and [..., 0 + 0j] in numpy"
             )
 
     if func == "subtract" and val_type == bool and data_type == dpnp.bool:
@@ -347,7 +355,6 @@ def test_divide_scalar(shape, dtype):
 
 @pytest.mark.parametrize("shape", [(), (3, 2)], ids=["()", "(3, 2)"])
 @pytest.mark.parametrize("dtype", get_all_dtypes())
-@pytest.mark.skip("mute until in-place support in dpctl is done")
 def test_power_scalar(shape, dtype):
     np_a = numpy.ones(shape, dtype=dtype)
     dpnp_a = dpnp.ones(shape, dtype=dtype)
@@ -970,11 +977,7 @@ def test_power(self, dtype):
         np_array2 = numpy.array(array2_data, dtype=dtype)
         expected = numpy.power(np_array1, np_array2, out=out)
 
-        if dtype is dpnp.complex128:
-            # ((0 + 0j) ** 2) == (Nan + NaNj) in dpnp and == (0 + 0j) in numpy
-            assert_allclose(expected[1:], result[1:], rtol=1e-06)
-        else:
-            assert_allclose(expected, result, rtol=1e-06)
+        assert_allclose(expected, result, rtol=1e-06)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     def test_out_dtypes(self, dtype):

tests/test_sycl_queue.py

@@ -603,7 +603,7 @@ def test_out_2in_1out(func, data1, data2, device):
     result = dpnp.empty_like(dp_out)
     getattr(dpnp, func)(x1, x2, out=result)
 
-    assert_array_equal(result, expected)
+    assert_allclose(result, expected)
 
     assert_sycl_queue_equal(result.sycl_queue, x1.sycl_queue)
     assert_sycl_queue_equal(result.sycl_queue, x2.sycl_queue)

tests/third_party/cupy/math_tests/test_arithmetic.py

@@ -9,7 +9,7 @@
 from tests.helper import has_support_aspect64
 from tests.third_party.cupy import testing
 
-float_types = [*testing.helper._float_dtypes]
+float_types = list(testing.helper._float_dtypes)
 complex_types = []
 signed_int_types = [numpy.int32, numpy.int64]
 unsigned_int_types = []

tests/third_party/cupy/testing/helper.py

@@ -1007,7 +1007,7 @@ def test_func(*args, **kw):
             for dtype in dtypes:
                 if (
                     numpy.dtype(dtype).type in (numpy.float64, numpy.complex128)
-                    and not select_default_device().has_aspect_fp64
+                    and not has_support_aspect64()
                 ):
                     continue