address comments

Author: Vahid Tavanashad

dpnp/dpnp_iface_functional.py

@@ -373,6 +373,7 @@ def piecewise(x, condlist, funclist):
         funclen = len(funclist)
     except TypeError as e:
         raise TypeError("funclist must be a sequence of scalars") from e
+
     if condlen == funclen:
         # default value is zero
         default_value = x_dtype.type(0)
@@ -384,11 +385,10 @@ def piecewise(x, condlist, funclist):
                 "Callable functions are not supported currently"
             )
         if isinstance(default_value, dpnp.ndarray):
-            default_value = default_value.astype(x_dtype)
+            default_value = default_value.astype(x_dtype, copy=False)
         else:
             default_value = x_dtype.type(default_value)
         funclist = funclist[:-1]
-
     else:
         raise ValueError(
             f"with {condlen} condition(s), either {condlen} or {condlen + 1} "
@@ -401,7 +401,7 @@ def piecewise(x, condlist, funclist):
                 "Callable functions are not supported currently"
             )
         if isinstance(func, dpnp.ndarray):
-            func = func.astype(x_dtype)
+            func = func.astype(x_dtype, copy=False)
         else:
             func = x_dtype.type(func)
         dpnp.where(condition, func, default_value, out=result)

dpnp/tests/test_functional.py

@@ -161,70 +161,6 @@ def test_simple(self):
         result = dpnp.piecewise(ia, (True, False), [1])
         assert_array_equal(result, expected)
 
-    def test_error_dpnp(self):
-        ia = dpnp.array([0, 0])
-        # values cannot be a callable function
-        assert_raises_regex(
-            NotImplementedError,
-            "Callable functions are not supported currently",
-            dpnp.piecewise,
-            ia,
-            [dpnp.array([True, False])],
-            [lambda x: -1],
-        )
-
-        # default value cannot be a callable function
-        assert_raises_regex(
-            NotImplementedError,
-            "Callable functions are not supported currently",
-            dpnp.piecewise,
-            ia,
-            [dpnp.array([True, False])],
-            [-1, lambda x: 1],
-        )
-
-        # funclist is not array-like
-        assert_raises_regex(
-            TypeError,
-            "funclist must be a sequence of scalars",
-            dpnp.piecewise,
-            ia,
-            [dpnp.array([True, False])],
-            1,
-        )
-
-        assert_raises_regex(
-            TypeError,
-            "object of type",
-            numpy.piecewise,
-            ia.asnumpy(),
-            [numpy.array([True, False])],
-            1,
-        )
-
-    @pytest.mark.parametrize("xp", [dpnp, numpy])
-    def test_error(self, xp):
-        ia = xp.array([0, 0])
-        # not enough functions
-        assert_raises_regex(
-            ValueError,
-            "1 or 2 functions are expected",
-            xp.piecewise,
-            ia,
-            [xp.array([True, False])],
-            [],
-        )
-
-        # extra function
-        assert_raises_regex(
-            ValueError,
-            "1 or 2 functions are expected",
-            xp.piecewise,
-            ia,
-            [xp.array([True, False])],
-            [1, 2, 3],
-        )
-
     def test_two_conditions(self):
         a = numpy.array([1, 2])
         ia = dpnp.array(a)
@@ -316,3 +252,87 @@ def test_multidimensional_extrafunc(self):
         expected = numpy.piecewise(a, [a < 0, a >= 2], [-1, 1, 3])
         result = dpnp.piecewise(ia, [ia < 0, ia >= 2], [-1, 1, 3])
         assert_array_equal(result, expected)
+
+    def test_error_dpnp(self):
+        ia = dpnp.array([0, 0])
+        # values cannot be a callable function
+        assert_raises_regex(
+            NotImplementedError,
+            "Callable functions are not supported currently",
+            dpnp.piecewise,
+            ia,
+            [dpnp.array([True, False])],
+            [lambda x: -1],
+        )
+
+        # default value cannot be a callable function
+        assert_raises_regex(
+            NotImplementedError,
+            "Callable functions are not supported currently",
+            dpnp.piecewise,
+            ia,
+            [dpnp.array([True, False])],
+            [-1, lambda x: 1],
+        )
+
+        # funclist is not array-like
+        assert_raises_regex(
+            TypeError,
+            "funclist must be a sequence of scalars",
+            dpnp.piecewise,
+            ia,
+            [dpnp.array([True, False])],
+            1,
+        )
+
+        # funclist is a string
+        assert_raises_regex(
+            TypeError,
+            "funclist must be a sequence of scalars",
+            dpnp.piecewise,
+            ia,
+            [ia > 0],
+            "q",
+        )
+
+        assert_raises_regex(
+            TypeError,
+            "object of type",
+            numpy.piecewise,
+            ia.asnumpy(),
+            [numpy.array([True, False])],
+            1,
+        )
+
+    @pytest.mark.parametrize("xp", [dpnp, numpy])
+    def test_error(self, xp):
+        ia = xp.array([0, 0])
+        # not enough functions
+        assert_raises_regex(
+            ValueError,
+            "1 or 2 functions are expected",
+            xp.piecewise,
+            ia,
+            [xp.array([True, False])],
+            [],
+        )
+
+        # extra function
+        assert_raises_regex(
+            ValueError,
+            "1 or 2 functions are expected",
+            xp.piecewise,
+            ia,
+            [xp.array([True, False])],
+            [1, 2, 3],
+        )
+
+        # condlist is empty
+        assert_raises_regex(
+            IndexError,
+            "index out of range",
+            xp.piecewise,
+            ia,
+            [],
+            [1, 2],
+        )

dpnp/tests/test_usm_type.py

@@ -755,17 +755,21 @@ def test_apply_over_axes(usm_type):
     assert x.usm_type == y.usm_type
 
 
-@pytest.mark.parametrize("usm_type", list_of_usm_types)
-def test_piecewise(usm_type):
-    x = dpnp.array([0, 0], usm_type=usm_type)
-    y = dpnp.array([True, False], usm_type=usm_type)
-    z = dpnp.array([1, -1], usm_type=usm_type)
+@pytest.mark.parametrize("usm_type_x", list_of_usm_types)
+@pytest.mark.parametrize("usm_type_y", list_of_usm_types)
+@pytest.mark.parametrize("usm_type_z", list_of_usm_types)
+def test_piecewise(usm_type_x, usm_type_y, usm_type_z):
+    x = dpnp.array([0, 0], usm_type=usm_type_x)
+    y = dpnp.array([True, False], usm_type=usm_type_y)
+    z = dpnp.array([1, -1], usm_type=usm_type_z)
     result = dpnp.piecewise(x, y, z)
-    res_usm_type = result.usm_type
 
-    assert x.usm_type == res_usm_type
-    assert y.usm_type == res_usm_type
-    assert z.usm_type == res_usm_type
+    assert x.usm_type == usm_type_x
+    assert y.usm_type == usm_type_y
+    assert z.usm_type == usm_type_z
+    assert result.usm_type == du.get_coerced_usm_type(
+        [usm_type_x, usm_type_y, usm_type_z]
+    )
 
 
 @pytest.mark.parametrize(