def test_remove_edge_in_directed_graph(self): g = Graph(True) g.add_edge((1, 2, 10)) g.add_edge((2, 3, 11)) g.add_edge((3, 1, 12)) g.remove_edge((2, 3)) self.assertEqual(g.table[1][2], 10, 'should have kept the edge') self.assertEqual(g.table[3][1], 12, 'should have kept the edge') self.assertEqual(g.table[2], {}, 'should have removed the edge')
def test_add_weight_no_edge(self): """ Test addting the weight of an edge that does not exist. """ g = Graph() g.add_node("A") g.add_node("B") with self.assertRaises(ValueError) as context: g.add_weight("A", "B", 1.51) self.assertIn("edge", str(context.exception))
def test_repr(self): """ Test the correctness of the __repr__ function. """ correct = "{'A': {}, 'B': {}, 'C': {}}" g = Graph() g.add_node("A") g.add_node("B") g.add_node("C") self.assertEqual(repr(g), correct)
def test_add_weight_invalid_end(self): """ Test addting the weight of an edge where the end node does not exist. """ g = Graph() g.add_node("A") g.add_node("B") with self.assertRaises(ValueError) as context: g.add_weight("A", "C", 44.43) self.assertIn("end", str(context.exception))
def test_add_edge_default(self): """ Test adding an edge to the graph. """ correct = "{'A': {'B': 0.0}, 'B': {}}" g = Graph() g.add_node("A") g.add_node("B") g.add_edge("A", "B") self.assertEqual(str(g), correct)
def test_get_vertices_for_undirected_graph(self): g = Graph(False) g.add_edge((1, 2)) g.add_edge((2, 3)) g.add_edge((3, 1)) actual = g.get_edges() expected = [(1, 2, True), (1, 3, True), (2, 3, True)] self.assertEqual(actual, expected, 'should return only one way edges')
def test_add_weight_invalid_start(self): """ Test addting the weight of an edge where the start node does not exist. """ g = Graph() g.add_node("A") g.add_node("B") with self.assertRaises(ValueError) as context: g.add_weight("C", "B", 20.00) self.assertIn("start", str(context.exception))
def test_add_node_duplicate(self): """ Test that an exception is thrown when adding two nodes with the same name. """ g = Graph() self.assertEqual(g.size(), 0) g.add_node("A") with self.assertRaises(ValueError): g.add_node("A")
def test_add_weight(self): """ Test updating the weight of an edge between two nodes. """ correct = "{'A': {'B': 3.14}, 'B': {}}" g = Graph() g.add_node("A") g.add_node("B") g.add_edge("A", "B") g.add_weight("A", "B", 3.14) self.assertEqual(str(g), correct)
def test_set_weight(self): """ Test setting the weight of an edge between two nodes. """ g = Graph() g.add_node("A") g.add_node("B") g.add_edge("B", "A") self.assertEqual(g.get_weight("B", "A"), 0.0) g.set_weight("B", "A", 123.45) self.assertEqual(g.get_weight("B", "A"), 123.45)
def test_add_node_size(self): """ Test the success of adding a new node to the graph using the size of the graph. """ g = Graph() self.assertEqual(g.size(), 0) g.add_node("A") self.assertEqual(g.size(), 1) g.add_node("B") self.assertEqual(g.size(), 2)
def test_add_edge_for_directed_graph(self): g = Graph(True) g.add_edge((1, 2, 3)) self.assertIn(1, g.table, 'should have stored a key for tail vertex') self.assertIn(2, g.table[1], 'should have stored the edge') self.assertEqual(g.table[1][2], 3, 'should have stored the edge value') self.assertIn(2, g.table, 'should not have stored the node') self.assertNotIn(1, g.table[2], 'should not have stored the reverse edge')
def test_add_edge_for_undirected_graph(self): g = Graph(False) g.add_edge((1, 2, 3)) self.assertIn(1, g.table, 'should have stored a key for tail vertex') self.assertIn(2, g.table[1], 'should have stored the edge') self.assertEqual(g.table[1][2], 3, 'should have stored the edge value') self.assertIn(2, g.table, 'should have stored a key for head vertex') self.assertIn(1, g.table[2], 'should have stored the reversed edge') self.assertEqual(g.table[2][1], 3, 'should have stored the edge value')
def test_remove_node_with_edges(): graph = Graph() graph.graph[1] = {2, 3} graph.graph[2] = {4} graph.graph[3] = {3} graph.graph[4] = {1, 2} graph.remove_node(3) expected = {1: {2}, 2: {4}, 4: {1, 2}} output = graph.graph assert output == expected
def graph(scope='module'): # TODO: maybe randomness comes from here? d = { 'A': graph._Point2D(0, 0), 'B': graph._Point2D(0, 3), 'C': graph._Point2D(4, 3), 'D': graph._Point2D(4, 0) } g = Graph(d) return g
def test_brute_force(self): graph1 = Graph() graph1.add_edge("A", "B", 1) graph1.add_edge("A", "C", 1) graph1.add_edge("B", "D", 9) graph1.add_edge("C", "D", 1) graph1.end = "D" graph1.start = "A" path = brute_force(graph1) self.assertListEqual(path[0], ["A", "C", "D"]) self.assertEqual(path[1], 2)
def test_add_node_str(self): """ Test the success of adding a new node to the graph using the string representation of the graph. """ correct = "{'A': {}, 'B': {}, 'C': {}}" g = Graph() g.add_node("A") g.add_node("B") g.add_node("C") self.assertEqual(str(g), correct)
def test_get_weights2(self): self.graph = Graph(["text edge graph edge", "text edge graph edge"], 3) df = self.graph.get_weights() assert df.loc["text", "graph"] == 2 assert df.loc["graph", "text"] == 2 assert df.loc["text", "edge"] == 2 assert df.loc["edge", "text"] == 2 assert df.loc["edge", "graph"] == 6 assert df.loc["graph", "edge"] == 6
def test_dijkstra(self): graph = Graph() graph.add_edge("A", "B", 1) graph.add_edge("A", "C", 1) graph.add_edge("B", "D", 9) graph.add_edge("C", "D", 1) path, distance = dijkstra(graph,"A", "D") self.assertListEqual(path, ["A", "C", "D"]) self.assertEqual(distance, 2) self.assertRaises(ValueError, dijkstra, graph, "A", "X") self.assertRaises(TypeError, dijkstra, "A", 7)
def test_get_edge_as_tuple(self): graph = Graph(True) v1 = graph.add_vertex("apple") v2 = graph.add_vertex("banana") v3 = graph.add_vertex("coconut") graph.add_edge("apple", "banana") graph.add_edge("apple", "coconut", 3) self.assertEqual(("apple", "banana"), graph.get_edge_as_tuple(v1, v2)) self.assertEqual(("apple", "coconut", 3), graph.get_edge_as_tuple(v1, v3))
def add_maze(self,row,col,id=0, show = True, debug=False): # return a optimize graph instead of maze instance if id is not 0: self.mazes.append(Maze(row, col, id, show, debug)) else: if len(self.mazes) < 1: self.mazes.append(Maze(row, col, 0, show, debug)) else: self.mazes.append(Maze(row, col, len(self.mazes) + 1, show, debug)) graph = Graph(self.mazes[-1],show,debug) self.graphs.append(graph) return self.graphs[-1]
def main(): t1 = time.time() print('Load train set ID...') train_set = load_train_txt_file() train_set.remove('1a0a') graph_dict = {} train_dict = {} train_ID = 0 for network_name in train_set: train_dict[train_ID] = network_name train_ID += 1 print( str(train_ID) + " Read graph ..." + network_name + "'s edgelist_file!") g = Graph() Path_edgelist_file = windows_dir_pre + '/output/edgelist/edgelist_' + network_name + '.txt' g.read_edgelist_file(path=Path_edgelist_file, weighted=True, directed=False) print( str(train_ID) + ' Read graph ...' + network_name + "'s node_label_file!") Path_node_label_file = windows_dir_pre + '/output/residue_type/residue_type_' + network_name + '.txt' g.read_node_label_file(Path_node_label_file) print( str(train_ID) + ' Read graph ...' + network_name + "'s feature_file!") Path_node_feature_file = windows_dir_pre + '/output/feature/feature_' + network_name + '.txt' g.read_node_features_file(Path_node_feature_file) graph_dict[network_name] = g if train_ID == 200: break Protein_GCN_model = Protein_GCN( graph_dict=graph_dict, train_dict=train_dict, learning_rate=learning_rate, epochs=epochs, hidden1=hidden1, dropout=dropout, weight_decay=weight_decay, early_stopping=early_stopping, #权值衰减 max_degree=max_degree, clf_ratio=clf_ratio, Path_output=Path_output, batch_size=batch_size) # if args.graph_format == 'adjlist': # g.read_adjlist(filename=args.input) # elif args.graph_format == 'edgelist': # g.read_edgelist(filename=args.input, weighted=args.weighted, # directed=args.directed) t2 = time.time()
def test_remove_vertex(self): g = Graph(False) g.add_edge((1, 2)) g.add_edge((2, 3)) g.add_edge((3, 1)) g.remove_vertex(3) self.assertTrue(g.table[1][2], 'should keep edges not involving 3') self.assertTrue(g.table[2][1], 'should keep edges not involving 3') self.assertNotIn(3, g.table, 'vertex 3 disappeared') self.assertNotIn(3, g.table[1], 'edge from 3 to 1 dissappeared')
def test_incident_vertices_are_correctly_maintained_after_remove_vertex( self): g = Graph(directed=True) g.add_edge((1, 2)) g.add_edge((2, 3)) g.add_edge((3, 1)) # table: {1: {2: True}, 2: {3: True}, 3: {1: True}} # incident: {1: set([3]), 2: set([1]), 3: set([2])} g.remove_vertex(1) self.assertEqual(g.table, {2: {3: True}, 3: {}}) self.assertEqual(g.incident_vertices, {2: set(), 3: set([2])}) g = Graph(directed=False) g.add_edge((1, 2)) g.add_edge((2, 3)) g.add_edge((3, 1)) # table: {1: {2: True, 3: True}, 2: {1: True, 3: True}, 3: {1: True, 2: True}} # incident: {1: set([2, 3]), 2: set([1, 3]), 3: set([1, 2])} g.remove_vertex(1) self.assertEqual(g.table, {2: {3: True}, 3: {2: True}}) self.assertEqual(g.incident_vertices, {2: set([3]), 3: set([2])})
def test_remove_one_directed_edge(): graph = Graph() graph.graph[1] = set() graph.graph[2] = set() graph.graph[1].add(2) graph.graph[1].add(3) graph.graph[2].add(3) graph.remove_edge(1, 2) expected = {1: {3}, 2: {3}} output = graph.graph assert output == expected
def test_remove_edge_in_undirected_graph(self): g = Graph(False) g.add_edge((1, 2, 10)) g.add_edge((2, 3, 11)) g.add_edge((3, 1, 12)) g.remove_edge((2, 3)) self.assertEqual(g.table[1][2], 10, 'no removals') self.assertEqual(g.table[1][3], 12, 'no removals') self.assertEqual(g.table[2][1], 10, 'removed the edge from tail') self.assertEqual(g.table[3][1], 12, 'removed the edge from head')
def test_neighbours_in_directed_graph(self): g = Graph(True) g.add_edge((1, 2)) g.add_edge((1, 3)) expected = [2, 3] actual = g.neighbours(1) self.assertEqual(actual, expected, 'should find neighbours of 1') expected = [] actual = g.neighbours(2) self.assertEqual(actual, expected, '2 has no neighbours')
def create_graph(map_array): WEIGHT_SIDE = 1 WEIGHT_DIAG = sqrt(2) G = Graph() # inserindo nos no grafo for i, row in enumerate(map_array): for j, value in enumerate(row): # '-' = nao eh um no # '*' = no normal # '#' = no inicial # '$' = no final name = G.node_name(map_array, (i, j)) if value != '-': G.insert_node(name) if value == '#': if G.start_node == '': G.set_start(name) else: print("ERRO: Mapa contem mais de um ponto inicial.") return None elif value == '$': if G.end_node == '': G.set_end(name) else: print("ERRO: Mapa contem mais de um ponto final.") return None # inserindo arestas no gafo for i, row in enumerate(map_array): for j, value in enumerate(row): if value != '-': for a in side_adjacents(map_array, (i, j)): ai = a[0] aj = a[1] if map_array[ai][aj] != '-': G.insert_arc(G.node_name(map_array, (i, j)), G.node_name(map_array, a), WEIGHT_SIDE) for a in diag_adjacents(map_array, (i, j)): ai = a[0] aj = a[1] if map_array[ai][aj] != '-': G.insert_arc(G.node_name(map_array, (i, j)), G.node_name(map_array, a), WEIGHT_DIAG) return G
def main( arg_one_input="D:\\workspace\\pycharm\\paper_algorithm\\FindSimilarityCommunity\\src\\contrast\\data\\paper\\synthetic\\football_1.net", arg_one_feature_file="D:\\workspace\\pycharm\\paper_algorithm\\FindSimilarityCommunity\\src\\contrast\\data\\paper\\synthetic\\football_info_115_1", arg_two_input="D:\\workspace\\pycharm\\paper_algorithm\\FindSimilarityCommunity\\src\\contrast\\data\\paper\\synthetic\\football_1-0.05.net", arg_two_feature_file="D:\\workspace\\pycharm\\paper_algorithm\\FindSimilarityCommunity\\src\\contrast\\data\\paper\\synthetic\\football_info_115_2" ): warnings.filterwarnings("ignore", category=FutureWarning) t1 = time.time() # init graph arg_one = args.args() arg_one.input = arg_one_input arg_one.feature_file = arg_one_feature_file nx_graph_one = nx.read_edgelist(arg_one.input, nodetype=int, comments="%") adj_matrix_one = nx.adjacency_matrix(nx_graph_one).todense() g_one = Graph(adj_matrix_one) g_one.read_edgelist(filename=arg_one.input, weighted=arg_one.weighted, directed=arg_one.directed) g_one.read_node_features(arg_one.feature_file) arg_two = args.args() arg_two.input = arg_two_input arg_two.feature_file = arg_two_feature_file nx_graph_two = nx.read_edgelist(arg_two.input, nodetype=int, comments="%") adj_matrix_two = nx.adjacency_matrix(nx_graph_two).todense() g_two = Graph(adj_matrix_two) g_two.read_edgelist(filename=arg_two.input, weighted=arg_two.weighted, directed=arg_two.directed) g_two.read_node_features(arg_two.feature_file) # community detection # igraph.Graph.community_infomap() # SCAN algorithm_one = SCAN(g_one.G, 0.5, 3) communities_one = algorithm_one.execute() algorithm_two = SCAN(g_two.G, 0.5, 3) communities_two = algorithm_two.execute() return communities_one, communities_two, g_one, g_two
def test_add_edge_node_to_multiple_nodes(): graph = Graph() graph.graph[1] = set() graph.graph[2] = set() graph.graph[3] = set() graph.add_edge(1, 2) graph.add_edge(2, 2) graph.add_edge(3, 2) graph.add_edge(1, 3) expected = {1: {2, 3}, 2: {1, 2, 3}, 3: {2, 1}} output = graph.graph assert output == expected