Add a special handling for fix() and round() ufuncs

Author: antonwolfy

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -199,19 +199,25 @@ def __call__(
         if dtype is not None:
             x_usm = dpt.astype(x_usm, dtype, copy=False)
 
-        if isinstance(out, tuple):
-            if len(out) != self.nout:
-                raise ValueError(
-                    "'out' tuple must have exactly one entry per ufunc output"
-                )
-            out = out[0]
+        out = self._unpack_out_kw(out)
         out_usm = None if out is None else dpnp.get_usm_ndarray(out)
 
         res_usm = super().__call__(x_usm, out=out_usm, order=order)
         if out is not None and isinstance(out, dpnp_array):
             return out
         return dpnp_array._create_from_usm_ndarray(res_usm)
 
+    def _unpack_out_kw(self, out):
+        """Unpack `out` keyword if passed as a tuple."""
+
+        if isinstance(out, tuple):
+            if len(out) != self.nout:
+                raise ValueError(
+                    "'out' tuple must have exactly one entry per ufunc output"
+                )
+            return out[0]
+        return out
+
 
 class DPNPUnaryTwoOutputsFunc(UnaryElementwiseFunc):
     """
@@ -819,15 +825,22 @@ def __call__(self, x, /, out=None, *, order="K"):
             pass  # pass to raise error in main implementation
         elif dpnp.issubdtype(x.dtype, dpnp.inexact):
             pass  # for inexact types, pass to calculate in the backend
-        elif out is not None and not dpnp.is_supported_array_type(out):
+        elif not (
+            out is None
+            or isinstance(out, tuple)
+            or dpnp.is_supported_array_type(out)
+        ):
             pass  # pass to raise error in main implementation
-        elif out is not None and out.dtype != x.dtype:
+        elif not (
+            out is None or isinstance(out, tuple) or out.dtype == x.dtype
+        ):
             # passing will raise an error but with incorrect needed dtype
             raise ValueError(
                 f"Output array of type {x.dtype} is needed, got {out.dtype}"
             )
         else:
             # for exact types, return the input
+            out = self._unpack_out_kw(out)
             if out is None:
                 return dpnp.copy(x, order=order)
 
@@ -932,6 +945,7 @@ def __init__(
     def __call__(self, x, /, decimals=0, out=None, *, dtype=None):
         if decimals != 0:
             x_usm = dpnp.get_usm_ndarray(x)
+            out = self._unpack_out_kw(out)
             out_usm = None if out is None else dpnp.get_usm_ndarray(out)
 
             if dpnp.issubdtype(x_usm.dtype, dpnp.integer):

dpnp/tests/test_mathematical.py

@@ -2010,14 +2010,17 @@ def test_out_dtype(self, func):
             fn(*args, out=out, dtype="f4")
 
     @pytest.mark.parametrize("xp", [numpy, dpnp])
-    @pytest.mark.parametrize("func", ["abs", "add", "frexp"])
+    @pytest.mark.parametrize("func", ["abs", "fix", "round", "add", "frexp"])
     def test_out_wrong_tuple_len(self, xp, func):
+        if func == "round" and xp is numpy:
+            pytest.skip("numpy.round(x, out=(...)) is not supported")
+
         x = xp.array([1, 2, 3])
 
         fn = getattr(xp, func)
-        args = [x] * fn.nin
+        args = [x] * getattr(fn, "nin", getattr(dpnp, func).nin)
 
-        nout = fn.nout
+        nout = getattr(fn, "nout", getattr(dpnp, func).nout)
         outs = [(), tuple(range(nout + 1))]
         if nout > 1:
             outs.append(tuple(range(nout - 1)))