Fix multiply (#502)

* start change

Author: Rubtsowa

dpnp/dpnp_algo/dpnp_algo_mathematical.pyx

@@ -326,58 +326,20 @@ cpdef tuple dpnp_modf(dparray x1):
 
 
 cpdef dparray dpnp_multiply(dparray x1, x2):
-    x2_is_scalar = dpnp.isscalar(x2)
-
-    x1_dtype_ = x1.dtype
-    x2_dtype_ = type(x2) if x2_is_scalar else x2.dtype
-
-    types_map = {float: dpnp.float64, int: dpnp.int64}
-    x1_dtype = types_map.get(x1_dtype_, x1_dtype_)
-    x2_dtype = types_map.get(x2_dtype_, x2_dtype_)
-
-    if x1_dtype == dpnp.float64:
-        if x2_dtype == dpnp.float64:
-            res_type = dpnp.float64
-        elif x2_dtype == dpnp.float32:
-            res_type = dpnp.float64
-        elif x2_dtype == dpnp.int64:
-            res_type = dpnp.float64
-        elif x2_dtype == dpnp.int32:
-            res_type = dpnp.float64
-    elif x1_dtype == dpnp.float32:
-        if x2_dtype == dpnp.float64:
-            res_type = dpnp.float32
-        elif x2_dtype == dpnp.float32:
-            res_type = dpnp.float32
-        elif x2_dtype == dpnp.int64:
-            res_type = dpnp.float32
-        elif x2_dtype == dpnp.int32:
-            res_type = dpnp.float32
-    elif x1_dtype == dpnp.int64:
-        if x2_dtype == dpnp.float64:
-            res_type = dpnp.float64
-        elif x2_dtype == dpnp.float32:
-            res_type = dpnp.float32
-        elif x2_dtype == dpnp.int64:
-            res_type = dpnp.int64
-        elif x2_dtype == dpnp.int32:
-            res_type = dpnp.int64
-    elif x1_dtype == dpnp.int32:
-        if x2_dtype == dpnp.float64:
-            res_type = dpnp.float64
-        elif x2_dtype == dpnp.float32:
-            res_type = dpnp.float32
-        elif x2_dtype == dpnp.int64:
-            res_type = dpnp.int32
-        elif x2_dtype == dpnp.int32:
-            res_type = dpnp.int32
-
-    cdef dparray result = dparray(x1.shape, dtype=res_type)
-
-    if x2_is_scalar:
-        for i in range(result.size):
+    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
+        return result.reshape(x1.shape)
     else:
         return call_fptr_2in_1out(DPNP_FN_MULTIPLY, x1, x2, x1.shape)
 

dpnp/dpnp_iface_mathematical.py

@@ -966,16 +966,24 @@ def multiply(x1, x2, **kwargs):
     is_x1_scalar = dpnp.isscalar(x1)
     is_x2_scalar = dpnp.isscalar(x2)
 
-    if (not use_origin_backend(x1) and (is_x1_dparray or is_x1_scalar)) and \
-            (not use_origin_backend(x2) and (is_x2_dparray or is_x2_scalar)) and \
-            not (is_x1_scalar and is_x2_scalar) and not kwargs:
-
-        if is_x1_scalar:
-            return dpnp_multiply(x2, x1)
+    if not use_origin_backend(x1):
+        if kwargs:
+            pass
+        elif not (is_x1_dparray or is_x1_scalar):
+            pass
+        elif not (is_x2_dparray or is_x2_scalar):
+            pass
+        elif is_x1_scalar and is_x2_scalar:
+            pass
+        elif (is_x1_dparray and is_x2_dparray) and (x1.size != x2.size):
+            pass
+        elif (is_x1_dparray and is_x2_dparray) and (x1.shape != x2.shape):
+            pass
         else:
-            if is_x1_dparray and is_x2_dparray:
-                if (x1.size == x2.size) and (x1.shape == x2.shape):
-                    return dpnp_multiply(x1, x2)
+            if is_x1_scalar:
+                return dpnp_multiply(x2, x1)
+            else:
+                 return dpnp_multiply(x1, x2)
 
     return call_origin(numpy.multiply, x1, x2, **kwargs)
 

tests/test_mathematical.py

@@ -26,6 +26,35 @@ def test_diff(array):
     numpy.testing.assert_allclose(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_multiply(array, val, data_type, val_type):
+    a = numpy.array(array, dtype=data_type)
+    ia = inp.array(a)
+    val_ = val_type(val)
+    result = inp.multiply(ia, val_)
+    expected = numpy.multiply(ia, val_)
+    numpy.testing.assert_array_equal(expected, result)
+
+
 @pytest.mark.parametrize("array", [[1, 2, 3, 4, 5],
                                    [1, 2, numpy.nan, 4, 5],
                                    [[1, 2, numpy.nan], [3, -4, -5]]])