okstra 0.113.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/algorithms/centrality/tests/test_katz_centrality.py

@@ -1,345 +0,0 @@
-import math
-
-import pytest
-
-import networkx as nx
-
-
-class TestKatzCentrality:
-    def test_K5(self):
-        """Katz centrality: K5"""
-        G = nx.complete_graph(5)
-        alpha = 0.1
-        b = nx.katz_centrality(G, alpha)
-        v = math.sqrt(1 / 5.0)
-        b_answer = dict.fromkeys(G, v)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-        nstart = {n: 1 for n in G}
-        b = nx.katz_centrality(G, alpha, nstart=nstart)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_P3(self):
-        """Katz centrality: P3"""
-        alpha = 0.1
-        G = nx.path_graph(3)
-        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
-        b = nx.katz_centrality(G, alpha)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-
-    def test_maxiter(self):
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            nx.katz_centrality(nx.path_graph(3), 0.1, max_iter=0)
-
-    def test_beta_as_scalar(self):
-        alpha = 0.1
-        beta = 0.1
-        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
-        G = nx.path_graph(3)
-        b = nx.katz_centrality(G, alpha, beta)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-
-    def test_beta_as_dict(self):
-        alpha = 0.1
-        beta = {0: 1.0, 1: 1.0, 2: 1.0}
-        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
-        G = nx.path_graph(3)
-        b = nx.katz_centrality(G, alpha, beta)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-
-    def test_multiple_alpha(self):
-        alpha_list = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]
-        for alpha in alpha_list:
-            b_answer = {
-                0.1: {
-                    0: 0.5598852584152165,
-                    1: 0.6107839182711449,
-                    2: 0.5598852584152162,
-                },
-                0.2: {
-                    0: 0.5454545454545454,
-                    1: 0.6363636363636365,
-                    2: 0.5454545454545454,
-                },
-                0.3: {
-                    0: 0.5333964609104419,
-                    1: 0.6564879518897746,
-                    2: 0.5333964609104419,
-                },
-                0.4: {
-                    0: 0.5232045649263551,
-                    1: 0.6726915834767423,
-                    2: 0.5232045649263551,
-                },
-                0.5: {
-                    0: 0.5144957746691622,
-                    1: 0.6859943117075809,
-                    2: 0.5144957746691622,
-                },
-                0.6: {
-                    0: 0.5069794004195823,
-                    1: 0.6970966755769258,
-                    2: 0.5069794004195823,
-                },
-            }
-            G = nx.path_graph(3)
-            b = nx.katz_centrality(G, alpha)
-            for n in sorted(G):
-                assert b[n] == pytest.approx(b_answer[alpha][n], abs=1e-4)
-
-    def test_multigraph(self):
-        with pytest.raises(nx.NetworkXException):
-            nx.katz_centrality(nx.MultiGraph(), 0.1)
-
-    def test_empty(self):
-        e = nx.katz_centrality(nx.Graph(), 0.1)
-        assert e == {}
-
-    def test_bad_beta(self):
-        with pytest.raises(nx.NetworkXException):
-            G = nx.Graph([(0, 1)])
-            beta = {0: 77}
-            nx.katz_centrality(G, 0.1, beta=beta)
-
-    def test_bad_beta_number(self):
-        with pytest.raises(nx.NetworkXException):
-            G = nx.Graph([(0, 1)])
-            nx.katz_centrality(G, 0.1, beta="foo")
-
-
-class TestKatzCentralityNumpy:
-    @classmethod
-    def setup_class(cls):
-        global np
-        np = pytest.importorskip("numpy")
-        pytest.importorskip("scipy")
-
-    def test_K5(self):
-        """Katz centrality: K5"""
-        G = nx.complete_graph(5)
-        alpha = 0.1
-        b = nx.katz_centrality(G, alpha)
-        v = math.sqrt(1 / 5.0)
-        b_answer = dict.fromkeys(G, v)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-        b = nx.eigenvector_centrality_numpy(G)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
-
-    def test_P3(self):
-        """Katz centrality: P3"""
-        alpha = 0.1
-        G = nx.path_graph(3)
-        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
-        b = nx.katz_centrality_numpy(G, alpha)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-
-    def test_beta_as_scalar(self):
-        alpha = 0.1
-        beta = 0.1
-        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
-        G = nx.path_graph(3)
-        b = nx.katz_centrality_numpy(G, alpha, beta)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-
-    def test_beta_as_dict(self):
-        alpha = 0.1
-        beta = {0: 1.0, 1: 1.0, 2: 1.0}
-        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
-        G = nx.path_graph(3)
-        b = nx.katz_centrality_numpy(G, alpha, beta)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-
-    def test_multiple_alpha(self):
-        alpha_list = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]
-        for alpha in alpha_list:
-            b_answer = {
-                0.1: {
-                    0: 0.5598852584152165,
-                    1: 0.6107839182711449,
-                    2: 0.5598852584152162,
-                },
-                0.2: {
-                    0: 0.5454545454545454,
-                    1: 0.6363636363636365,
-                    2: 0.5454545454545454,
-                },
-                0.3: {
-                    0: 0.5333964609104419,
-                    1: 0.6564879518897746,
-                    2: 0.5333964609104419,
-                },
-                0.4: {
-                    0: 0.5232045649263551,
-                    1: 0.6726915834767423,
-                    2: 0.5232045649263551,
-                },
-                0.5: {
-                    0: 0.5144957746691622,
-                    1: 0.6859943117075809,
-                    2: 0.5144957746691622,
-                },
-                0.6: {
-                    0: 0.5069794004195823,
-                    1: 0.6970966755769258,
-                    2: 0.5069794004195823,
-                },
-            }
-            G = nx.path_graph(3)
-            b = nx.katz_centrality_numpy(G, alpha)
-            for n in sorted(G):
-                assert b[n] == pytest.approx(b_answer[alpha][n], abs=1e-4)
-
-    def test_multigraph(self):
-        with pytest.raises(nx.NetworkXException):
-            nx.katz_centrality(nx.MultiGraph(), 0.1)
-
-    def test_empty(self):
-        e = nx.katz_centrality(nx.Graph(), 0.1)
-        assert e == {}
-
-    def test_bad_beta(self):
-        with pytest.raises(nx.NetworkXException):
-            G = nx.Graph([(0, 1)])
-            beta = {0: 77}
-            nx.katz_centrality_numpy(G, 0.1, beta=beta)
-
-    def test_bad_beta_numbe(self):
-        with pytest.raises(nx.NetworkXException):
-            G = nx.Graph([(0, 1)])
-            nx.katz_centrality_numpy(G, 0.1, beta="foo")
-
-    def test_K5_unweighted(self):
-        """Katz centrality: K5"""
-        G = nx.complete_graph(5)
-        alpha = 0.1
-        b = nx.katz_centrality(G, alpha, weight=None)
-        v = math.sqrt(1 / 5.0)
-        b_answer = dict.fromkeys(G, v)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-        b = nx.eigenvector_centrality_numpy(G, weight=None)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
-
-    def test_P3_unweighted(self):
-        """Katz centrality: P3"""
-        alpha = 0.1
-        G = nx.path_graph(3)
-        b_answer = {0: 0.5598852584152165, 1: 0.6107839182711449, 2: 0.5598852584152162}
-        b = nx.katz_centrality_numpy(G, alpha, weight=None)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-
-
-class TestKatzCentralityDirected:
-    @classmethod
-    def setup_class(cls):
-        G = nx.DiGraph()
-        edges = [
-            (1, 2),
-            (1, 3),
-            (2, 4),
-            (3, 2),
-            (3, 5),
-            (4, 2),
-            (4, 5),
-            (4, 6),
-            (5, 6),
-            (5, 7),
-            (5, 8),
-            (6, 8),
-            (7, 1),
-            (7, 5),
-            (7, 8),
-            (8, 6),
-            (8, 7),
-        ]
-        G.add_edges_from(edges, weight=2.0)
-        cls.G = G.reverse()
-        cls.G.alpha = 0.1
-        cls.G.evc = [
-            0.3289589783189635,
-            0.2832077296243516,
-            0.3425906003685471,
-            0.3970420865198392,
-            0.41074871061646284,
-            0.272257430756461,
-            0.4201989685435462,
-            0.34229059218038554,
-        ]
-
-        H = nx.DiGraph(edges)
-        cls.H = G.reverse()
-        cls.H.alpha = 0.1
-        cls.H.evc = [
-            0.3289589783189635,
-            0.2832077296243516,
-            0.3425906003685471,
-            0.3970420865198392,
-            0.41074871061646284,
-            0.272257430756461,
-            0.4201989685435462,
-            0.34229059218038554,
-        ]
-
-    def test_katz_centrality_weighted(self):
-        G = self.G
-        alpha = self.G.alpha
-        p = nx.katz_centrality(G, alpha, weight="weight")
-        for a, b in zip(list(p.values()), self.G.evc):
-            assert a == pytest.approx(b, abs=1e-7)
-
-    def test_katz_centrality_unweighted(self):
-        H = self.H
-        alpha = self.H.alpha
-        p = nx.katz_centrality(H, alpha, weight="weight")
-        for a, b in zip(list(p.values()), self.H.evc):
-            assert a == pytest.approx(b, abs=1e-7)
-
-
-class TestKatzCentralityDirectedNumpy(TestKatzCentralityDirected):
-    @classmethod
-    def setup_class(cls):
-        global np
-        np = pytest.importorskip("numpy")
-        pytest.importorskip("scipy")
-        super().setup_class()
-
-    def test_katz_centrality_weighted(self):
-        G = self.G
-        alpha = self.G.alpha
-        p = nx.katz_centrality_numpy(G, alpha, weight="weight")
-        for a, b in zip(list(p.values()), self.G.evc):
-            assert a == pytest.approx(b, abs=1e-7)
-
-    def test_katz_centrality_unweighted(self):
-        H = self.H
-        alpha = self.H.alpha
-        p = nx.katz_centrality_numpy(H, alpha, weight="weight")
-        for a, b in zip(list(p.values()), self.H.evc):
-            assert a == pytest.approx(b, abs=1e-7)
-
-
-class TestKatzEigenvectorVKatz:
-    @classmethod
-    def setup_class(cls):
-        global np
-        np = pytest.importorskip("numpy")
-        pytest.importorskip("scipy")
-
-    def test_eigenvector_v_katz_random(self):
-        G = nx.gnp_random_graph(10, 0.5, seed=1234)
-        l = max(np.linalg.eigvals(nx.adjacency_matrix(G).todense()))
-        e = nx.eigenvector_centrality_numpy(G)
-        k = nx.katz_centrality_numpy(G, 1.0 / l)
-        for n in G:
-            assert e[n] == pytest.approx(k[n], abs=1e-7)

package/runtime/python/okstra_vendor/networkx/algorithms/centrality/tests/test_laplacian_centrality.py

@@ -1,220 +0,0 @@
-import pytest
-
-import networkx as nx
-
-np = pytest.importorskip("numpy")
-sp = pytest.importorskip("scipy")
-
-
-def test_laplacian_centrality_null_graph():
-    G = nx.Graph()
-    with pytest.raises(nx.NetworkXPointlessConcept):
-        d = nx.laplacian_centrality(G, normalized=False)
-
-
-def test_laplacian_centrality_single_node():
-    """See gh-6571"""
-    G = nx.empty_graph(1)
-    assert nx.laplacian_centrality(G, normalized=False) == {0: 0}
-    with pytest.raises(ZeroDivisionError):
-        nx.laplacian_centrality(G, normalized=True)
-
-
-def test_laplacian_centrality_unconnected_nodes():
-    """laplacian_centrality on a unconnected node graph should return 0
-
-    For graphs without edges, the Laplacian energy is 0 and is unchanged with
-    node removal, so::
-
-        LC(v) = LE(G) - LE(G - v) = 0 - 0 = 0
-    """
-    G = nx.empty_graph(3)
-    assert nx.laplacian_centrality(G, normalized=False) == {0: 0, 1: 0, 2: 0}
-
-
-def test_laplacian_centrality_empty_graph():
-    G = nx.empty_graph(3)
-    with pytest.raises(ZeroDivisionError):
-        d = nx.laplacian_centrality(G, normalized=True)
-
-
-def test_laplacian_centrality_E():
-    E = nx.Graph()
-    E.add_weighted_edges_from(
-        [(0, 1, 4), (4, 5, 1), (0, 2, 2), (2, 1, 1), (1, 3, 2), (1, 4, 2)]
-    )
-    d = nx.laplacian_centrality(E)
-    exact = {
-        0: 0.700000,
-        1: 0.900000,
-        2: 0.280000,
-        3: 0.220000,
-        4: 0.260000,
-        5: 0.040000,
-    }
-
-    for n, dc in d.items():
-        assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-    # Check not normalized
-    full_energy = 200
-    dnn = nx.laplacian_centrality(E, normalized=False)
-    for n, dc in dnn.items():
-        assert exact[n] * full_energy == pytest.approx(dc, abs=1e-7)
-
-    # Check unweighted not-normalized version
-    duw_nn = nx.laplacian_centrality(E, normalized=False, weight=None)
-    exact_uw_nn = {
-        0: 18,
-        1: 34,
-        2: 18,
-        3: 10,
-        4: 16,
-        5: 6,
-    }
-    for n, dc in duw_nn.items():
-        assert exact_uw_nn[n] == pytest.approx(dc, abs=1e-7)
-
-    # Check unweighted version
-    duw = nx.laplacian_centrality(E, weight=None)
-    full_energy = 42
-    for n, dc in duw.items():
-        assert exact_uw_nn[n] / full_energy == pytest.approx(dc, abs=1e-7)
-
-
-def test_laplacian_centrality_KC():
-    KC = nx.karate_club_graph()
-    d = nx.laplacian_centrality(KC)
-    exact = {
-        0: 0.2543593,
-        1: 0.1724524,
-        2: 0.2166053,
-        3: 0.0964646,
-        4: 0.0350344,
-        5: 0.0571109,
-        6: 0.0540713,
-        7: 0.0788674,
-        8: 0.1222204,
-        9: 0.0217565,
-        10: 0.0308751,
-        11: 0.0215965,
-        12: 0.0174372,
-        13: 0.118861,
-        14: 0.0366341,
-        15: 0.0548712,
-        16: 0.0172772,
-        17: 0.0191969,
-        18: 0.0225564,
-        19: 0.0331147,
-        20: 0.0279955,
-        21: 0.0246361,
-        22: 0.0382339,
-        23: 0.1294193,
-        24: 0.0227164,
-        25: 0.0644697,
-        26: 0.0281555,
-        27: 0.075188,
-        28: 0.0364742,
-        29: 0.0707087,
-        30: 0.0708687,
-        31: 0.131019,
-        32: 0.2370821,
-        33: 0.3066709,
-    }
-    for n, dc in d.items():
-        assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-    # Check not normalized
-    full_energy = 12502
-    dnn = nx.laplacian_centrality(KC, normalized=False)
-    for n, dc in dnn.items():
-        assert exact[n] * full_energy == pytest.approx(dc, abs=1e-3)
-
-
-def test_laplacian_centrality_K():
-    K = nx.krackhardt_kite_graph()
-    d = nx.laplacian_centrality(K)
-    exact = {
-        0: 0.3010753,
-        1: 0.3010753,
-        2: 0.2258065,
-        3: 0.483871,
-        4: 0.2258065,
-        5: 0.3870968,
-        6: 0.3870968,
-        7: 0.1935484,
-        8: 0.0752688,
-        9: 0.0322581,
-    }
-    for n, dc in d.items():
-        assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-    # Check not normalized
-    full_energy = 186
-    dnn = nx.laplacian_centrality(K, normalized=False)
-    for n, dc in dnn.items():
-        assert exact[n] * full_energy == pytest.approx(dc, abs=1e-3)
-
-
-def test_laplacian_centrality_P3():
-    P3 = nx.path_graph(3)
-    d = nx.laplacian_centrality(P3)
-    exact = {0: 0.6, 1: 1.0, 2: 0.6}
-    for n, dc in d.items():
-        assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-
-def test_laplacian_centrality_K5():
-    K5 = nx.complete_graph(5)
-    d = nx.laplacian_centrality(K5)
-    exact = {0: 0.52, 1: 0.52, 2: 0.52, 3: 0.52, 4: 0.52}
-    for n, dc in d.items():
-        assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-
-def test_laplacian_centrality_FF():
-    FF = nx.florentine_families_graph()
-    d = nx.laplacian_centrality(FF)
-    exact = {
-        "Acciaiuoli": 0.0804598,
-        "Medici": 0.4022989,
-        "Castellani": 0.1724138,
-        "Peruzzi": 0.183908,
-        "Strozzi": 0.2528736,
-        "Barbadori": 0.137931,
-        "Ridolfi": 0.2183908,
-        "Tornabuoni": 0.2183908,
-        "Albizzi": 0.1954023,
-        "Salviati": 0.1149425,
-        "Pazzi": 0.0344828,
-        "Bischeri": 0.1954023,
-        "Guadagni": 0.2298851,
-        "Ginori": 0.045977,
-        "Lamberteschi": 0.0574713,
-    }
-    for n, dc in d.items():
-        assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-
-def test_laplacian_centrality_DG():
-    DG = nx.DiGraph([(0, 5), (1, 5), (2, 5), (3, 5), (4, 5), (5, 6), (5, 7), (5, 8)])
-    d = nx.laplacian_centrality(DG)
-    exact = {
-        0: 0.2123352,
-        5: 0.515391,
-        1: 0.2123352,
-        2: 0.2123352,
-        3: 0.2123352,
-        4: 0.2123352,
-        6: 0.2952031,
-        7: 0.2952031,
-        8: 0.2952031,
-    }
-    for n, dc in d.items():
-        assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-    # Check not normalized
-    full_energy = 9.50704
-    dnn = nx.laplacian_centrality(DG, normalized=False)
-    for n, dc in dnn.items():
-        assert exact[n] * full_energy == pytest.approx(dc, abs=1e-4)