okstra 0.107.2 → 0.109.0

package/runtime/python/okstra_vendor/networkx/algorithms/bipartite/tests/test_matching.py

@@ -0,0 +1,327 @@
+"""Unit tests for the :mod:`networkx.algorithms.bipartite.matching` module."""
+
+import itertools
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms.bipartite.matching import (
+    eppstein_matching,
+    hopcroft_karp_matching,
+    maximum_matching,
+    minimum_weight_full_matching,
+    to_vertex_cover,
+)
+
+
+class TestMatching:
+    """Tests for bipartite matching algorithms."""
+
+    def setup_method(self):
+        """Creates a bipartite graph for use in testing matching algorithms.
+
+        The bipartite graph has a maximum cardinality matching that leaves
+        vertex 1 and vertex 10 unmatched. The first six numbers are the left
+        vertices and the next six numbers are the right vertices.
+
+        """
+        self.simple_graph = nx.complete_bipartite_graph(2, 3)
+        self.simple_solution = {0: 2, 1: 3, 2: 0, 3: 1}
+
+        edges = [(0, 7), (0, 8), (2, 6), (2, 9), (3, 8), (4, 8), (4, 9), (5, 11)]
+        self.top_nodes = set(range(6))
+        self.graph = nx.Graph()
+        self.graph.add_nodes_from(range(12))
+        self.graph.add_edges_from(edges)
+
+        # Example bipartite graph from issue 2127
+        G = nx.Graph()
+        G.add_nodes_from(
+            [
+                (1, "C"),
+                (1, "B"),
+                (0, "G"),
+                (1, "F"),
+                (1, "E"),
+                (0, "C"),
+                (1, "D"),
+                (1, "I"),
+                (0, "A"),
+                (0, "D"),
+                (0, "F"),
+                (0, "E"),
+                (0, "H"),
+                (1, "G"),
+                (1, "A"),
+                (0, "I"),
+                (0, "B"),
+                (1, "H"),
+            ]
+        )
+        G.add_edge((1, "C"), (0, "A"))
+        G.add_edge((1, "B"), (0, "A"))
+        G.add_edge((0, "G"), (1, "I"))
+        G.add_edge((0, "G"), (1, "H"))
+        G.add_edge((1, "F"), (0, "A"))
+        G.add_edge((1, "F"), (0, "C"))
+        G.add_edge((1, "F"), (0, "E"))
+        G.add_edge((1, "E"), (0, "A"))
+        G.add_edge((1, "E"), (0, "C"))
+        G.add_edge((0, "C"), (1, "D"))
+        G.add_edge((0, "C"), (1, "I"))
+        G.add_edge((0, "C"), (1, "G"))
+        G.add_edge((0, "C"), (1, "H"))
+        G.add_edge((1, "D"), (0, "A"))
+        G.add_edge((1, "I"), (0, "A"))
+        G.add_edge((1, "I"), (0, "E"))
+        G.add_edge((0, "A"), (1, "G"))
+        G.add_edge((0, "A"), (1, "H"))
+        G.add_edge((0, "E"), (1, "G"))
+        G.add_edge((0, "E"), (1, "H"))
+        self.disconnected_graph = G
+
+    def check_match(self, matching):
+        """Asserts that the matching is what we expect from the bipartite graph
+        constructed in the :meth:`setup` fixture.
+
+        """
+        # For the sake of brevity, rename `matching` to `M`.
+        M = matching
+        matched_vertices = frozenset(itertools.chain(*M.items()))
+        # Assert that the maximum number of vertices (10) is matched.
+        assert matched_vertices == frozenset(range(12)) - {1, 10}
+        # Assert that no vertex appears in two edges, or in other words, that
+        # the matching (u, v) and (v, u) both appear in the matching
+        # dictionary.
+        assert all(u == M[M[u]] for u in range(12) if u in M)
+
+    def check_vertex_cover(self, vertices):
+        """Asserts that the given set of vertices is the vertex cover we
+        expected from the bipartite graph constructed in the :meth:`setup`
+        fixture.
+
+        """
+        # By Konig's theorem, the number of edges in a maximum matching equals
+        # the number of vertices in a minimum vertex cover.
+        assert len(vertices) == 5
+        # Assert that the set is truly a vertex cover.
+        for u, v in self.graph.edges():
+            assert u in vertices or v in vertices
+        # TODO Assert that the vertices are the correct ones.
+
+    def test_eppstein_matching(self):
+        """Tests that David Eppstein's implementation of the Hopcroft--Karp
+        algorithm produces a maximum cardinality matching.
+
+        """
+        self.check_match(eppstein_matching(self.graph, self.top_nodes))
+
+    def test_hopcroft_karp_matching(self):
+        """Tests that the Hopcroft--Karp algorithm produces a maximum
+        cardinality matching in a bipartite graph.
+
+        """
+        self.check_match(hopcroft_karp_matching(self.graph, self.top_nodes))
+
+    def test_to_vertex_cover(self):
+        """Test for converting a maximum matching to a minimum vertex cover."""
+        matching = maximum_matching(self.graph, self.top_nodes)
+        vertex_cover = to_vertex_cover(self.graph, matching, self.top_nodes)
+        self.check_vertex_cover(vertex_cover)
+
+    def test_eppstein_matching_simple(self):
+        match = eppstein_matching(self.simple_graph)
+        assert match == self.simple_solution
+
+    def test_hopcroft_karp_matching_simple(self):
+        match = hopcroft_karp_matching(self.simple_graph)
+        assert match == self.simple_solution
+
+    def test_eppstein_matching_disconnected(self):
+        with pytest.raises(nx.AmbiguousSolution):
+            match = eppstein_matching(self.disconnected_graph)
+
+    def test_hopcroft_karp_matching_disconnected(self):
+        with pytest.raises(nx.AmbiguousSolution):
+            match = hopcroft_karp_matching(self.disconnected_graph)
+
+    def test_issue_2127(self):
+        """Test from issue 2127"""
+        # Build the example DAG
+        G = nx.DiGraph()
+        G.add_edge("A", "C")
+        G.add_edge("A", "B")
+        G.add_edge("C", "E")
+        G.add_edge("C", "D")
+        G.add_edge("E", "G")
+        G.add_edge("E", "F")
+        G.add_edge("G", "I")
+        G.add_edge("G", "H")
+
+        tc = nx.transitive_closure(G)
+        btc = nx.Graph()
+
+        # Create a bipartite graph based on the transitive closure of G
+        for v in tc.nodes():
+            btc.add_node((0, v))
+            btc.add_node((1, v))
+
+        for u, v in tc.edges():
+            btc.add_edge((0, u), (1, v))
+
+        top_nodes = {n for n in btc if n[0] == 0}
+        matching = hopcroft_karp_matching(btc, top_nodes)
+        vertex_cover = to_vertex_cover(btc, matching, top_nodes)
+        independent_set = set(G) - {v for _, v in vertex_cover}
+        assert {"B", "D", "F", "I", "H"} == independent_set
+
+    def test_vertex_cover_issue_2384(self):
+        G = nx.Graph([(0, 3), (1, 3), (1, 4), (2, 3)])
+        matching = maximum_matching(G)
+        vertex_cover = to_vertex_cover(G, matching)
+        for u, v in G.edges():
+            assert u in vertex_cover or v in vertex_cover
+
+    def test_vertex_cover_issue_3306(self):
+        G = nx.Graph()
+        edges = [(0, 2), (1, 0), (1, 1), (1, 2), (2, 2)]
+        G.add_edges_from([((i, "L"), (j, "R")) for i, j in edges])
+
+        matching = maximum_matching(G)
+        vertex_cover = to_vertex_cover(G, matching)
+        for u, v in G.edges():
+            assert u in vertex_cover or v in vertex_cover
+
+    def test_unorderable_nodes(self):
+        a = object()
+        b = object()
+        c = object()
+        d = object()
+        e = object()
+        G = nx.Graph([(a, d), (b, d), (b, e), (c, d)])
+        matching = maximum_matching(G)
+        vertex_cover = to_vertex_cover(G, matching)
+        for u, v in G.edges():
+            assert u in vertex_cover or v in vertex_cover
+
+
+def test_eppstein_matching():
+    """Test in accordance to issue #1927"""
+    G = nx.Graph()
+    G.add_nodes_from(["a", 2, 3, 4], bipartite=0)
+    G.add_nodes_from([1, "b", "c"], bipartite=1)
+    G.add_edges_from([("a", 1), ("a", "b"), (2, "b"), (2, "c"), (3, "c"), (4, 1)])
+    matching = eppstein_matching(G)
+    assert len(matching) == len(maximum_matching(G))
+    assert all(x in set(matching.keys()) for x in set(matching.values()))
+
+
+class TestMinimumWeightFullMatching:
+    @classmethod
+    def setup_class(cls):
+        pytest.importorskip("scipy")
+
+    def test_minimum_weight_full_matching_incomplete_graph(self):
+        B = nx.Graph()
+        B.add_nodes_from([1, 2], bipartite=0)
+        B.add_nodes_from([3, 4], bipartite=1)
+        B.add_edge(1, 4, weight=100)
+        B.add_edge(2, 3, weight=100)
+        B.add_edge(2, 4, weight=50)
+        matching = minimum_weight_full_matching(B)
+        assert matching == {1: 4, 2: 3, 4: 1, 3: 2}
+
+    def test_minimum_weight_full_matching_with_no_full_matching(self):
+        B = nx.Graph()
+        B.add_nodes_from([1, 2, 3], bipartite=0)
+        B.add_nodes_from([4, 5, 6], bipartite=1)
+        B.add_edge(1, 4, weight=100)
+        B.add_edge(2, 4, weight=100)
+        B.add_edge(3, 4, weight=50)
+        B.add_edge(3, 5, weight=50)
+        B.add_edge(3, 6, weight=50)
+        with pytest.raises(ValueError):
+            minimum_weight_full_matching(B)
+
+    def test_minimum_weight_full_matching_square(self):
+        G = nx.complete_bipartite_graph(3, 3)
+        G.add_edge(0, 3, weight=400)
+        G.add_edge(0, 4, weight=150)
+        G.add_edge(0, 5, weight=400)
+        G.add_edge(1, 3, weight=400)
+        G.add_edge(1, 4, weight=450)
+        G.add_edge(1, 5, weight=600)
+        G.add_edge(2, 3, weight=300)
+        G.add_edge(2, 4, weight=225)
+        G.add_edge(2, 5, weight=300)
+        matching = minimum_weight_full_matching(G)
+        assert matching == {0: 4, 1: 3, 2: 5, 4: 0, 3: 1, 5: 2}
+
+    def test_minimum_weight_full_matching_smaller_left(self):
+        G = nx.complete_bipartite_graph(3, 4)
+        G.add_edge(0, 3, weight=400)
+        G.add_edge(0, 4, weight=150)
+        G.add_edge(0, 5, weight=400)
+        G.add_edge(0, 6, weight=1)
+        G.add_edge(1, 3, weight=400)
+        G.add_edge(1, 4, weight=450)
+        G.add_edge(1, 5, weight=600)
+        G.add_edge(1, 6, weight=2)
+        G.add_edge(2, 3, weight=300)
+        G.add_edge(2, 4, weight=225)
+        G.add_edge(2, 5, weight=290)
+        G.add_edge(2, 6, weight=3)
+        matching = minimum_weight_full_matching(G)
+        assert matching == {0: 4, 1: 6, 2: 5, 4: 0, 5: 2, 6: 1}
+
+    def test_minimum_weight_full_matching_smaller_top_nodes_right(self):
+        G = nx.complete_bipartite_graph(3, 4)
+        G.add_edge(0, 3, weight=400)
+        G.add_edge(0, 4, weight=150)
+        G.add_edge(0, 5, weight=400)
+        G.add_edge(0, 6, weight=1)
+        G.add_edge(1, 3, weight=400)
+        G.add_edge(1, 4, weight=450)
+        G.add_edge(1, 5, weight=600)
+        G.add_edge(1, 6, weight=2)
+        G.add_edge(2, 3, weight=300)
+        G.add_edge(2, 4, weight=225)
+        G.add_edge(2, 5, weight=290)
+        G.add_edge(2, 6, weight=3)
+        matching = minimum_weight_full_matching(G, top_nodes=[3, 4, 5, 6])
+        assert matching == {0: 4, 1: 6, 2: 5, 4: 0, 5: 2, 6: 1}
+
+    def test_minimum_weight_full_matching_smaller_right(self):
+        G = nx.complete_bipartite_graph(4, 3)
+        G.add_edge(0, 4, weight=400)
+        G.add_edge(0, 5, weight=400)
+        G.add_edge(0, 6, weight=300)
+        G.add_edge(1, 4, weight=150)
+        G.add_edge(1, 5, weight=450)
+        G.add_edge(1, 6, weight=225)
+        G.add_edge(2, 4, weight=400)
+        G.add_edge(2, 5, weight=600)
+        G.add_edge(2, 6, weight=290)
+        G.add_edge(3, 4, weight=1)
+        G.add_edge(3, 5, weight=2)
+        G.add_edge(3, 6, weight=3)
+        matching = minimum_weight_full_matching(G)
+        assert matching == {1: 4, 2: 6, 3: 5, 4: 1, 5: 3, 6: 2}
+
+    def test_minimum_weight_full_matching_negative_weights(self):
+        G = nx.complete_bipartite_graph(2, 2)
+        G.add_edge(0, 2, weight=-2)
+        G.add_edge(0, 3, weight=0.2)
+        G.add_edge(1, 2, weight=-2)
+        G.add_edge(1, 3, weight=0.3)
+        matching = minimum_weight_full_matching(G)
+        assert matching == {0: 3, 1: 2, 2: 1, 3: 0}
+
+    def test_minimum_weight_full_matching_different_weight_key(self):
+        G = nx.complete_bipartite_graph(2, 2)
+        G.add_edge(0, 2, mass=2)
+        G.add_edge(0, 3, mass=0.2)
+        G.add_edge(1, 2, mass=1)
+        G.add_edge(1, 3, mass=2)
+        matching = minimum_weight_full_matching(G, weight="mass")
+        assert matching == {0: 3, 1: 2, 2: 1, 3: 0}

package/runtime/python/okstra_vendor/networkx/algorithms/bipartite/tests/test_matrix.py

@@ -0,0 +1,138 @@
+import itertools
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms import bipartite
+from networkx.utils import edges_equal
+
+np = pytest.importorskip("numpy")
+sp = pytest.importorskip("scipy")
+
+
+class TestBiadjacencyMatrix:
+    def test_biadjacency_matrix_weight(self):
+        G = nx.path_graph(5)
+        G.add_edge(0, 1, weight=2, other=4)
+        X = [1, 3]
+        Y = [0, 2, 4]
+        M = bipartite.biadjacency_matrix(G, X, weight="weight")
+        assert M[0, 0] == 2
+        M = bipartite.biadjacency_matrix(G, X, weight="other")
+        assert M[0, 0] == 4
+
+    def test_biadjacency_matrix(self):
+        tops = [2, 5, 10]
+        bots = [5, 10, 15]
+        for i in range(len(tops)):
+            G = bipartite.random_graph(tops[i], bots[i], 0.2)
+            top = [n for n, d in G.nodes(data=True) if d["bipartite"] == 0]
+            M = bipartite.biadjacency_matrix(G, top)
+            assert M.shape[0] == tops[i]
+            assert M.shape[1] == bots[i]
+
+    def test_biadjacency_matrix_order(self):
+        G = nx.path_graph(5)
+        G.add_edge(0, 1, weight=2)
+        X = [3, 1]
+        Y = [4, 2, 0]
+        M = bipartite.biadjacency_matrix(G, X, Y, weight="weight")
+        assert M[1, 2] == 2
+
+    def test_biadjacency_matrix_empty_graph(self):
+        G = nx.empty_graph(2)
+        M = nx.bipartite.biadjacency_matrix(G, [0])
+        assert np.array_equal(M.toarray(), np.array([[0]]))
+
+    def test_null_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph(), [])
+
+    def test_empty_graph(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph([(1, 0)]), [])
+
+    def test_duplicate_row(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph([(1, 0)]), [1, 1])
+
+    def test_duplicate_col(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph([(1, 0)]), [0], [1, 1])
+
+    def test_format_keyword(self):
+        with pytest.raises(nx.NetworkXError):
+            bipartite.biadjacency_matrix(nx.Graph([(1, 0)]), [0], format="foo")
+
+    def test_from_biadjacency_roundtrip(self):
+        B1 = nx.path_graph(5)
+        M = bipartite.biadjacency_matrix(B1, [0, 2, 4])
+        B2 = bipartite.from_biadjacency_matrix(M)
+        assert nx.is_isomorphic(B1, B2)
+
+    def test_from_biadjacency_weight(self):
+        M = sp.sparse.csc_array([[1, 2], [0, 3]])
+        B = bipartite.from_biadjacency_matrix(M)
+        assert edges_equal(B.edges(), [(0, 2), (0, 3), (1, 3)])
+        B = bipartite.from_biadjacency_matrix(M, edge_attribute="weight")
+        e = [(0, 2, {"weight": 1}), (0, 3, {"weight": 2}), (1, 3, {"weight": 3})]
+        assert edges_equal(B.edges(data=True), e)
+
+    def test_from_biadjacency_multigraph(self):
+        M = sp.sparse.csc_array([[1, 2], [0, 3]])
+        B = bipartite.from_biadjacency_matrix(M, create_using=nx.MultiGraph())
+        assert edges_equal(B.edges(), [(0, 2), (0, 3), (0, 3), (1, 3), (1, 3), (1, 3)])
+
+    @pytest.mark.parametrize(
+        "row_order,column_order,create_using",
+        itertools.product(
+            (None, ("a", "b"), (25, (0, 5, 10))),
+            (None, ("c", "d"), (26, (0, 5, 10))),
+            (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph),
+        ),
+    )
+    def test_from_biadjacency_nodelist(self, row_order, column_order, create_using):
+        M = sp.sparse.csc_array([[1, 2], [0, 3]])
+        B_default = bipartite.from_biadjacency_matrix(M, create_using=create_using())
+        B = bipartite.from_biadjacency_matrix(
+            M,
+            create_using=create_using(),
+            row_order=row_order,
+            column_order=column_order,
+        )
+
+        row_order = row_order if row_order else list(range(M.shape[0]))
+        column_order = (
+            column_order
+            if column_order
+            else list(range(M.shape[0], M.shape[0] + M.shape[1]))
+        )
+
+        top_map = dict(enumerate(row_order))
+
+        bottom_map = {idx + M.shape[0]: node for idx, node in enumerate(column_order)}
+
+        def map_edges(edges):
+            return [(top_map[u], bottom_map[v]) for u, v in edges]
+
+        mapped_edges = map_edges(B_default.edges())
+        assert edges_equal(mapped_edges, B.edges())
+
+    def test_invalid_from_biadjacency_nodelist(self):
+        M = sp.sparse.csc_array([[1, 2], [0, 3]])
+        # For when top nodelist has the wrong length
+        row_order_invalid = ["a", "b", "c"]
+        # For when bottom nodelist has the wrong length
+        column_order_invalid = ["c", "d", "e"]
+        with pytest.raises(ValueError):
+            bipartite.from_biadjacency_matrix(
+                M,
+                create_using=nx.MultiGraph(),
+                row_order=row_order_invalid,
+            )
+        with pytest.raises(ValueError):
+            bipartite.from_biadjacency_matrix(
+                M,
+                create_using=nx.MultiGraph(),
+                column_order=column_order_invalid,
+            )