improve coverage

Author: vtavana

dpnp/dpnp_utils/dpnp_utils_linearalgebra.py

@@ -244,6 +244,7 @@ def _get_result_shape(x1, x2, out, func, np_flag):
             x1, x2, x1_ndim, x2_ndim
         )
     else:  # func == "vecdot"
+        assert func == "vecdot"
         x1, x2, result_shape = _get_result_shape_vecdot(
             x1, x2, x1_ndim, x2_ndim
         )
@@ -466,11 +467,15 @@ def _gemm_matmul(exec_q, x1, x2, res):
 
 
 def _shape_error(shape1, shape2, func, err_msg):
+    """Validate the shapes of input and output arrays."""
 
     if func == "matmul":
         signature = "(n?,k),(k,m?)->(n?,m?)"
-    else:  # func == "vecdot"
+    elif func == "vecdot":
         signature = "(n?,),(n?,)->()"
+    else:
+        # applicable when err_msg == 3
+        assert func is None
 
     if err_msg == 0:
         raise ValueError(
@@ -485,7 +490,8 @@ def _shape_error(shape1, shape2, func, err_msg):
             f"array has shape {shape2}. "
             f"These cannot be broadcast together for '{func}' function."
         )
-    elif err_msg == 2:
+    else:  # err_msg == 2:
+        assert err_msg == 2
         raise ValueError(
             f"Expected output array of shape {shape1}, but got {shape2}."
         )
@@ -557,6 +563,7 @@ def _validate_internal(axes, i, ndim):
         x1_ndim = x1.ndim
         x2_ndim = x2.ndim
     else:  # func == "vecdot"
+        assert func == "vecdot"
         x1_ndim = x2_ndim = 1
 
     axes[0] = _validate_internal(axes[0], 0, x1_ndim)
@@ -573,6 +580,16 @@ def _validate_internal(axes, i, ndim):
     return axes
 
 
+def _validate_out_array(out, exec_q):
+    """Validate out is supported array and has correct queue."""
+    if out is not None:
+        dpnp.check_supported_arrays_type(out)
+        if dpctl.utils.get_execution_queue((exec_q, out.sycl_queue)) is None:
+            raise ExecutionPlacementError(
+                "Input and output allocation queues are not compatible"
+            )
+
+
 def dpnp_cross(a, b, cp):
     """Return the cross product of two (arrays of) vectors."""
 
@@ -660,13 +677,7 @@ def dpnp_dot(a, b, /, out=None, *, conjugate=False):
         )
 
     res_usm_type, exec_q = get_usm_allocations([a, b])
-    if (
-        out is not None
-        and dpctl.utils.get_execution_queue((exec_q, out.sycl_queue)) is None
-    ):
-        raise ExecutionPlacementError(
-            "Input and output allocation queues are not compatible"
-        )
+    _validate_out_array(out, exec_q)
 
     # Determine the appropriate data types
     dot_dtype, res_dtype = _compute_res_dtype(a, b, sycl_queue=exec_q)
@@ -755,19 +766,17 @@ def dpnp_matmul(
 
     dpnp.check_supported_arrays_type(x1, x2)
     res_usm_type, exec_q = get_usm_allocations([x1, x2])
-    if out is not None:
-        dpnp.check_supported_arrays_type(out)
-        if dpctl.utils.get_execution_queue((exec_q, out.sycl_queue)) is None:
-            raise ExecutionPlacementError(
-                "Input and output allocation queues are not compatible"
-            )
+    _validate_out_array(out, exec_q)
 
-    if order in ["a", "A"]:
+    if order in "aA":
         if x1.flags.fnc and x2.flags.fnc:
             order = "F"
         else:
             order = "C"
 
+    if order in "kK":
+        order = "C"
+
     x1_ndim = x1.ndim
     x2_ndim = x2.ndim
     if axes is not None:
@@ -938,6 +947,7 @@ def dpnp_matmul(
                     result,
                 )
             else:  # call_flag == "gemm_batch"
+                assert call_flag == "gemm_batch"
                 result = _gemm_batch_matmul(
                     exec_q,
                     x1,
@@ -962,14 +972,7 @@ def dpnp_matmul(
                 result = dpnp.moveaxis(result, (-1,), axes_res)
             return dpnp.ascontiguousarray(result)
 
-        # If `order` was not passed as default
-        # we need to update it to match the passed `order`.
-        if order not in ["k", "K"]:
-            return dpnp.asarray(result, order=order)
-        # dpnp.ascontiguousarray changes 0-D array to 1-D array
-        if result.ndim == 0:
-            return result
-        return dpnp.ascontiguousarray(result)
+        return dpnp.asarray(result, order=order)
 
     result = dpnp.get_result_array(result, out, casting=casting)
     if axes is not None and out is result:
@@ -994,14 +997,9 @@ def dpnp_vecdot(
 
     dpnp.check_supported_arrays_type(x1, x2)
     res_usm_type, exec_q = get_usm_allocations([x1, x2])
-    if out is not None:
-        dpnp.check_supported_arrays_type(out)
-        if dpctl.utils.get_execution_queue((exec_q, out.sycl_queue)) is None:
-            raise ExecutionPlacementError(
-                "Input and output allocation queues are not compatible"
-            )
+    _validate_out_array(out, exec_q)
 
-    if order in ["a", "A"]:
+    if order in "aAkK":
         if x1.flags.fnc and x2.flags.fnc:
             order = "F"
         else:
@@ -1048,7 +1046,7 @@ def dpnp_vecdot(
     _, x1_is_1D, _ = _define_dim_flags(x1, axis=-1)
     _, x2_is_1D, _ = _define_dim_flags(x2, axis=-1)
 
-    if numpy.prod(result_shape) == 0 or x1.size == 0 or x2.size == 0:
+    if x1.size == 0 or x2.size == 0:
         order = "C" if order in "kK" else order
         result = _create_result_array(
             x1,
@@ -1060,8 +1058,9 @@ def dpnp_vecdot(
             sycl_queue=exec_q,
             order=order,
         )
-        if x1.size == 0 or x2.size == 0:
-            result.fill(0)
+        if numpy.prod(result_shape) == 0:
+            return result
+        result.fill(0)
         return result
     elif x1_is_1D and x2_is_1D:
         call_flag = "dot"
@@ -1079,6 +1078,7 @@ def dpnp_vecdot(
         else:
             result = dpnp_dot(x1, x2, out=out, conjugate=True)
     else:  # call_flag == "vecdot"
+        assert call_flag == "vecdot"
         x1_usm = dpnp.get_usm_ndarray(x1)
         x2_usm = dpnp.get_usm_ndarray(x2)
         result = dpnp_array._create_from_usm_ndarray(
@@ -1091,13 +1091,6 @@ def dpnp_vecdot(
         result = dpnp.reshape(result, result_shape)
 
     if out is None:
-        # If `order` was not passed as default
-        # we need to update it to match the passed `order`.
-        if order not in "kK":
-            return dpnp.asarray(result, order=order)
-        # dpnp.ascontiguousarray changes 0-D array to 1-D array
-        if result.ndim == 0:
-            return result
-        return dpnp.ascontiguousarray(result)
+        return dpnp.asarray(result, order=order)
 
     return dpnp.get_result_array(result, out, casting=casting)

tests/test_mathematical.py

@@ -3648,6 +3648,8 @@ def test_matmul_dtype_matrix_inputs(self, dtype1, dtype2, shape_pair):
         expected = numpy.matmul(a1, a2)
         assert_dtype_allclose(result, expected)
 
+    @pytest.mark.parametrize("order1", ["C", "F", "A"])
+    @pytest.mark.parametrize("order2", ["C", "F", "A"])
     @pytest.mark.parametrize("order", ["C", "F", "K", "A"])
     @pytest.mark.parametrize(
         "shape_pair",
@@ -3662,17 +3664,26 @@ def test_matmul_dtype_matrix_inputs(self, dtype1, dtype2, shape_pair):
             "((6, 7, 4, 3), (6, 7, 3, 5))",
         ],
     )
-    def test_matmul_order(self, order, shape_pair):
+    def test_matmul_order(self, order1, order2, order, shape_pair):
         shape1, shape2 = shape_pair
-        a1 = numpy.arange(numpy.prod(shape1)).reshape(shape1)
-        a2 = numpy.arange(numpy.prod(shape2)).reshape(shape2)
+        a1 = numpy.arange(numpy.prod(shape1)).reshape(shape1, order=order1)
+        a2 = numpy.arange(numpy.prod(shape2)).reshape(shape2, order=order2)
 
         b1 = dpnp.asarray(a1)
         b2 = dpnp.asarray(a2)
 
         result = dpnp.matmul(b1, b2, order=order)
         expected = numpy.matmul(a1, a2, order=order)
-        assert result.flags.c_contiguous == expected.flags.c_contiguous
+        # For the special case of shape_pair == ((6, 7, 4, 3), (6, 7, 3, 5))
+        # and order1 == "F" and order2 == "F", NumPy result is not c-contiguous
+        # nor f-contiguous, while dpnp (and cupy) results are c-contiguous
+        if not (
+            shape_pair == ((6, 7, 4, 3), (6, 7, 3, 5))
+            and order1 == "F"
+            and order2 == "F"
+            and order == "K"
+        ):
+            assert result.flags.c_contiguous == expected.flags.c_contiguous
         assert result.flags.f_contiguous == expected.flags.f_contiguous
         assert_dtype_allclose(result, expected)
 

tests/test_product.py

@@ -1343,6 +1343,7 @@ def setup_method(self):
         "shape_pair",
         [
             ((4,), (4,)),  # call_flag: dot
+            ((1, 1, 4), (1, 1, 4)),  # call_flag: dot
             ((3, 1), (3, 1)),
             ((2, 0), (2, 0)),  # zero-size inputs, 1D output
             ((3, 0, 4), (3, 0, 4)),  # zero-size output
@@ -1353,6 +1354,7 @@ def setup_method(self):
             ((3, 4), (4,)),
             ((1, 4, 5), (3, 1, 5)),
             ((1, 1, 4, 5), (3, 1, 5)),
+            ((1, 4, 5), (1, 3, 1, 5)),
         ],
     )
     def test_basic(self, dtype, shape_pair):
@@ -1375,6 +1377,7 @@ def test_basic(self, dtype, shape_pair):
         "shape_pair",
         [
             ((4,), (4,)),  # call_flag: dot
+            ((1, 1, 4), (1, 1, 4)),  # call_flag: dot
             ((3, 1), (3, 1)),
             ((2, 0), (2, 0)),  # zero-size inputs, 1D output
             ((3, 0, 4), (3, 0, 4)),  # zero-size output
@@ -1385,6 +1388,7 @@ def test_basic(self, dtype, shape_pair):
             ((3, 4), (4,)),
             ((1, 4, 5), (3, 1, 5)),
             ((1, 1, 4, 5), (3, 1, 5)),
+            ((1, 4, 5), (1, 3, 1, 5)),
         ],
     )
     def test_complex(self, dtype, shape_pair):
@@ -1501,18 +1505,22 @@ def test_input_dtype_matrix(self, dtype1, dtype2):
         expected = numpy.vecdot(a, b)
         assert_dtype_allclose(result, expected)
 
+    @pytest.mark.parametrize("order1", ["C", "F", "A"])
+    @pytest.mark.parametrize("order2", ["C", "F", "A"])
     @pytest.mark.parametrize("order", ["C", "F", "K", "A"])
     @pytest.mark.parametrize(
         "shape",
-        [((4, 3)), ((4, 3, 5)), ((6, 7, 3, 5))],
-        ids=["((4, 3))", "((4, 3, 5))", "((6, 7, 3, 5))"],
+        [(4, 3), (4, 3, 5), (6, 7, 3, 5)],
+        ids=["(4, 3)", "(4, 3, 5)", "(6, 7, 3, 5)"],
     )
-    def test_order(self, order, shape):
-        a = numpy.arange(numpy.prod(shape)).reshape(shape)
-        b = dpnp.asarray(a)
-
-        result = dpnp.vecdot(b, b, order=order)
-        expected = numpy.vecdot(a, a, order=order)
+    def test_order(self, order1, order2, order, shape):
+        a = numpy.arange(numpy.prod(shape)).reshape(shape, order=order1)
+        b = numpy.arange(numpy.prod(shape)).reshape(shape, order=order2)
+        a_dp = dpnp.asarray(a)
+        b_dp = dpnp.asarray(b)
+
+        result = dpnp.vecdot(a_dp, b_dp, order=order)
+        expected = numpy.vecdot(a, b, order=order)
         assert result.flags.c_contiguous == expected.flags.c_contiguous
         assert result.flags.f_contiguous == expected.flags.f_contiguous
         assert_dtype_allclose(result, expected)