okstra 0.113.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/linalg/tests/test_graphmatrix.py

@@ -1,275 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.exception import NetworkXError
-
-np = pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-
-def test_incidence_matrix_simple():
-    deg = [3, 2, 2, 1, 0]
-    G = nx.havel_hakimi_graph(deg)
-    deg = [(1, 0), (1, 0), (1, 0), (2, 0), (1, 0), (2, 1), (0, 1), (0, 1)]
-    MG = nx.random_clustered_graph(deg, seed=42)
-
-    I = nx.incidence_matrix(G, dtype=int).todense()
-    # fmt: off
-    expected = np.array(
-        [[1, 1, 1, 0],
-         [0, 1, 0, 1],
-         [1, 0, 0, 1],
-         [0, 0, 1, 0],
-         [0, 0, 0, 0]]
-    )
-    # fmt: on
-    np.testing.assert_equal(I, expected)
-
-    I = nx.incidence_matrix(MG, dtype=int).todense()
-    # fmt: off
-    expected = np.array(
-        [[1, 0, 0, 0, 0, 0, 0],
-         [1, 0, 0, 0, 0, 0, 0],
-         [0, 1, 0, 0, 0, 0, 0],
-         [0, 0, 0, 0, 0, 0, 0],
-         [0, 1, 0, 0, 0, 0, 0],
-         [0, 0, 0, 0, 1, 1, 0],
-         [0, 0, 0, 0, 0, 1, 1],
-         [0, 0, 0, 0, 1, 0, 1]]
-    )
-    # fmt: on
-    np.testing.assert_equal(I, expected)
-
-    with pytest.raises(NetworkXError):
-        nx.incidence_matrix(G, nodelist=[0, 1])
-
-
-class TestGraphMatrix:
-    @classmethod
-    def setup_class(cls):
-        deg = [3, 2, 2, 1, 0]
-        cls.G = nx.havel_hakimi_graph(deg)
-        # fmt: off
-        cls.OI = np.array(
-            [[-1, -1, -1, 0],
-             [1, 0, 0, -1],
-             [0, 1, 0, 1],
-             [0, 0, 1, 0],
-             [0, 0, 0, 0]]
-        )
-        cls.A = np.array(
-            [[0, 1, 1, 1, 0],
-             [1, 0, 1, 0, 0],
-             [1, 1, 0, 0, 0],
-             [1, 0, 0, 0, 0],
-             [0, 0, 0, 0, 0]]
-        )
-        # fmt: on
-        cls.WG = nx.havel_hakimi_graph(deg)
-        cls.WG.add_edges_from(
-            (u, v, {"weight": 0.5, "other": 0.3}) for (u, v) in cls.G.edges()
-        )
-        # fmt: off
-        cls.WA = np.array(
-            [[0, 0.5, 0.5, 0.5, 0],
-             [0.5, 0, 0.5, 0, 0],
-             [0.5, 0.5, 0, 0, 0],
-             [0.5, 0, 0, 0, 0],
-             [0, 0, 0, 0, 0]]
-        )
-        # fmt: on
-        cls.MG = nx.MultiGraph(cls.G)
-        cls.MG2 = cls.MG.copy()
-        cls.MG2.add_edge(0, 1)
-        # fmt: off
-        cls.MG2A = np.array(
-            [[0, 2, 1, 1, 0],
-             [2, 0, 1, 0, 0],
-             [1, 1, 0, 0, 0],
-             [1, 0, 0, 0, 0],
-             [0, 0, 0, 0, 0]]
-        )
-        cls.MGOI = np.array(
-            [[-1, -1, -1, -1, 0],
-             [1, 1, 0, 0, -1],
-             [0, 0, 1, 0, 1],
-             [0, 0, 0, 1, 0],
-             [0, 0, 0, 0, 0]]
-        )
-        # fmt: on
-        cls.no_edges_G = nx.Graph([(1, 2), (3, 2, {"weight": 8})])
-        cls.no_edges_A = np.array([[0, 0], [0, 0]])
-
-    def test_incidence_matrix(self):
-        "Conversion to incidence matrix"
-        I = nx.incidence_matrix(
-            self.G,
-            nodelist=sorted(self.G),
-            edgelist=sorted(self.G.edges()),
-            oriented=True,
-            dtype=int,
-        ).todense()
-        np.testing.assert_equal(I, self.OI)
-
-        I = nx.incidence_matrix(
-            self.G,
-            nodelist=sorted(self.G),
-            edgelist=sorted(self.G.edges()),
-            oriented=False,
-            dtype=int,
-        ).todense()
-        np.testing.assert_equal(I, np.abs(self.OI))
-
-        I = nx.incidence_matrix(
-            self.MG,
-            nodelist=sorted(self.MG),
-            edgelist=sorted(self.MG.edges()),
-            oriented=True,
-            dtype=int,
-        ).todense()
-        np.testing.assert_equal(I, self.OI)
-
-        I = nx.incidence_matrix(
-            self.MG,
-            nodelist=sorted(self.MG),
-            edgelist=sorted(self.MG.edges()),
-            oriented=False,
-            dtype=int,
-        ).todense()
-        np.testing.assert_equal(I, np.abs(self.OI))
-
-        I = nx.incidence_matrix(
-            self.MG2,
-            nodelist=sorted(self.MG2),
-            edgelist=sorted(self.MG2.edges()),
-            oriented=True,
-            dtype=int,
-        ).todense()
-        np.testing.assert_equal(I, self.MGOI)
-
-        I = nx.incidence_matrix(
-            self.MG2,
-            nodelist=sorted(self.MG),
-            edgelist=sorted(self.MG2.edges()),
-            oriented=False,
-            dtype=int,
-        ).todense()
-        np.testing.assert_equal(I, np.abs(self.MGOI))
-
-        I = nx.incidence_matrix(self.G, dtype=np.uint8)
-        assert I.dtype == np.uint8
-
-    def test_weighted_incidence_matrix(self):
-        I = nx.incidence_matrix(
-            self.WG,
-            nodelist=sorted(self.WG),
-            edgelist=sorted(self.WG.edges()),
-            oriented=True,
-            dtype=int,
-        ).todense()
-        np.testing.assert_equal(I, self.OI)
-
-        I = nx.incidence_matrix(
-            self.WG,
-            nodelist=sorted(self.WG),
-            edgelist=sorted(self.WG.edges()),
-            oriented=False,
-            dtype=int,
-        ).todense()
-        np.testing.assert_equal(I, np.abs(self.OI))
-
-        # np.testing.assert_equal(nx.incidence_matrix(self.WG,oriented=True,
-        #                                  weight='weight').todense(),0.5*self.OI)
-        # np.testing.assert_equal(nx.incidence_matrix(self.WG,weight='weight').todense(),
-        #              np.abs(0.5*self.OI))
-        # np.testing.assert_equal(nx.incidence_matrix(self.WG,oriented=True,weight='other').todense(),
-        #              0.3*self.OI)
-
-        I = nx.incidence_matrix(
-            self.WG,
-            nodelist=sorted(self.WG),
-            edgelist=sorted(self.WG.edges()),
-            oriented=True,
-            weight="weight",
-        ).todense()
-        np.testing.assert_equal(I, 0.5 * self.OI)
-
-        I = nx.incidence_matrix(
-            self.WG,
-            nodelist=sorted(self.WG),
-            edgelist=sorted(self.WG.edges()),
-            oriented=False,
-            weight="weight",
-        ).todense()
-        np.testing.assert_equal(I, np.abs(0.5 * self.OI))
-
-        I = nx.incidence_matrix(
-            self.WG,
-            nodelist=sorted(self.WG),
-            edgelist=sorted(self.WG.edges()),
-            oriented=True,
-            weight="other",
-        ).todense()
-        np.testing.assert_equal(I, 0.3 * self.OI)
-
-        # WMG=nx.MultiGraph(self.WG)
-        # WMG.add_edge(0,1,weight=0.5,other=0.3)
-        # np.testing.assert_equal(nx.incidence_matrix(WMG,weight='weight').todense(),
-        #              np.abs(0.5*self.MGOI))
-        # np.testing.assert_equal(nx.incidence_matrix(WMG,weight='weight',oriented=True).todense(),
-        #              0.5*self.MGOI)
-        # np.testing.assert_equal(nx.incidence_matrix(WMG,weight='other',oriented=True).todense(),
-        #              0.3*self.MGOI)
-
-        WMG = nx.MultiGraph(self.WG)
-        WMG.add_edge(0, 1, weight=0.5, other=0.3)
-
-        I = nx.incidence_matrix(
-            WMG,
-            nodelist=sorted(WMG),
-            edgelist=sorted(WMG.edges(keys=True)),
-            oriented=True,
-            weight="weight",
-        ).todense()
-        np.testing.assert_equal(I, 0.5 * self.MGOI)
-
-        I = nx.incidence_matrix(
-            WMG,
-            nodelist=sorted(WMG),
-            edgelist=sorted(WMG.edges(keys=True)),
-            oriented=False,
-            weight="weight",
-        ).todense()
-        np.testing.assert_equal(I, np.abs(0.5 * self.MGOI))
-
-        I = nx.incidence_matrix(
-            WMG,
-            nodelist=sorted(WMG),
-            edgelist=sorted(WMG.edges(keys=True)),
-            oriented=True,
-            weight="other",
-        ).todense()
-        np.testing.assert_equal(I, 0.3 * self.MGOI)
-
-    def test_adjacency_matrix(self):
-        "Conversion to adjacency matrix"
-        np.testing.assert_equal(nx.adjacency_matrix(self.G).todense(), self.A)
-        np.testing.assert_equal(nx.adjacency_matrix(self.MG).todense(), self.A)
-        np.testing.assert_equal(nx.adjacency_matrix(self.MG2).todense(), self.MG2A)
-        np.testing.assert_equal(
-            nx.adjacency_matrix(self.G, nodelist=[0, 1]).todense(), self.A[:2, :2]
-        )
-        np.testing.assert_equal(nx.adjacency_matrix(self.WG).todense(), self.WA)
-        np.testing.assert_equal(
-            nx.adjacency_matrix(self.WG, weight=None).todense(), self.A
-        )
-        np.testing.assert_equal(
-            nx.adjacency_matrix(self.MG2, weight=None).todense(), self.MG2A
-        )
-        np.testing.assert_equal(
-            nx.adjacency_matrix(self.WG, weight="other").todense(), 0.6 * self.WA
-        )
-        np.testing.assert_equal(
-            nx.adjacency_matrix(self.no_edges_G, nodelist=[1, 3]).todense(),
-            self.no_edges_A,
-        )

package/runtime/python/okstra_vendor/networkx/linalg/tests/test_laplacian.py

@@ -1,334 +0,0 @@
-import pytest
-
-import networkx as nx
-
-np = pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-
-class TestLaplacian:
-    @classmethod
-    def setup_class(cls):
-        deg = [3, 2, 2, 1, 0]
-        cls.G = nx.havel_hakimi_graph(deg)
-        cls.WG = nx.Graph(
-            (u, v, {"weight": 0.5, "other": 0.3}) for (u, v) in cls.G.edges()
-        )
-        cls.WG.add_node(4)
-        cls.MG = nx.MultiGraph(cls.G)
-
-        # Graph with clsloops
-        cls.Gsl = cls.G.copy()
-        for node in cls.Gsl.nodes():
-            cls.Gsl.add_edge(node, node)
-
-        # Graph used as an example in Sec. 4.1 of Langville and Meyer,
-        # "Google's PageRank and Beyond".
-        cls.DiG = nx.DiGraph()
-        cls.DiG.add_edges_from(
-            (
-                (1, 2),
-                (1, 3),
-                (3, 1),
-                (3, 2),
-                (3, 5),
-                (4, 5),
-                (4, 6),
-                (5, 4),
-                (5, 6),
-                (6, 4),
-            )
-        )
-        cls.DiMG = nx.MultiDiGraph(cls.DiG)
-        cls.DiWG = nx.DiGraph(
-            (u, v, {"weight": 0.5, "other": 0.3}) for (u, v) in cls.DiG.edges()
-        )
-        cls.DiGsl = cls.DiG.copy()
-        for node in cls.DiGsl.nodes():
-            cls.DiGsl.add_edge(node, node)
-
-    def test_laplacian(self):
-        "Graph Laplacian"
-        # fmt: off
-        NL = np.array([[ 3, -1, -1, -1,  0],
-                       [-1,  2, -1,  0,  0],
-                       [-1, -1,  2,  0,  0],
-                       [-1,  0,  0,  1,  0],
-                       [ 0,  0,  0,  0,  0]])
-        # fmt: on
-        WL = 0.5 * NL
-        OL = 0.3 * NL
-        # fmt: off
-        DiNL = np.array([[ 2, -1, -1,  0,  0,  0],
-                         [ 0,  0,  0,  0,  0,  0],
-                         [-1, -1,  3, -1,  0,  0],
-                         [ 0,  0,  0,  2, -1, -1],
-                         [ 0,  0,  0, -1,  2, -1],
-                         [ 0,  0,  0,  0, -1,  1]])
-        # fmt: on
-        DiWL = 0.5 * DiNL
-        DiOL = 0.3 * DiNL
-        np.testing.assert_equal(nx.laplacian_matrix(self.G).todense(), NL)
-        np.testing.assert_equal(nx.laplacian_matrix(self.MG).todense(), NL)
-        np.testing.assert_equal(
-            nx.laplacian_matrix(self.G, nodelist=[0, 1]).todense(),
-            np.array([[1, -1], [-1, 1]]),
-        )
-        np.testing.assert_equal(nx.laplacian_matrix(self.WG).todense(), WL)
-        np.testing.assert_equal(nx.laplacian_matrix(self.WG, weight=None).todense(), NL)
-        np.testing.assert_equal(
-            nx.laplacian_matrix(self.WG, weight="other").todense(), OL
-        )
-
-        np.testing.assert_equal(nx.laplacian_matrix(self.DiG).todense(), DiNL)
-        np.testing.assert_equal(nx.laplacian_matrix(self.DiMG).todense(), DiNL)
-        np.testing.assert_equal(
-            nx.laplacian_matrix(self.DiG, nodelist=[1, 2]).todense(),
-            np.array([[1, -1], [0, 0]]),
-        )
-        np.testing.assert_equal(nx.laplacian_matrix(self.DiWG).todense(), DiWL)
-        np.testing.assert_equal(
-            nx.laplacian_matrix(self.DiWG, weight=None).todense(), DiNL
-        )
-        np.testing.assert_equal(
-            nx.laplacian_matrix(self.DiWG, weight="other").todense(), DiOL
-        )
-
-    def test_normalized_laplacian(self):
-        "Generalized Graph Laplacian"
-        # fmt: off
-        G = np.array([[ 1.   , -0.408, -0.408, -0.577,  0.],
-                      [-0.408,  1.   , -0.5  ,  0.   ,  0.],
-                      [-0.408, -0.5  ,  1.   ,  0.   ,  0.],
-                      [-0.577,  0.   ,  0.   ,  1.   ,  0.],
-                      [ 0.   ,  0.   ,  0.   ,  0.   ,  0.]])
-        GL = np.array([[ 1.   , -0.408, -0.408, -0.577,  0.   ],
-                       [-0.408,  1.   , -0.5  ,  0.   ,  0.   ],
-                       [-0.408, -0.5  ,  1.   ,  0.   ,  0.   ],
-                       [-0.577,  0.   ,  0.   ,  1.   ,  0.   ],
-                       [ 0.   ,  0.   ,  0.   ,  0.   ,  0.   ]])
-        Lsl = np.array([[ 0.75  , -0.2887, -0.2887, -0.3536,  0.    ],
-                        [-0.2887,  0.6667, -0.3333,  0.    ,  0.    ],
-                        [-0.2887, -0.3333,  0.6667,  0.    ,  0.    ],
-                        [-0.3536,  0.    ,  0.    ,  0.5   ,  0.    ],
-                        [ 0.    ,  0.    ,  0.    ,  0.    ,  0.    ]])
-
-        DiG = np.array([[ 1.    ,  0.    , -0.4082,  0.    ,  0.    ,  0.    ],
-                        [ 0.    ,  0.    ,  0.    ,  0.    ,  0.    ,  0.    ],
-                        [-0.4082,  0.    ,  1.    ,  0.    , -0.4082,  0.    ],
-                        [ 0.    ,  0.    ,  0.    ,  1.    , -0.5   , -0.7071],
-                        [ 0.    ,  0.    ,  0.    , -0.5   ,  1.    , -0.7071],
-                        [ 0.    ,  0.    ,  0.    , -0.7071,  0.     , 1.    ]])
-        DiGL = np.array([[ 1.    ,  0.    , -0.4082,  0.    ,  0.    ,  0.    ],
-                         [ 0.    ,  0.    ,  0.    ,  0.    ,  0.    ,  0.    ],
-                         [-0.4082,  0.    ,  1.    , -0.4082,  0.    ,  0.    ],
-                         [ 0.    ,  0.    ,  0.    ,  1.    , -0.5   , -0.7071],
-                         [ 0.    ,  0.    ,  0.    , -0.5   ,  1.    , -0.7071],
-                         [ 0.    ,  0.    ,  0.    ,  0.    , -0.7071,  1.    ]])
-        DiLsl = np.array([[ 0.6667, -0.5774, -0.2887,  0.    ,  0.    ,  0.    ],
-                          [ 0.    ,  0.    ,  0.    ,  0.    ,  0.    ,  0.    ],
-                          [-0.2887, -0.5   ,  0.75  , -0.2887,  0.    ,  0.    ],
-                          [ 0.    ,  0.    ,  0.    ,  0.6667, -0.3333, -0.4082],
-                          [ 0.    ,  0.    ,  0.    , -0.3333,  0.6667, -0.4082],
-                          [ 0.    ,  0.    ,  0.    ,  0.    , -0.4082,  0.5   ]])
-        # fmt: on
-
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.G, nodelist=range(5)).todense(),
-            G,
-            decimal=3,
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.G).todense(), GL, decimal=3
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.MG).todense(), GL, decimal=3
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.WG).todense(), GL, decimal=3
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.WG, weight="other").todense(),
-            GL,
-            decimal=3,
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.Gsl).todense(), Lsl, decimal=3
-        )
-
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(
-                self.DiG,
-                nodelist=range(1, 1 + 6),
-            ).todense(),
-            DiG,
-            decimal=3,
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.DiG).todense(), DiGL, decimal=3
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.DiMG).todense(), DiGL, decimal=3
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.DiWG).todense(), DiGL, decimal=3
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.DiWG, weight="other").todense(),
-            DiGL,
-            decimal=3,
-        )
-        np.testing.assert_almost_equal(
-            nx.normalized_laplacian_matrix(self.DiGsl).todense(), DiLsl, decimal=3
-        )
-
-
-def test_directed_laplacian():
-    "Directed Laplacian"
-    # Graph used as an example in Sec. 4.1 of Langville and Meyer,
-    # "Google's PageRank and Beyond". The graph contains dangling nodes, so
-    # the pagerank random walk is selected by directed_laplacian
-    G = nx.DiGraph()
-    G.add_edges_from(
-        (
-            (1, 2),
-            (1, 3),
-            (3, 1),
-            (3, 2),
-            (3, 5),
-            (4, 5),
-            (4, 6),
-            (5, 4),
-            (5, 6),
-            (6, 4),
-        )
-    )
-    # fmt: off
-    GL = np.array([[ 0.9833, -0.2941, -0.3882, -0.0291, -0.0231, -0.0261],
-                   [-0.2941,  0.8333, -0.2339, -0.0536, -0.0589, -0.0554],
-                   [-0.3882, -0.2339,  0.9833, -0.0278, -0.0896, -0.0251],
-                   [-0.0291, -0.0536, -0.0278,  0.9833, -0.4878, -0.6675],
-                   [-0.0231, -0.0589, -0.0896, -0.4878,  0.9833, -0.2078],
-                   [-0.0261, -0.0554, -0.0251, -0.6675, -0.2078,  0.9833]])
-    # fmt: on
-    L = nx.directed_laplacian_matrix(G, alpha=0.9, nodelist=sorted(G))
-    np.testing.assert_almost_equal(L, GL, decimal=3)
-
-    # Make the graph strongly connected, so we can use a random and lazy walk
-    G.add_edges_from(((2, 5), (6, 1)))
-    # fmt: off
-    GL = np.array([[ 1.    , -0.3062, -0.4714,  0.    ,  0.    , -0.3227],
-                   [-0.3062,  1.    , -0.1443,  0.    , -0.3162,  0.    ],
-                   [-0.4714, -0.1443,  1.    ,  0.    , -0.0913,  0.    ],
-                   [ 0.    ,  0.    ,  0.    ,  1.    , -0.5   , -0.5   ],
-                   [ 0.    , -0.3162, -0.0913, -0.5   ,  1.    , -0.25  ],
-                   [-0.3227,  0.    ,  0.    , -0.5   , -0.25  ,  1.    ]])
-    # fmt: on
-    L = nx.directed_laplacian_matrix(
-        G, alpha=0.9, nodelist=sorted(G), walk_type="random"
-    )
-    np.testing.assert_almost_equal(L, GL, decimal=3)
-
-    # fmt: off
-    GL = np.array([[ 0.5   , -0.1531, -0.2357,  0.    ,  0.    , -0.1614],
-                   [-0.1531,  0.5   , -0.0722,  0.    , -0.1581,  0.    ],
-                   [-0.2357, -0.0722,  0.5   ,  0.    , -0.0456,  0.    ],
-                   [ 0.    ,  0.    ,  0.    ,  0.5   , -0.25  , -0.25  ],
-                   [ 0.    , -0.1581, -0.0456, -0.25  ,  0.5   , -0.125 ],
-                   [-0.1614,  0.    ,  0.    , -0.25  , -0.125 ,  0.5   ]])
-    # fmt: on
-    L = nx.directed_laplacian_matrix(G, alpha=0.9, nodelist=sorted(G), walk_type="lazy")
-    np.testing.assert_almost_equal(L, GL, decimal=3)
-
-    # Make a strongly connected periodic graph
-    G = nx.DiGraph()
-    G.add_edges_from(((1, 2), (2, 4), (4, 1), (1, 3), (3, 4)))
-    # fmt: off
-    GL = np.array([[ 0.5  , -0.176, -0.176, -0.25 ],
-                   [-0.176,  0.5  ,  0.   , -0.176],
-                   [-0.176,  0.   ,  0.5  , -0.176],
-                   [-0.25 , -0.176, -0.176,  0.5  ]])
-    # fmt: on
-    L = nx.directed_laplacian_matrix(G, alpha=0.9, nodelist=sorted(G))
-    np.testing.assert_almost_equal(L, GL, decimal=3)
-
-
-def test_directed_combinatorial_laplacian():
-    "Directed combinatorial Laplacian"
-    # Graph used as an example in Sec. 4.1 of Langville and Meyer,
-    # "Google's PageRank and Beyond". The graph contains dangling nodes, so
-    # the pagerank random walk is selected by directed_laplacian
-    G = nx.DiGraph()
-    G.add_edges_from(
-        (
-            (1, 2),
-            (1, 3),
-            (3, 1),
-            (3, 2),
-            (3, 5),
-            (4, 5),
-            (4, 6),
-            (5, 4),
-            (5, 6),
-            (6, 4),
-        )
-    )
-    # fmt: off
-    GL = np.array([[ 0.0366, -0.0132, -0.0153, -0.0034, -0.0020, -0.0027],
-                   [-0.0132,  0.0450, -0.0111, -0.0076, -0.0062, -0.0069],
-                   [-0.0153, -0.0111,  0.0408, -0.0035, -0.0083, -0.0027],
-                   [-0.0034, -0.0076, -0.0035,  0.3688, -0.1356, -0.2187],
-                   [-0.0020, -0.0062, -0.0083, -0.1356,  0.2026, -0.0505],
-                   [-0.0027, -0.0069, -0.0027, -0.2187, -0.0505,  0.2815]])
-    # fmt: on
-
-    L = nx.directed_combinatorial_laplacian_matrix(G, alpha=0.9, nodelist=sorted(G))
-    np.testing.assert_almost_equal(L, GL, decimal=3)
-
-    # Make the graph strongly connected, so we can use a random and lazy walk
-    G.add_edges_from(((2, 5), (6, 1)))
-
-    # fmt: off
-    GL = np.array([[ 0.1395, -0.0349, -0.0465,  0.    ,  0.    , -0.0581],
-                   [-0.0349,  0.093 , -0.0116,  0.    , -0.0465,  0.    ],
-                   [-0.0465, -0.0116,  0.0698,  0.    , -0.0116,  0.    ],
-                   [ 0.    ,  0.    ,  0.    ,  0.2326, -0.1163, -0.1163],
-                   [ 0.    , -0.0465, -0.0116, -0.1163,  0.2326, -0.0581],
-                   [-0.0581,  0.    ,  0.    , -0.1163, -0.0581,  0.2326]])
-    # fmt: on
-
-    L = nx.directed_combinatorial_laplacian_matrix(
-        G, alpha=0.9, nodelist=sorted(G), walk_type="random"
-    )
-    np.testing.assert_almost_equal(L, GL, decimal=3)
-
-    # fmt: off
-    GL = np.array([[ 0.0698, -0.0174, -0.0233,  0.    ,  0.    , -0.0291],
-                   [-0.0174,  0.0465, -0.0058,  0.    , -0.0233,  0.    ],
-                   [-0.0233, -0.0058,  0.0349,  0.    , -0.0058,  0.    ],
-                   [ 0.    ,  0.    ,  0.    ,  0.1163, -0.0581, -0.0581],
-                   [ 0.    , -0.0233, -0.0058, -0.0581,  0.1163, -0.0291],
-                   [-0.0291,  0.    ,  0.    , -0.0581, -0.0291,  0.1163]])
-    # fmt: on
-
-    L = nx.directed_combinatorial_laplacian_matrix(
-        G, alpha=0.9, nodelist=sorted(G), walk_type="lazy"
-    )
-    np.testing.assert_almost_equal(L, GL, decimal=3)
-
-    E = nx.DiGraph(nx.margulis_gabber_galil_graph(2))
-    L = nx.directed_combinatorial_laplacian_matrix(E)
-    # fmt: off
-    expected = np.array(
-        [[ 0.16666667, -0.08333333, -0.08333333,  0.        ],
-         [-0.08333333,  0.16666667,  0.        , -0.08333333],
-         [-0.08333333,  0.        ,  0.16666667, -0.08333333],
-         [ 0.        , -0.08333333, -0.08333333,  0.16666667]]
-    )
-    # fmt: on
-    np.testing.assert_almost_equal(L, expected, decimal=6)
-
-    with pytest.raises(nx.NetworkXError):
-        nx.directed_combinatorial_laplacian_matrix(G, walk_type="pagerank", alpha=100)
-    with pytest.raises(nx.NetworkXError):
-        nx.directed_combinatorial_laplacian_matrix(G, walk_type="silly")

package/runtime/python/okstra_vendor/networkx/linalg/tests/test_modularity.py

@@ -1,86 +0,0 @@
-import pytest
-
-import networkx as nx
-
-np = pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-
-class TestModularity:
-    @classmethod
-    def setup_class(cls):
-        deg = [3, 2, 2, 1, 0]
-        cls.G = nx.havel_hakimi_graph(deg)
-        # Graph used as an example in Sec. 4.1 of Langville and Meyer,
-        # "Google's PageRank and Beyond". (Used for test_directed_laplacian)
-        cls.DG = nx.DiGraph()
-        cls.DG.add_edges_from(
-            (
-                (1, 2),
-                (1, 3),
-                (3, 1),
-                (3, 2),
-                (3, 5),
-                (4, 5),
-                (4, 6),
-                (5, 4),
-                (5, 6),
-                (6, 4),
-            )
-        )
-
-    def test_modularity(self):
-        "Modularity matrix"
-        # fmt: off
-        B = np.array([[-1.125,  0.25,  0.25,  0.625,  0.],
-                      [0.25, -0.5,  0.5, -0.25,  0.],
-                      [0.25,  0.5, -0.5, -0.25,  0.],
-                      [0.625, -0.25, -0.25, -0.125,  0.],
-                      [0.,  0.,  0.,  0.,  0.]])
-        # fmt: on
-
-        permutation = [4, 0, 1, 2, 3]
-        np.testing.assert_equal(nx.modularity_matrix(self.G), B)
-        np.testing.assert_equal(
-            nx.modularity_matrix(self.G, nodelist=permutation),
-            B[np.ix_(permutation, permutation)],
-        )
-
-    def test_modularity_weight(self):
-        "Modularity matrix with weights"
-        # fmt: off
-        B = np.array([[-1.125,  0.25,  0.25,  0.625,  0.],
-                      [0.25, -0.5,  0.5, -0.25,  0.],
-                      [0.25,  0.5, -0.5, -0.25,  0.],
-                      [0.625, -0.25, -0.25, -0.125,  0.],
-                      [0.,  0.,  0.,  0.,  0.]])
-        # fmt: on
-
-        G_weighted = self.G.copy()
-        for n1, n2 in G_weighted.edges():
-            G_weighted.edges[n1, n2]["weight"] = 0.5
-        # The following test would fail in networkx 1.1
-        np.testing.assert_equal(nx.modularity_matrix(G_weighted), B)
-        # The following test that the modularity matrix get rescaled accordingly
-        np.testing.assert_equal(
-            nx.modularity_matrix(G_weighted, weight="weight"), 0.5 * B
-        )
-
-    def test_directed_modularity(self):
-        "Directed Modularity matrix"
-        # fmt: off
-        B = np.array([[-0.2,  0.6,  0.8, -0.4, -0.4, -0.4],
-                      [0.,  0.,  0.,  0.,  0.,  0.],
-                      [0.7,  0.4, -0.3, -0.6,  0.4, -0.6],
-                      [-0.2, -0.4, -0.2, -0.4,  0.6,  0.6],
-                      [-0.2, -0.4, -0.2,  0.6, -0.4,  0.6],
-                      [-0.1, -0.2, -0.1,  0.8, -0.2, -0.2]])
-        # fmt: on
-        node_permutation = [5, 1, 2, 3, 4, 6]
-        idx_permutation = [4, 0, 1, 2, 3, 5]
-        mm = nx.directed_modularity_matrix(self.DG, nodelist=sorted(self.DG))
-        np.testing.assert_equal(mm, B)
-        np.testing.assert_equal(
-            nx.directed_modularity_matrix(self.DG, nodelist=node_permutation),
-            B[np.ix_(idx_permutation, idx_permutation)],
-        )