chore: import upstream snapshot with attribution

2026-07-13 12:36:30 +08:00
commit 55ab4e4a73
473 changed files with 72932 additions and 0 deletions
@@ -0,0 +1,72 @@
+import unittest
+
+import easygraph as eg
+
+
+class TestCycleRatioCentrality(unittest.TestCase):
+    def setUp(self):
+        self.G_triangle = eg.Graph()
+        self.G_triangle.add_edges([(1, 2), (2, 3), (3, 1)])
+
+        self.G_star = eg.Graph()
+        self.G_star.add_edges([(1, 2), (1, 3), (1, 4)])
+
+        self.G_complete = eg.complete_graph(4)
+
+        self.G_disconnected = eg.Graph()
+        self.G_disconnected.add_edges([(1, 2), (3, 4)])
+
+    def test_triangle_graph(self):
+        result = eg.cycle_ratio_centrality(self.G_triangle.copy())
+        self.assertTrue(all(isinstance(v, float) for v in result.values()))
+        self.assertEqual(len(result), 3)
+
+    def test_star_graph(self):
+        result = eg.cycle_ratio_centrality(self.G_star.copy())
+        self.assertEqual(result, {})
+
+    def test_complete_graph(self):
+        result = eg.cycle_ratio_centrality(self.G_complete.copy())
+        self.assertEqual(len(result), 4)
+        self.assertTrue(all(v > 0 for v in result.values()))
+
+    def test_disconnected_graph(self):
+        result = eg.cycle_ratio_centrality(self.G_disconnected.copy())
+        self.assertEqual(result, {})
+
+    def test_my_all_shortest_paths_valid(self):
+        G = eg.Graph()
+        G.add_edges([(1, 2), (2, 3), (3, 4)])
+        paths = list(eg.my_all_shortest_paths(G, 1, 4))
+        self.assertIn([1, 2, 3, 4], paths)
+
+    def test_my_all_shortest_paths_invalid(self):
+        G = eg.Graph()
+        G.add_edges([(1, 2), (3, 4)])
+        with self.assertRaises(eg.EasyGraphNoPath):
+            list(eg.my_all_shortest_paths(G, 1, 4))
+
+    def test_getandJudgeSimpleCircle_true(self):
+        G = eg.Graph()
+        G.add_edges([(1, 2), (2, 3), (3, 1)])
+        self.assertTrue(eg.getandJudgeSimpleCircle([1, 2, 3], G))
+
+    def test_getandJudgeSimpleCircle_false(self):
+        G = eg.Graph()
+        G.add_edges([(1, 2), (2, 3)])
+        self.assertFalse(eg.getandJudgeSimpleCircle([1, 2, 3], G))
+
+    def test_statistics_and_calculate_indicators(self):
+        SmallestCyclesOfNodes = {1: set(), 2: set(), 3: set()}
+        CycLenDict = {3: 0}
+        SmallestCycles = {(1, 2, 3)}
+        result = eg.StatisticsAndCalculateIndicators(
+            SmallestCyclesOfNodes, CycLenDict, SmallestCycles
+        )
+        self.assertTrue(isinstance(result, dict))
+        self.assertIn(1, result)
+        self.assertGreater(result[1], 0)
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,38 @@
+import unittest
+
+import easygraph as eg
+
+
+class TestHypergraphDegreeCentrality(unittest.TestCase):
+    def test_basic_degree_centrality(self):
+        hg = eg.Hypergraph(num_v=4, e_list=[(0, 1), (1, 2), (2, 3), (0, 2)])
+        result = eg.hyepergraph_degree_centrality(hg)
+        expected = {0: 2, 1: 2, 2: 3, 3: 1}
+        self.assertEqual(result, expected)
+
+    def test_empty_hypergraph(self):
+        hg = eg.Hypergraph(num_v=1, e_list=[])
+        result = eg.hyepergraph_degree_centrality(hg)
+        self.assertEqual(result, {0: 0})
+
+    def test_single_edge(self):
+        hg = eg.Hypergraph(num_v=3, e_list=[(0, 1, 2)])
+        result = eg.hyepergraph_degree_centrality(hg)
+        expected = {0: 1, 1: 1, 2: 1}
+        self.assertEqual(result, expected)
+
+    def test_singleton_nodes(self):
+        hg = eg.Hypergraph(num_v=3, e_list=[(0,), (1,), (2,)])
+        result = eg.hyepergraph_degree_centrality(hg)
+        expected = {0: 1, 1: 1, 2: 1}
+        self.assertEqual(result, expected)
+
+    def test_node_with_no_edges(self):
+        hg = eg.Hypergraph(num_v=4, e_list=[(0, 1), (1, 2)])
+        result = eg.hyepergraph_degree_centrality(hg)
+        expected = {0: 1, 1: 2, 2: 1, 3: 0}  # node 3 has no edges
+        self.assertEqual(result, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,51 @@
+import unittest
+
+import easygraph as eg
+
+
+class TestHypercoreness(unittest.TestCase):
+    def test_simple_hypergraph(self):
+        hg = eg.Hypergraph(num_v=5, e_list=[(0, 1), (1, 2, 3), (3, 4)])
+        si = eg.size_independent_hypercoreness(hg)
+        fb = eg.frequency_based_hypercoreness(hg)
+
+        self.assertIsInstance(si, dict)
+        self.assertIsInstance(fb, dict)
+        self.assertTrue(set(si.keys()).issubset(set(hg.v)))
+        self.assertTrue(set(fb.keys()).issubset(set(hg.v)))
+
+        for val in si.values():
+            self.assertIsInstance(val, float)
+            self.assertGreaterEqual(val, 0)
+
+        for val in fb.values():
+            self.assertIsInstance(val, float)
+            self.assertGreaterEqual(val, 0)
+
+    def test_single_hyperedge(self):
+        hg = eg.Hypergraph(num_v=3, e_list=[(0, 1, 2)])
+        si = eg.size_independent_hypercoreness(hg)
+        fb = eg.frequency_based_hypercoreness(hg)
+
+        self.assertTrue(all(v >= 0 for v in si.values()))
+        self.assertTrue(all(v >= 0 for v in fb.values()))
+
+    def test_large_uniform_hypergraph(self):
+        hg = eg.Hypergraph(num_v=10, e_list=[(i, i + 1, i + 2) for i in range(7)])
+        si = eg.size_independent_hypercoreness(hg)
+        fb = eg.frequency_based_hypercoreness(hg)
+
+        self.assertEqual(len(si), 10)
+        self.assertEqual(len(fb), 10)
+
+    def test_empty_hypergraph_raises(self):
+        hg = eg.Hypergraph(num_v=1, e_list=[])
+        with self.assertRaises(IndexError):
+            eg.size_independent_hypercoreness(hg)
+
+        with self.assertRaises(IndexError):
+            eg.frequency_based_hypercoreness(hg)
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,40 @@
+import unittest
+
+import easygraph as eg
+import numpy as np
+
+
+class TestHypergraphSCentrality(unittest.TestCase):
+    def setUp(self):
+        # Simple test hypergraph
+        self.hg = eg.Hypergraph(num_v=5, e_list=[(0, 1), (1, 2, 3), (3, 4)])
+        self.empty_hg = eg.Hypergraph(num_v=1, e_list=[])
+        self.singleton_hg = eg.Hypergraph(num_v=3, e_list=[(0,), (1,), (2,)])
+
+    def test_s_betweenness_normal(self):
+        result = eg.s_betweenness(self.hg)
+        self.assertIsInstance(result, (list, dict))
+        self.assertTrue(all(isinstance(x, (int, float)) for x in result))
+
+    def test_s_closeness_normal(self):
+        result = eg.s_closeness(self.hg)
+        self.assertIsInstance(result, (list, dict))
+        self.assertTrue(all(isinstance(x, (int, float)) for x in result))
+
+    def test_s_eccentricity_all(self):
+        result = eg.s_eccentricity(self.hg)
+        self.assertIsInstance(result, dict)
+        for v in result.values():
+            self.assertIsInstance(v, (int, float, np.integer, np.floating))
+
+    def test_s_eccentricity_edges_false(self):
+        result = eg.s_eccentricity(self.hg, edges=False)
+        self.assertIsInstance(result, dict)
+
+    def test_s_eccentricity_invalid_source(self):
+        with self.assertRaises(KeyError):
+            eg.s_eccentricity(self.hg, source=(999, 888))
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,43 @@
+import unittest
+
+import easygraph as eg
+import numpy as np
+
+from easygraph.exception import EasyGraphError
+
+
+class TestVectorCentrality(unittest.TestCase):
+    def test_single_edge(self):
+        hg = eg.Hypergraph(num_v=3, e_list=[(0, 1, 2)])
+        result = eg.vector_centrality(hg)
+        self.assertEqual(set(result.keys()), {0, 1, 2})
+        for val in result.values():
+            self.assertEqual(len(val), 2)  # because D = 3 → k = 2 and 3
+
+    def test_multiple_edges_different_orders(self):
+        hg = eg.Hypergraph(num_v=4, e_list=[(0, 1), (1, 2, 3)])
+        result = eg.vector_centrality(hg)
+        self.assertEqual(set(result.keys()), {0, 1, 2, 3})
+        for val in result.values():
+            self.assertEqual(len(val), 2)
+            self.assertTrue(all(isinstance(x, (float, np.floating)) for x in val))
+
+    def test_disconnected_hypergraph_raises(self):
+        hg = eg.Hypergraph(num_v=6, e_list=[(0, 1), (2, 3)])
+        with self.assertRaises(EasyGraphError):
+            eg.vector_centrality(hg)
+
+    def test_non_consecutive_node_ids(self):
+        hg = eg.Hypergraph(num_v=5, e_list=[(0, 2, 4)])
+        result = eg.vector_centrality(hg)
+        self.assertEqual(len(result), 5)
+        for val in result.values():
+            self.assertEqual(len(val), 2)
+
+    def test_index_error_due_to_wrong_num_v(self):
+        with self.assertRaises(eg.EasyGraphError):
+            eg.Hypergraph(num_v=3, e_list=[(0, 1, 5)])
+
+
+if __name__ == "__main__":
+    unittest.main()