fix review

Author: jharlow-intel

dpnp/dpnp_broadcast.py

@@ -29,7 +29,6 @@
 """Implementation of broadcast class."""
 
 import dpnp
-import dpnp.tensor as dpt
 from dpnp.tensor._manipulation_functions import _broadcast_shapes
 
 
@@ -41,16 +40,15 @@ class broadcast:
 
     Parameters
     ----------
-    *args : object
-        Input parameters. Every argument must define ``shape`` attribute.
+    *args : {dpnp.ndarray, usm_ndarray}
+        Input arrays to broadcast against one another.
 
     Returns
     -------
     broadcast : broadcast object
         Broadcast the input parameters against one another, and
         return an object that encapsulates the result.
-        Amongst others, it has ``shape`` and ``nd`` properties, and
-        may be used as an iterator.
+        Amongst others, it has ``shape`` and ``nd`` properties.
 
     See Also
     --------
@@ -73,32 +71,22 @@ class broadcast:
     >>> b.size
     9
 
+    Limitations
+    -----------
+    Input arrays are not coerced, so array-like objects and scalars are not
+    supported and ``TypeError`` exception will be raised.
+
     Notes
     -----
     Iterator functionality is not supported.
 
     """
 
     def __init__(self, *args):
-        for i, arg in enumerate(args):
-            if not hasattr(arg, "shape"):
-                raise TypeError(
-                    f"Argument at position {i} must define shape attribute"
-                )
+        dpnp.check_supported_arrays_type(*args)
 
         self._arrays = tuple(args)
 
-        dpnp_arrays = [arg for arg in self._arrays if isinstance(arg, dpnp.ndarray)]
-        if len(dpnp_arrays) > 1:
-            exec_q = dpt.get_execution_queue(
-                tuple(array.sycl_queue for array in dpnp_arrays)
-            )
-            if exec_q is None:
-                raise dpt.ExecutionPlacementError(
-                    "Execution placement can not be unambiguously inferred "
-                    "from input arguments."
-                )
-
         if len(self._arrays) == 0:
             self._shape = ()
             self._size = 1

dpnp/tests/test_manipulation.py

@@ -24,8 +24,8 @@
     get_unsigned_dtypes,
     has_support_aspect64,
 )
-from .third_party.cupy import testing
 from .tensor.helper import get_queue_or_skip
+from .third_party.cupy import testing
 
 
 def _compare_results(result, expected):
@@ -307,7 +307,7 @@ def test_no_copy(self):
         assert_array_equal(b, a)
 
 
-class TestBroadcast:
+class TestBroadcastShapes:
     @pytest.mark.parametrize(
         "shape",
         [
@@ -2095,12 +2095,14 @@ def test_broadcast_three_arrays(self):
         assert bc.numiter == 3
 
     def test_broadcast_ndim_property(self):
-        # Test that ndim property equals nd property
+        # Test that ndim property matches numpy and equals nd property
         a = dpnp.array([[1, 2], [3, 4]])
         b = dpnp.array([5, 6])
 
         bc = dpnp.broadcast(a, b)
+        bc_np = numpy.broadcast(a.asnumpy(), b.asnumpy())
 
+        assert bc.ndim == bc_np.ndim
         assert bc.ndim == bc.nd
 
     def test_broadcast_complex_shapes(self):
@@ -2116,13 +2118,19 @@ def test_broadcast_complex_shapes(self):
         assert bc.nd == bc_np.nd
         assert bc.size == bc_np.size
 
-    def test_broadcast_with_array_like(self):
-        # Conversion from array-like inputs is not implemented for broadcast yet.
+    @pytest.mark.parametrize(
+        "arg",
+        [[[1], [2]], 3, numpy.ones((2, 1))],
+        ids=["list", "scalar", "numpy"],
+    )
+    def test_broadcast_unsupported_type(self, arg):
+        # unlike numpy, input arrays are not coerced, so array-like objects,
+        # scalars and host arrays are rejected the same way as they are by
+        # dpnp.broadcast_to and dpnp.broadcast_arrays
         a = dpnp.array([1, 2, 3])
-        b = [[1], [2]]
 
         with pytest.raises(TypeError):
-            dpnp.broadcast(a, b)
+            dpnp.broadcast(a, arg)
 
     @pytest.mark.parametrize(
         "shapes",
@@ -2171,21 +2179,20 @@ def test_broadcast_no_args(self):
         assert bc.size == 1
         assert bc.numiter == 0
 
-    def test_broadcast_argument_without_shape(self):
-        a = dpnp.array([1, 2, 3])
-
-        with pytest.raises(TypeError):
-            dpnp.broadcast(a, 3)
-
-    def test_broadcast_compute_follows_data(self):
+    def test_broadcast_different_queues(self):
+        # Broadcasting is a shape-only query, so inputs are not required
+        # to share a common execution placement
         q1 = get_queue_or_skip()
         q2 = get_queue_or_skip()
 
         a = dpt.ones((2, 1), sycl_queue=q1)
         b = dpt.ones((1, 2), sycl_queue=q2)
 
-        with pytest.raises(dpt.ExecutionPlacementError):
-            dpnp.broadcast(a, b)
+        bc = dpnp.broadcast(a, b)
+
+        assert bc.shape == (2, 2)
+        assert bc.size == 4
+        assert bc.nd == 2
 
     def test_broadcast_repr(self):
         # Test __repr__ method