Return scalar, if both inputs are scalars

Author: antonwolfy

dpnp/dpnp_iface_mathematical.py

@@ -1091,12 +1091,13 @@ def multiply(x1,
 
     Returns
     -------
-    y : dpnp.ndarray
+    y : {dpnp.ndarray, scalar}
         The product of `x1` and `x2`, element-wise.
+        The result is a scalar if both x1 and x2 are scalars.
 
     Limitations
     -----------
-    Parameters ``x1`` and ``x2`` are supported as either :class:`dpnp.ndarray` or scalar.
+    Parameters `x1` and `x2` are supported as either :class:`dpnp.ndarray` or scalar.
     Parameters ``out``, ``where``, ``dtype`` and ``subok`` are supported with their default values.
     Keyword arguments ``kwargs`` are currently unsupported.
     Otherwise the functions will be executed sequentially on CPU.
@@ -1120,6 +1121,9 @@ def multiply(x1,
         pass
     elif subok is not True:
         pass
+    elif dpnp.isscalar(x1) and dpnp.isscalar(x2):
+        # keep the result in host memory, if both inputs are scalars
+        return x1 * x2
     else:
         # get a common queue to copy data from the host into a device if any input is scalar
         queue = get_common_allocation_queue([x1, x2]) if dpnp.isscalar(x1) or dpnp.isscalar(x2) else None

tests/third_party/cupy/math_tests/test_arithmetic.py

@@ -145,27 +145,31 @@ def check_binary(self, xp):
                 y = y.astype(numpy.complex64)
 
         # NumPy returns an output array of another type than DPNP when input ones have diffrent types.
-        if self.name == 'multiply' and xp is cupy and dtype1 != dtype2:
-            is_array_arg1 = not xp.isscalar(arg1)
-            is_array_arg2 = not xp.isscalar(arg2)
-
-            is_int_float = lambda _x, _y: numpy.issubdtype(_x, numpy.integer) and numpy.issubdtype(_y, numpy.floating)
-            is_same_type = lambda _x, _y, _type: numpy.issubdtype(_x, _type) and numpy.issubdtype(_y, _type)
-
-            if is_array_arg1 and is_array_arg2:
-                # If both inputs are arrays where one is of floating type and another - integer,
-                # NumPy will return an output array of always "float64" type,
-                # while DPNP will return the array of a wider type from the input arrays.
-                if is_int_float(dtype1, dtype2) or is_int_float(dtype2, dtype1):
-                    y = y.astype(numpy.float64)
-            elif is_same_type(dtype1, dtype2, numpy.floating) or is_same_type(dtype1, dtype2, numpy.integer):
-                # If one input is an array and another - scalar,
-                # NumPy will return an output array of the same type as the inpupt array has,
-                # while DPNP will return the array of a wider type from the inputs (considering both array and scalar).
-                if is_array_arg1 and not is_array_arg2:
-                    y = y.astype(dtype1)
-                elif is_array_arg2 and not is_array_arg1:
-                    y = y.astype(dtype2)
+        if self.name == 'multiply' and xp is cupy:
+            if xp.isscalar(arg1) and xp.isscalar(arg2):
+                # If both are scalars, the result will be a scalar, so needs to convert into numpy-scalar.
+                y = numpy.asarray(y)
+            elif dtype1 != dtype2:
+                is_array_arg1 = not xp.isscalar(arg1)
+                is_array_arg2 = not xp.isscalar(arg2)
+
+                is_int_float = lambda _x, _y: numpy.issubdtype(_x, numpy.integer) and numpy.issubdtype(_y, numpy.floating)
+                is_same_type = lambda _x, _y, _type: numpy.issubdtype(_x, _type) and numpy.issubdtype(_y, _type)
+
+                if is_array_arg1 and is_array_arg2:
+                    # If both inputs are arrays where one is of floating type and another - integer,
+                    # NumPy will return an output array of always "float64" type,
+                    # while DPNP will return the array of a wider type from the input arrays.
+                    if is_int_float(dtype1, dtype2) or is_int_float(dtype2, dtype1):
+                        y = y.astype(numpy.float64)
+                elif is_same_type(dtype1, dtype2, numpy.floating) or is_same_type(dtype1, dtype2, numpy.integer):
+                    # If one input is an array and another - scalar,
+                    # NumPy will return an output array of the same type as the inpupt array has,
+                    # while DPNP will return the array of a wider type from the inputs (considering both array and scalar).
+                    if is_array_arg1 and not is_array_arg2:
+                        y = y.astype(dtype1)
+                    elif is_array_arg2 and not is_array_arg1:
+                        y = y.astype(dtype2)
 
         # NumPy returns different values (nan/inf) on division by zero
         # depending on the architecture.