Raise ValueError exception per axes keyword

Author: antonwolfy

dpnp/dpnp_array.py

@@ -372,9 +372,7 @@ def __imatmul__(self, other):
         if the result without `out` would have less dimensions than `a`.
         Since the signature of matmul is '(n?,k),(k,m?)->(n?,m?)' this is the
         case exactly when the second operand has both core dimensions.
-
-        The error here will be confusing, but for now, we enforce this by
-        passing the correct `axes=`.
+        We have to enforce this check by passing the correct `axes=`.
         """
         if self.ndim == 1:
             axes = [(-1,), (-2, -1), (-1,)]

dpnp/dpnp_utils/dpnp_utils_linearalgebra.py

@@ -563,7 +563,7 @@ def _validate_internal(axes, i, ndim):
 
     if x1_ndim == 1 and x2_ndim == 1:
         if axes[2] != ():
-            raise TypeError("Axes item 2 should be an empty tuple.")
+            raise ValueError("Axes item 2 should be an empty tuple.")
     elif x1_ndim == 1 or x2_ndim == 1:
         axes[2] = _validate_internal(axes[2], 2, 1)
     else:

tests/test_mathematical.py

@@ -4228,24 +4228,25 @@ def test_shapes(self, a_sh, b_sh):
 
 
 class TestMatmulInvalidCases:
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize(
-        "shape_pair",
+        "shape1, shape2",
         [
             ((3, 2), ()),
             ((), (3, 2)),
             ((), ()),
         ],
     )
-    def test_zero_dim(self, shape_pair):
-        for xp in (numpy, dpnp):
-            shape1, shape2 = shape_pair
-            x1 = xp.arange(numpy.prod(shape1), dtype=xp.float32).reshape(shape1)
-            x2 = xp.arange(numpy.prod(shape2), dtype=xp.float32).reshape(shape2)
-            with pytest.raises(ValueError):
-                xp.matmul(x1, x2)
+    def test_zero_dim(self, xp, shape1, shape2):
+        x1 = xp.arange(numpy.prod(shape1), dtype=xp.float32).reshape(shape1)
+        x2 = xp.arange(numpy.prod(shape2), dtype=xp.float32).reshape(shape2)
 
+        with pytest.raises(ValueError):
+            xp.matmul(x1, x2)
+
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize(
-        "shape_pair",
+        "shape1, shape2",
         [
             ((3,), (4,)),
             ((2, 3), (4, 5)),
@@ -4258,16 +4259,16 @@ def test_zero_dim(self, shape_pair):
             ((6, 5, 3, 2), (3, 2, 4)),
         ],
     )
-    def test_invalid_shape(self, shape_pair):
-        for xp in (numpy, dpnp):
-            shape1, shape2 = shape_pair
-            x1 = xp.arange(numpy.prod(shape1), dtype=xp.float32).reshape(shape1)
-            x2 = xp.arange(numpy.prod(shape2), dtype=xp.float32).reshape(shape2)
-            with pytest.raises(ValueError):
-                xp.matmul(x1, x2)
+    def test_invalid_shape(self, xp, shape1, shape2):
+        x1 = xp.arange(numpy.prod(shape1), dtype=xp.float32).reshape(shape1)
+        x2 = xp.arange(numpy.prod(shape2), dtype=xp.float32).reshape(shape2)
 
+        with pytest.raises(ValueError):
+            xp.matmul(x1, x2)
+
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize(
-        "shape_pair",
+        "shape1, shape2, out_shape",
         [
             ((5, 4, 3), (3, 1), (3, 4, 1)),
             ((5, 4, 3), (3, 1), (5, 6, 1)),
@@ -4279,24 +4280,24 @@ def test_invalid_shape(self, shape_pair):
             ((4,), (3, 4, 5), (3, 6)),
         ],
     )
-    def test_invalid_shape_out(self, shape_pair):
-        for xp in (numpy, dpnp):
-            shape1, shape2, out_shape = shape_pair
-            x1 = xp.arange(numpy.prod(shape1), dtype=xp.float32).reshape(shape1)
-            x2 = xp.arange(numpy.prod(shape2), dtype=xp.float32).reshape(shape2)
-            res = xp.empty(out_shape)
-            with pytest.raises(ValueError):
-                xp.matmul(x1, x2, out=res)
+    def test_invalid_shape_out(self, xp, shape1, shape2, out_shape):
+        x1 = xp.arange(numpy.prod(shape1), dtype=xp.float32).reshape(shape1)
+        x2 = xp.arange(numpy.prod(shape2), dtype=xp.float32).reshape(shape2)
+        res = xp.empty(out_shape)
 
+        with pytest.raises(ValueError):
+            xp.matmul(x1, x2, out=res)
+
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True)[:-2])
-    def test_invalid_dtype(self, dtype):
+    def test_invalid_dtype(self, xp, dtype):
         dpnp_dtype = get_all_dtypes(no_none=True)[-1]
-        a1 = dpnp.arange(5 * 4, dtype=dpnp_dtype).reshape(5, 4)
-        a2 = dpnp.arange(7 * 4, dtype=dpnp_dtype).reshape(4, 7)
-        dp_out = dpnp.empty((5, 7), dtype=dtype)
+        a1 = xp.arange(5 * 4, dtype=dpnp_dtype).reshape(5, 4)
+        a2 = xp.arange(7 * 4, dtype=dpnp_dtype).reshape(4, 7)
+        dp_out = xp.empty((5, 7), dtype=dtype)
 
         with pytest.raises(TypeError):
-            dpnp.matmul(a1, a2, out=dp_out)
+            xp.matmul(a1, a2, out=dp_out)
 
     def test_exe_q(self):
         x1 = dpnp.ones((5, 4), sycl_queue=dpctl.SyclQueue())
@@ -4310,13 +4311,14 @@ def test_exe_q(self):
         with pytest.raises(ExecutionPlacementError):
             dpnp.matmul(x1, x2, out=out)
 
-    def test_matmul_casting(self):
-        a1 = dpnp.arange(2 * 4, dtype=dpnp.float32).reshape(2, 4)
-        a2 = dpnp.arange(4 * 3).reshape(4, 3)
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    def test_matmul_casting(self, xp):
+        a1 = xp.arange(2 * 4, dtype=xp.float32).reshape(2, 4)
+        a2 = xp.arange(4 * 3).reshape(4, 3)
 
-        res = dpnp.empty((2, 3), dtype=dpnp.int64)
+        res = xp.empty((2, 3), dtype=xp.int64)
         with pytest.raises(TypeError):
-            dpnp.matmul(a1, a2, out=res, casting="safe")
+            xp.matmul(a1, a2, out=res, casting="safe")
 
     def test_matmul_not_implemented(self):
         a1 = dpnp.arange(2 * 4).reshape(2, 4)
@@ -4332,52 +4334,53 @@ def test_matmul_not_implemented(self):
         with pytest.raises(NotImplementedError):
             dpnp.matmul(a1, a2, axis=2)
 
-    def test_matmul_axes(self):
-        a1 = dpnp.arange(120).reshape(2, 5, 3, 4)
-        a2 = dpnp.arange(120).reshape(4, 2, 5, 3)
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    def test_matmul_axes(self, xp):
+        a1 = xp.arange(120).reshape(2, 5, 3, 4)
+        a2 = xp.arange(120).reshape(4, 2, 5, 3)
 
         # axes must be a list
         axes = ((3, 1), (2, 0), (0, 1))
         with pytest.raises(TypeError):
-            dpnp.matmul(a1, a2, axes=axes)
+            xp.matmul(a1, a2, axes=axes)
 
         # axes must be be a list of three tuples
         axes = [(3, 1), (2, 0)]
         with pytest.raises(ValueError):
-            dpnp.matmul(a1, a2, axes=axes)
+            xp.matmul(a1, a2, axes=axes)
 
         # axes item should be a tuple
         axes = [(3, 1), (2, 0), [0, 1]]
         with pytest.raises(TypeError):
-            dpnp.matmul(a1, a2, axes=axes)
+            xp.matmul(a1, a2, axes=axes)
 
         # axes item should be a tuple with 2 elements
         axes = [(3, 1), (2, 0), (0, 1, 2)]
         with pytest.raises(ValueError):
-            dpnp.matmul(a1, a2, axes=axes)
+            xp.matmul(a1, a2, axes=axes)
 
         # axes must be an integer
         axes = [(3, 1), (2, 0), (0.0, 1)]
         with pytest.raises(TypeError):
-            dpnp.matmul(a1, a2, axes=axes)
+            xp.matmul(a1, a2, axes=axes)
 
         # axes item 2 should be an empty tuple
-        a = dpnp.arange(3)
+        a = xp.arange(3)
         axes = [0, 0, 0]
-        with pytest.raises(TypeError):
-            dpnp.matmul(a, a, axes=axes)
+        with pytest.raises(ValueError):
+            xp.matmul(a, a, axes=axes)
 
-        a = dpnp.arange(3 * 4 * 5).reshape(3, 4, 5)
-        b = dpnp.arange(3)
+        a = xp.arange(3 * 4 * 5).reshape(3, 4, 5)
+        b = xp.arange(3)
         # list object cannot be interpreted as an integer
         axes = [(1, 0), (0), [0]]
         with pytest.raises(TypeError):
-            dpnp.matmul(a, b, axes=axes)
+            xp.matmul(a, b, axes=axes)
 
         # axes item should be a tuple with a single element, or an integer
         axes = [(1, 0), (0), (0, 1)]
         with pytest.raises(ValueError):
-            dpnp.matmul(a, b, axes=axes)
+            xp.matmul(a, b, axes=axes)
 
 
 def test_elemenwise_nin_nout():