Fix matrix_rank for empty matrices (#2853)

This PR fixes `dpnp.linalg.matrix_rank` to handle empty matrices (arrays
with zero-size dimensions) without raising a `ValueError`.

Previously, calling `matrix_rank` on empty arrays would fail:
```python
import dpnp as np

dpnp.linalg.matrix_rank(np.zeros((0, 0)))
# ValueError: reduction cannot be performed over zero-size axes
```

The PR also adds comprehensive tests coverage, including testing both
normal and Hermitian modes.

Author: antonwolfy

CHANGELOG.md

@@ -90,6 +90,7 @@ Also, that release drops support for Python 3.9, making Python 3.10 the minimum
 * Ensured device aware dtype handling in `dpnp.identity` and `dpnp.gradient` [#2835](https://github.com/IntelPython/dpnp/pull/2835)
 * Fixed `dpnp.tensor.round` to use device-aware output dtype for boolean input [#2851](https://github.com/IntelPython/dpnp/pull/2851)
 * Resolved a deadlock in `dpnp.linalg.qr` by releasing the GIL before OneMKL `orgqr` call to prevent host tasks contention [#2850](https://github.com/IntelPython/dpnp/pull/2850)
+* Fixed `dpnp.linalg.matrix_rank` to properly handle an empty input array [#2853](https://github.com/IntelPython/dpnp/pull/2853)
 
 ### Security
 

dpnp/linalg/dpnp_utils_linalg.py

@@ -2279,6 +2279,13 @@ def dpnp_matrix_rank(A, tol=None, hermitian=False, rtol=None):
 
     S = dpnp_svd(A, compute_uv=False, hermitian=hermitian)
 
+    # Handle empty matrices: if either dimension is 0, there are no singular
+    # values and the rank is 0. For stacked matrices, return array of zeros
+    # with proper shape.
+    if S.shape[-1] == 0:
+        # S has shape (..., 0), so result should have shape (...)
+        return dpnp.count_nonzero(S, axis=-1)
+
     if tol is None:
         if rtol is None:
             rtol = max(A.shape[-2:]) * dpnp.finfo(S.dtype).eps

dpnp/tests/test_linalg.py

@@ -3104,7 +3104,7 @@ def test_matrix_power_errors(self):
 
 
 class TestMatrixRank:
-    @pytest.mark.parametrize("dtype", get_all_dtypes())
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(
         "data",
         [
@@ -3116,15 +3116,15 @@ class TestMatrixRank:
             numpy.array(1),
         ],
     )
-    def test_matrix_rank(self, data, dtype):
+    def test_basic(self, data, dtype):
         a = data.astype(dtype)
         a_dp = dpnp.array(a)
 
         np_rank = numpy.linalg.matrix_rank(a)
         dp_rank = dpnp.linalg.matrix_rank(a_dp)
         assert dp_rank.asnumpy() == np_rank
 
-    @pytest.mark.parametrize("dtype", get_all_dtypes())
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(
         "data",
         [
@@ -3134,7 +3134,7 @@ def test_matrix_rank(self, data, dtype):
             numpy.diag([1, 1, 1, 0]),
         ],
     )
-    def test_matrix_rank_hermitian(self, data, dtype):
+    def test_hermitian(self, data, dtype):
         a = data.astype(dtype)
         a_dp = dpnp.array(a)
 
@@ -3151,7 +3151,7 @@ def test_matrix_rank_hermitian(self, data, dtype):
         ],
         ids=["float", "0-D array", "1-D array"],
     )
-    def test_matrix_rank_tolerance(self, high_tol, low_tol):
+    def test_tolerance(self, high_tol, low_tol):
         a = numpy.eye(4)
         a[-1, -1] = 1e-6
         a_dp = dpnp.array(a)
@@ -3190,7 +3190,7 @@ def test_matrix_rank_tolerance(self, high_tol, low_tol):
         [0.99e-6, numpy.array(1.01e-6), numpy.ones(4) * [0.99e-6]],
         ids=["float", "0-D array", "1-D array"],
     )
-    def test_matrix_rank_tol(self, tol):
+    def test_tol(self, tol):
         a = numpy.zeros((4, 3, 2))
         a_dp = dpnp.array(a)
 
@@ -3209,7 +3209,7 @@ def test_matrix_rank_tol(self, tol):
         result = dpnp.linalg.matrix_rank(a_dp, tol=dp_tol)
         assert_dtype_allclose(result, expected)
 
-    def test_matrix_rank_errors(self):
+    def test_errors(self):
         a_dp = dpnp.array([[1, 2], [3, 4]], dtype="float32")
 
         # unsupported type `a`
@@ -3238,6 +3238,41 @@ def test_matrix_rank_errors(self):
             ValueError, dpnp.linalg.matrix_rank, a_dp, tol=1e-06, rtol=1e-04
         )
 
+    # TODO: use below fixture when NumPy 2.5 is released
+    # @testing.with_requires("numpy>=2.5")
+    @pytest.mark.parametrize(
+        "shape",
+        [
+            (0, 0),
+            (0, 5),
+            (5, 0),
+            (0, 5, 5),
+            (3, 0, 5),
+            (2, 0, 0),
+            (2, 5, 0),
+            (2, 3, 0, 4),
+        ],
+    )
+    def test_empty(self, shape):
+        a = numpy.zeros(shape)
+        ia = dpnp.array(a)
+
+        result = dpnp.linalg.matrix_rank(ia)
+        if numpy_version() < "2.5.0":  # TODO: remove
+            # Expected behavior: rank of empty matrix is 0
+            # For stacked matrices, return array of zeros
+            expected = numpy.zeros(shape[:-2], dtype=numpy.intp)
+            if expected.ndim == 0:
+                expected = numpy.array(0)
+        else:
+            expected = numpy.linalg.matrix_rank(a)
+        assert_array_equal(result, expected, strict=True)
+
+        # Also test with hermitian=True
+        if len(shape) >= 2 and shape[-2] == shape[-1]:
+            result = dpnp.linalg.matrix_rank(ia, hermitian=True)
+            assert_array_equal(result, expected, strict=True)
+
 
 # numpy.linalg.matrix_transpose() is available since numpy >= 2.0
 @testing.with_requires("numpy>=2.0")