address comments

Author: Vahid Tavanashad

CHANGELOG.md

@@ -27,6 +27,8 @@ This release achieves 100% compliance with Python Array API specification (revis
 * Updated `dpnp.einsum` to add support for `order=None` [#2411](https://github.com/IntelPython/dpnp/pull/2411)
 * Updated Python Array API specification version supported to `2024.12` [#2416](https://github.com/IntelPython/dpnp/pull/2416)
 * Removed `einsum_call` keyword from `dpnp.einsum_path` signature [#2421](https://github.com/IntelPython/dpnp/pull/2421)
+* Updated `dpnp.vdot` to return a 0-D array when one of the inputs is a scalar [#2295](https://github.com/IntelPython/dpnp/pull/2295)
+* Updated `dpnp.outer` to return the same dtype as NumPy when multiplying an array with a scalar [#2295](https://github.com/IntelPython/dpnp/pull/2295)
 
 ### Fixed
 

dpnp/dpnp_iface_linearalgebra.py

@@ -71,18 +71,17 @@
 # TODO: implement a specific scalar-array kernel
 def _call_multiply(a, b, out=None, outer_calc=False):
     """
-    Call multiply function for special cases of scalar-array dots.
-
-    if `sc` is an scalar and `a` is an array of type float32, we have
-    dpnp.multiply(a, sc).dtype == dpnp.float32 and
-    numpy.multiply(a, sc).dtype == dpnp.float32.
-
-    However, for scalar-array dots such as dot function we have
-    dpnp.dot(a, sc).dtype == dpnp.float32 while
-    numpy.dot(a, sc).dtype == dpnp.float64.
-
-    We need to adjust the behavior of the multiply function when it is
-    used for special cases of scalar-array dots.
+    Adjusted multiply function for handling special cases of scalar-array dot
+    products in linear algebra.
+
+    `dpnp.multiply` cannot directly be used for calculating scalar-array dots,
+    because the output dtype of multiply is not the same as the expected dtype
+    for scalar-array dots. For example, if `sc` is an scalar and `a` is an
+    array of type `float32`, then `dpnp.multiply(a, sc).dtype == dpnp.float32`
+    (similar to NumPy). However, for scalar-array dots, such as the dot
+    function, we need `dpnp.dot(a, sc).dtype == dpnp.float64` to align with
+    NumPy. This functions adjusts the behavior of `dpnp.multiply` function to
+    meet this requirement.
 
     """
 

dpnp/tests/helper.py

@@ -18,6 +18,7 @@ def _assert_dtype(a_dt, b_dt, check_only_type_kind=False):
 
 
 def _assert_shape(a, b):
+    # it is assumed `a` is a `dpnp.ndarray` and so it has shape attribute
     if hasattr(b, "shape"):
         assert a.shape == b.shape, f"{a.shape} != {b.shape}"
     else:

dpnp/tests/test_dlpack.py

@@ -40,7 +40,6 @@ def test_dtype_passthrough(self, xp, dt):
         x = xp.arange(5).astype(dt)
         y = xp.from_dlpack(x)
 
-        assert y.dtype == x.dtype
         assert_array_equal(x, y)
 
     @pytest.mark.parametrize("xp", [dpnp, numpy])

dpnp/tests/test_linalg.py

@@ -422,13 +422,9 @@ def test_det_empty(self):
         a = numpy.empty((0, 0, 2, 2), dtype=numpy.float32)
         ia = dpnp.array(a)
 
-        np_det = numpy.linalg.det(a)
-        dpnp_det = dpnp.linalg.det(ia)
-
-        assert dpnp_det.dtype == np_det.dtype
-        assert dpnp_det.shape == np_det.shape
-
-        assert_allclose(dpnp_det, np_det)
+        expected = numpy.linalg.det(a)
+        result = dpnp.linalg.det(ia)
+        assert_allclose(result, expected)
 
     @pytest.mark.parametrize(
         "matrix",
@@ -2851,25 +2847,6 @@ def get_tol(self, dtype):
             tol = 1e-03
         self._tol = tol
 
-    def check_types_shapes(
-        self, dp_u, dp_s, dp_vt, np_u, np_s, np_vt, compute_vt=True
-    ):
-        if has_support_aspect64():
-            if compute_vt:
-                assert dp_u.dtype == np_u.dtype
-                assert dp_vt.dtype == np_vt.dtype
-            assert dp_s.dtype == np_s.dtype
-        else:
-            if compute_vt:
-                assert dp_u.dtype.kind == np_u.dtype.kind
-                assert dp_vt.dtype.kind == np_vt.dtype.kind
-            assert dp_s.dtype.kind == np_s.dtype.kind
-
-        if compute_vt:
-            assert dp_u.shape == np_u.shape
-            assert dp_vt.shape == np_vt.shape
-        assert dp_s.shape == np_s.shape
-
     # Checks the accuracy of singular value decomposition (SVD).
     # Compares the reconstructed matrix from the decomposed components
     # with the original matrix.
@@ -2922,7 +2899,6 @@ def test_svd(self, dtype, shape):
         result = dpnp.linalg.svd(dp_a)
         dp_u, dp_s, dp_vh = result.U, result.S, result.Vh
 
-        self.check_types_shapes(dp_u, dp_s, dp_vh, np_u, np_s, np_vh)
         self.get_tol(dtype)
         self.check_decomposition(
             dp_a, dp_u, dp_s, dp_vh, np_u, np_s, np_vh, True
@@ -2950,10 +2926,6 @@ def test_svd_hermitian(self, dtype, compute_vt, shape):
             dp_s = dpnp.linalg.svd(dp_a, compute_uv=compute_vt, hermitian=True)
             np_u = np_vh = dp_u = dp_vh = None
 
-        self.check_types_shapes(
-            dp_u, dp_s, dp_vh, np_u, np_s, np_vh, compute_vt
-        )
-
         self.get_tol(dtype)
 
         self.check_decomposition(
@@ -3029,14 +3001,6 @@ def get_tol(self, dtype):
             tol = 1e-03
         self._tol = tol
 
-    def check_types_shapes(self, dp_B, np_B):
-        if has_support_aspect64():
-            assert dp_B.dtype == np_B.dtype
-        else:
-            assert dp_B.dtype.kind == np_B.dtype.kind
-
-        assert dp_B.shape == np_B.shape
-
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
     @pytest.mark.parametrize(
         "shape",
@@ -3058,7 +3022,6 @@ def test_pinv(self, dtype, shape):
         B = numpy.linalg.pinv(a)
         B_dp = dpnp.linalg.pinv(a_dp)
 
-        self.check_types_shapes(B_dp, B)
         self.get_tol(dtype)
         tol = self._tol
         assert_allclose(B_dp, B, rtol=tol, atol=tol)
@@ -3083,7 +3046,6 @@ def test_pinv_hermitian(self, dtype, shape):
         B = numpy.linalg.pinv(a, hermitian=True)
         B_dp = dpnp.linalg.pinv(a_dp, hermitian=True)
 
-        self.check_types_shapes(B_dp, B)
         self.get_tol(dtype)
         tol = self._tol
 

dpnp/tests/test_manipulation.py

@@ -1089,7 +1089,6 @@ def test_non_array_input(self):
         assert expected.flags["C"] == result.flags["C"]
         assert expected.flags["F"] == result.flags["F"]
         assert expected.flags["W"] == result.flags["W"]
-        assert expected.dtype == result.dtype
         assert_array_equal(result, expected)
 
     def test_C_and_F_simul(self):

dpnp/tests/test_sort.py

@@ -407,7 +407,6 @@ def test_complex(self, dtype):
         result = dpnp.sort_complex(ia)
         expected = numpy.sort_complex(a)
         assert_equal(result, expected)
-        assert result.dtype == expected.dtype
 
 
 @pytest.mark.parametrize("kth", [0, 1])

dpnp/tests/testing/array.py

@@ -50,9 +50,9 @@ def _assert(assert_func, result, expected, *args, **kwargs):
     # For numpy < 2.0, some tests will fail for dtype mismatch
     dev = dpctl.select_default_device()
     if numpy.__version__ >= "2.0.0" and dev.has_aspect_fp64:
-        kwargs.setdefault("strict", True)
+        strict = kwargs.setdefault("strict", True)
         if flag:
-            if kwargs.get("strict"):
+            if strict:
                 if hasattr(expected, "dtype"):
                     assert (
                         result.dtype == expected.dtype