Fix power (#500)

* change power

Author: Rubtsowa

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -238,7 +238,7 @@ cpdef dparray dpnp_maximum(dparray array1, dparray array2)
 cpdef dparray dpnp_minimum(dparray array1, dparray array2)
 cpdef dparray dpnp_multiply(dparray array1, array2)
 cpdef dparray dpnp_negative(dparray array1)
-cpdef dparray dpnp_power(dparray array1, dparray array2)
+cpdef dparray dpnp_power(dparray array1, array2)
 cpdef dparray dpnp_remainder(dparray array1, dparray array2)
 cpdef dparray dpnp_sin(dparray array1)
 cpdef dparray dpnp_subtract(dparray array1, dparray array2)

dpnp/dpnp_algo/dpnp_algo_mathematical.pyx

@@ -422,8 +422,24 @@ cpdef dparray dpnp_negative(dparray array1):
     return result
 
 
-cpdef dparray dpnp_power(dparray x1, dparray x2):
-    return call_fptr_2in_1out(DPNP_FN_POWER, x1, x2, x1.shape)
+cpdef dparray dpnp_power(dparray x1, x2):
+    cdef dparray result
+    if dpnp.isscalar(x2):
+        x2_ = dpnp.array([x2])
+
+        types_map = {
+            (dpnp.int32, dpnp.float64): dpnp.float64,
+            (dpnp.int64, dpnp.float64): dpnp.float64,
+        }
+
+        res_type = types_map.get((x1.dtype.type, x2_.dtype.type), x1.dtype)
+
+        result = dparray(x1.shape, dtype=res_type)
+        for i in range(x1.size):
+            result[i] = x1[i] ** x2
+        return result
+    else:
+        return call_fptr_2in_1out(DPNP_FN_POWER, x1, x2, x1.shape)
 
 
 cpdef dpnp_prod(dparray x1):

dpnp/dpnp_iface_mathematical.py

@@ -1183,17 +1183,19 @@ def power(x1, x2, **kwargs):
 
     """
 
-    is_x1_dparray = isinstance(x1, dparray)
-    is_x2_dparray = isinstance(x2, dparray)
-
-    if (not use_origin_backend(x1) and is_x1_dparray and is_x2_dparray and not kwargs):
-        if (x1.size != x2.size):
-            checker_throw_value_error("power", "size", x1.size, x2.size)
-
-        if (x1.shape != x2.shape):
-            checker_throw_value_error("power", "shape", x1.shape, x2.shape)
-
-        return dpnp_power(x1, x2)
+    if not use_origin_backend(x1):
+        if kwargs:
+            pass
+        elif not isinstance(x1, dparray):
+            pass
+        elif not isinstance(x2, dparray) and not dpnp.isscalar(x2):
+            pass
+        elif isinstance(x2, dparray) and x1.size != x2.size:
+            pass
+        elif isinstance(x2, dparray) and x1.shape != x2.shape:
+            pass
+        else:
+            return dpnp_power(x1, x2)
 
     return call_origin(numpy.power, x1, x2, **kwargs)
 

tests/test_mathematical.py

@@ -50,6 +50,35 @@ def test_nancumsum(array):
     numpy.testing.assert_array_equal(expected, result)
 
 
+@pytest.mark.parametrize("val_type",
+                         [numpy.float64, numpy.float32, numpy.int64, numpy.int32],
+                         ids=['numpy.float64', 'numpy.float32', 'numpy.int64', 'numpy.int32'])
+@pytest.mark.parametrize("data_type",
+                         [numpy.float64, numpy.float32, numpy.int64, numpy.int32],
+                         ids=['numpy.float64', 'numpy.float32', 'numpy.int64', 'numpy.int32'])
+@pytest.mark.parametrize("val",
+                         [0, 1, 5],
+                         ids=['0', '1', '5'])
+@pytest.mark.parametrize("array",
+                         [[[0, 0], [0, 0]],
+                          [[1, 2], [1, 2]],
+                          [[1, 2], [3, 4]],
+                          [[[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]]],
+                          [[[[1, 2], [3, 4]], [[1, 2], [2, 1]]], [[[1, 3], [3, 1]], [[0, 1], [1, 3]]]]],
+                         ids=['[[0, 0], [0, 0]]',
+                              '[[1, 2], [1, 2]]',
+                              '[[1, 2], [3, 4]]',
+                              '[[[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]]]',
+                              '[[[[1, 2], [3, 4]], [[1, 2], [2, 1]]], [[[1, 3], [3, 1]], [[0, 1], [1, 3]]]]'])
+def test_power(array, val, data_type, val_type):
+    a = numpy.array(array, dtype=data_type)
+    ia = inp.array(a)
+    val_ = val_type(val)
+    result = inp.power(ia, val_)
+    expected = numpy.power(ia, val_)
+    numpy.testing.assert_array_equal(expected, result)
+
+
 class TestEdiff1d:
 
     def test_ediff1d_int(self):