CI: Fix test_jacobi_svd

Author: Lucas-Haubert

include/nanoeigenpy/decompositions/jacobi-svd.hpp

@@ -44,7 +44,9 @@ struct JacobiSVDVisitor : nb::def_visitor<JacobiSVDVisitor<JacobiSVD>> {
         .def(
             "compute",
             [](JacobiSVD &c, MatrixType const &matrix,
-               unsigned int) -> JacobiSVD & { return c.compute(matrix); },
+               unsigned int computationOptions) -> JacobiSVD & {
+              return c.compute(matrix, computationOptions);
+            },
             "matrix"_a, "computationOptions"_a,
             "Computes the SVD of given matrix.", nb::rv_policy::reference)
 

tests/test_jacobi_svd.py

@@ -2,20 +2,21 @@
 import numpy as np
 import pytest
 
+THIN_U = nanoeigenpy.DecompositionOptions.ComputeThinU.value
+THIN_V = nanoeigenpy.DecompositionOptions.ComputeThinV.value
+FULL_U = nanoeigenpy.DecompositionOptions.ComputeFullU.value
+FULL_V = nanoeigenpy.DecompositionOptions.ComputeFullV.value
+
 _options = [
     0,
-    nanoeigenpy.DecompositionOptions.ComputeThinU.value,
-    nanoeigenpy.DecompositionOptions.ComputeThinV.value,
-    nanoeigenpy.DecompositionOptions.ComputeFullU.value,
-    nanoeigenpy.DecompositionOptions.ComputeFullV.value,
-    nanoeigenpy.DecompositionOptions.ComputeThinU.value
-    | nanoeigenpy.DecompositionOptions.ComputeThinV.value,
-    nanoeigenpy.DecompositionOptions.ComputeFullU.value
-    | nanoeigenpy.DecompositionOptions.ComputeFullV.value,
-    nanoeigenpy.DecompositionOptions.ComputeThinU.value
-    | nanoeigenpy.DecompositionOptions.ComputeFullV.value,
-    nanoeigenpy.DecompositionOptions.ComputeFullU.value
-    | nanoeigenpy.DecompositionOptions.ComputeThinV.value,
+    THIN_U,
+    THIN_V,
+    FULL_U,
+    FULL_V,
+    THIN_U | THIN_V,
+    FULL_U | FULL_V,
+    THIN_U | FULL_V,
+    FULL_U | THIN_V,
 ]
 
 _classes = [
@@ -26,34 +27,35 @@
 ]
 
 
+def is_valid_combination(cls, options):
+    if cls == nanoeigenpy.FullPivHhJacobiSVD:
+        has_thin_u = bool(options & THIN_U)
+        has_thin_v = bool(options & THIN_V)
+
+        if has_thin_u or has_thin_v:
+            return False
+
+    return True
+
+
 @pytest.mark.parametrize("cls", _classes)
 @pytest.mark.parametrize("options", _options)
 def test_jacobi(cls, options):
+    if not is_valid_combination(cls, options):
+        pytest.skip(f"Invalid combination: {cls.__name__} with options {options}")
+
     dim = 100
     rng = np.random.default_rng()
     A = rng.random((dim, dim))
     A = (A + A.T) * 0.5 + np.diag(10.0 + rng.random(dim))
 
-    if cls == nanoeigenpy.FullPivHhJacobiSVD:
-        if options != 0 and not (
-            options
-            & (
-                nanoeigenpy.DecompositionOptions.ComputeFullU.value
-                | nanoeigenpy.DecompositionOptions.ComputeFullV.value
-            )
-        ):
-            return
-
     jacobisvd = cls(A, options)
     assert jacobisvd.info() == nanoeigenpy.ComputationInfo.Success
 
-    if options & (
-        nanoeigenpy.DecompositionOptions.ComputeThinU.value
-        | nanoeigenpy.DecompositionOptions.ComputeFullU.value
-    ) and options & (
-        nanoeigenpy.DecompositionOptions.ComputeThinV.value
-        | nanoeigenpy.DecompositionOptions.ComputeFullV.value
-    ):
+    has_u = options & (THIN_U | FULL_U)
+    has_v = options & (THIN_V | FULL_V)
+
+    if has_u and has_v:
         X = rng.random((dim, 20))
         B = A @ X
         X_est = jacobisvd.solve(B)
@@ -66,10 +68,8 @@ def test_jacobi(cls, options):
         assert nanoeigenpy.is_approx(x, x_est)
         assert nanoeigenpy.is_approx(A @ x_est, b)
 
-    rows = jacobisvd.rows()
-    cols = jacobisvd.cols()
-    assert cols == dim
-    assert rows == dim
+    assert jacobisvd.rows() == dim
+    assert jacobisvd.cols() == dim
 
     _jacobisvd_compute = jacobisvd.compute(A)
     _jacobisvd_compute_options = jacobisvd.compute(A, options)
@@ -86,37 +86,19 @@ def test_jacobi(cls, options):
 
     compute_u = jacobisvd.computeU()
     compute_v = jacobisvd.computeV()
-    expected_compute_u = bool(
-        options
-        & (
-            nanoeigenpy.DecompositionOptions.ComputeThinU.value
-            | nanoeigenpy.DecompositionOptions.ComputeFullU.value
-        )
-    )
-    expected_compute_v = bool(
-        options
-        & (
-            nanoeigenpy.DecompositionOptions.ComputeThinV.value
-            | nanoeigenpy.DecompositionOptions.ComputeFullV.value
-        )
-    )
+    expected_compute_u = bool(has_u)
+    expected_compute_v = bool(has_v)
     assert compute_u == expected_compute_u
     assert compute_v == expected_compute_v
 
     if compute_u:
         matrixU = jacobisvd.matrixU()
-        if options & nanoeigenpy.DecompositionOptions.ComputeFullU.value:
-            assert matrixU.shape == (dim, dim)
-        elif options & nanoeigenpy.DecompositionOptions.ComputeThinU.value:
-            assert matrixU.shape == (dim, dim)
+        assert matrixU.shape == (dim, dim)
         assert nanoeigenpy.is_approx(matrixU.T @ matrixU, np.eye(matrixU.shape[1]))
 
     if compute_v:
         matrixV = jacobisvd.matrixV()
-        if options & nanoeigenpy.DecompositionOptions.ComputeFullV.value:
-            assert matrixV.shape == (dim, dim)
-        elif options & nanoeigenpy.DecompositionOptions.ComputeThinV.value:
-            assert matrixV.shape == (dim, dim)
+        assert matrixV.shape == (dim, dim)
         assert nanoeigenpy.is_approx(matrixV.T @ matrixV, np.eye(matrixV.shape[1]))
 
     if compute_u and compute_v: