def test_multigraph(self): assert nx.bellman_ford_path(self.MXG, "s", "v") == ["s", "x", "u", "v"] assert nx.bellman_ford_path_length(self.MXG, "s", "v") == 9 assert nx.single_source_bellman_ford_path(self.MXG, "s")["v"] == [ "s", "x", "u", "v", ] assert nx.single_source_bellman_ford_path_length(self.MXG, "s")["v"] == 9 D, P = nx.single_source_bellman_ford(self.MXG, "s", target="v") assert D == 9 assert P == ["s", "x", "u", "v"] P, D = nx.bellman_ford_predecessor_and_distance(self.MXG, "s") assert P["v"] == ["u"] assert D["v"] == 9 P, D = nx.goldberg_radzik(self.MXG, "s") assert P["v"] == "u" assert D["v"] == 9 assert nx.bellman_ford_path(self.MXG4, 0, 2) == [0, 1, 2] assert nx.bellman_ford_path_length(self.MXG4, 0, 2) == 4 assert nx.single_source_bellman_ford_path(self.MXG4, 0)[2] == [0, 1, 2] assert nx.single_source_bellman_ford_path_length(self.MXG4, 0)[2] == 4 D, P = nx.single_source_bellman_ford(self.MXG4, 0, target=2) assert D == 4 assert P == [0, 1, 2] P, D = nx.bellman_ford_predecessor_and_distance(self.MXG4, 0) assert P[2] == [1] assert D[2] == 4 P, D = nx.goldberg_radzik(self.MXG4, 0) assert P[2] == 1 assert D[2] == 4
def delete_high_betweenness_centrality(self, infectG): subinfectG = commons.get_subGraph_true(infectG) sort_list = Partion_common.get_layer_node_between(subinfectG) #根据中介性分层然后删除。 print('sort_list', sort_list) #先验证高中介性节点是否在中间。 # for every_node in sort_list: first_layer_between = [x[0] for x in sort_list[0]] #取第一层节点 two_source = random.sample(first_layer_between, 2) # 从list中随机获取2个元素,作为一个片断返回 lengthA_B = 100000 good_two_result = [] best_node_two_result = None for iter in range(0, 100): # 对这两个点进行Djstra,计算所有点到他们的距离。 print('two_source', two_source) lengthA_dict = nx.single_source_bellman_ford_path_length( subinfectG, two_source[0], weight='weight') lengthB_dict = nx.single_source_bellman_ford_path_length( subinfectG, two_source[1], weight='weight') # 初始化两个集合,用来保存两个类别节点集合。 node_twolist = [[], []] # 保存两个类别节点集合 node_diff_twolist = [[], []] # 保存不同点 for node in list(subinfectG.nodes): if lengthA_dict[node] > lengthB_dict[node]: # 这个点离b近一些。 node_twolist[1].append(node) node_diff_twolist[1].append(node) elif lengthA_dict[node] < lengthB_dict[node]: node_twolist[0].append(node) node_diff_twolist[0].append(node) else: node_twolist[0].append(node) node_twolist[1].append(node) print('node_twolist', len(node_twolist[1])) # 在两个list中找到中心位置,有几种中心性可以度量的。或者进行快速算法。 # 判断这次找的两个中心好不好。 lengthA_sum = 0 # a这个不同点, lengthB_sum = 0 for i in node_diff_twolist[0]: # 距离a近,第一个源点近的点。统计它跟自己区域点的距离之和 lengthA_sum += lengthA_dict[i] for j in node_diff_twolist[1]: # 距离b近,第二个源点近的点。统计它跟自己区域点的距离之和 lengthB_sum += lengthB_dict[j] sums = lengthA_sum + lengthB_sum if sums < lengthA_B: print('sums', sums) # 是比原来好的的两个源。 lengthA_B = sums good_two_result = two_source best_node_two_result = node_twolist else: # 重新长生两个源吧。这里还是可以做优化的,选择的方向问题。 two_source = random.sample(first_layer_between, 2) print('good_two_result', good_two_result) print('good_node_two_result', best_node_two_result) return [[good_two_result[0], best_node_two_result[0]], [good_two_result[1], best_node_two_result[1]]]
def test_multigraph(self): assert nx.bellman_ford_path(self.MXG, 's', 'v') == ['s', 'x', 'u', 'v'] assert nx.bellman_ford_path_length(self.MXG, 's', 'v') == 9 assert nx.single_source_bellman_ford_path( self.MXG, 's')['v'] == ['s', 'x', 'u', 'v'] assert nx.single_source_bellman_ford_path_length(self.MXG, 's')['v'] == 9 D, P = nx.single_source_bellman_ford(self.MXG, 's', target='v') assert D == 9 assert P == ['s', 'x', 'u', 'v'] P, D = nx.bellman_ford_predecessor_and_distance(self.MXG, 's') assert P['v'] == ['u'] assert D['v'] == 9 P, D = nx.goldberg_radzik(self.MXG, 's') assert P['v'] == 'u' assert D['v'] == 9 assert nx.bellman_ford_path(self.MXG4, 0, 2) == [0, 1, 2] assert nx.bellman_ford_path_length(self.MXG4, 0, 2) == 4 assert nx.single_source_bellman_ford_path(self.MXG4, 0)[2] == [0, 1, 2] assert nx.single_source_bellman_ford_path_length(self.MXG4, 0)[2] == 4 D, P = nx.single_source_bellman_ford(self.MXG4, 0, target=2) assert D == 4 assert P == [0, 1, 2] P, D = nx.bellman_ford_predecessor_and_distance(self.MXG4, 0) assert P[2] == [1] assert D[2] == 4 P, D = nx.goldberg_radzik(self.MXG4, 0) assert P[2] == 1 assert D[2] == 4
def test_multigraph(self): assert_equal(nx.bellman_ford_path(self.MXG, 's', 'v'), ['s', 'x', 'u', 'v']) assert_equal(nx.bellman_ford_path_length(self.MXG, 's', 'v'), 9) assert_equal(nx.single_source_bellman_ford_path(self.MXG, 's')['v'], ['s', 'x', 'u', 'v']) assert_equal(nx.single_source_bellman_ford_path_length(self.MXG, 's')['v'], 9) D, P = nx.single_source_bellman_ford(self.MXG, 's', target='v') assert_equal(D, 9) assert_equal(P, ['s', 'x', 'u', 'v']) P, D = nx.bellman_ford_predecessor_and_distance(self.MXG, 's') assert_equal(P['v'], ['u']) assert_equal(D['v'], 9) P, D = nx.goldberg_radzik(self.MXG, 's') assert_equal(P['v'], 'u') assert_equal(D['v'], 9) assert_equal(nx.bellman_ford_path(self.MXG4, 0, 2), [0, 1, 2]) assert_equal(nx.bellman_ford_path_length(self.MXG4, 0, 2), 4) assert_equal(nx.single_source_bellman_ford_path(self.MXG4, 0)[2], [0, 1, 2]) assert_equal(nx.single_source_bellman_ford_path_length(self.MXG4, 0)[2], 4) D, P = nx.single_source_bellman_ford(self.MXG4, 0, target=2) assert_equal(D, 4) assert_equal(P, [0, 1, 2]) P, D = nx.bellman_ford_predecessor_and_distance(self.MXG4, 0) assert_equal(P[2], [1]) assert_equal(D[2], 4) P, D = nx.goldberg_radzik(self.MXG4, 0) assert_equal(P[2], 1) assert_equal(D[2], 4)
def test_multigraph(self): assert_equal(nx.bellman_ford_path(self.MXG, 's', 'v'), ['s', 'x', 'u', 'v']) assert_equal(nx.bellman_ford_path_length(self.MXG, 's', 'v'), 9) assert_equal( nx.single_source_bellman_ford_path(self.MXG, 's')['v'], ['s', 'x', 'u', 'v']) assert_equal( dict(nx.single_source_bellman_ford_path_length(self.MXG, 's'))['v'], 9) D, P = nx.single_source_bellman_ford(self.MXG, 's', target='v') assert_equal(D['v'], 9) assert_equal(P['v'], ['s', 'x', 'u', 'v']) P, D = nx.bellman_ford_predecessor_and_distance(self.MXG, 's') assert_equal(P['v'], ['u']) assert_equal(D['v'], 9) P, D = nx.goldberg_radzik(self.MXG, 's') assert_equal(P['v'], 'u') assert_equal(D['v'], 9) assert_equal(nx.bellman_ford_path(self.MXG4, 0, 2), [0, 1, 2]) assert_equal(nx.bellman_ford_path_length(self.MXG4, 0, 2), 4) assert_equal( nx.single_source_bellman_ford_path(self.MXG4, 0)[2], [0, 1, 2]) assert_equal( dict(nx.single_source_bellman_ford_path_length(self.MXG4, 0))[2], 4) D, P = nx.single_source_bellman_ford(self.MXG4, 0, target=2) assert_equal(D[2], 4) assert_equal(P[2], [0, 1, 2]) P, D = nx.bellman_ford_predecessor_and_distance(self.MXG4, 0) assert_equal(P[2], [1]) assert_equal(D[2], 4) P, D = nx.goldberg_radzik(self.MXG4, 0) assert_equal(P[2], 1) assert_equal(D[2], 4)
def get_partion_bound(self,infectG, subinfecG, two_center_list, source_number=2): #边界点。 bound_list = [] for node_temp in list(infectG.nodes()): print(node_temp) if infectG.node[node_temp]['SI']==2: neighbors_list = list(nx.neighbors(infectG, node_temp)) neighbors_infect_list = [ x for x in neighbors_list if infectG.node[x]['SI']==2 ] if len(neighbors_list)!= 1 and len(neighbors_infect_list) ==1: # if len(neighbors_infect_list) == 1: bound_list.append(node_temp) print('boundelist',len(bound_list)) #求得所有点到他们的距离,把和加起来求得最小值。 #看下是否是边界点。 plot_main.plot_G_node_color(infectG,subinfecG,bound_list,two_center_list) #能否找到大小为k的点,以最小的h覆盖这些边界点。 #先检测源点距离他们的距离 lengthA_dict = nx.single_source_bellman_ford_path_length(subinfecG, two_center_list[0], weight='weight') lengthB_dict = nx.single_source_bellman_ford_path_length(subinfecG, two_center_list[1], weight='weight') distance_list =[ [], []] for bound in bound_list: distance_list[0].append(lengthA_dict[bound]) distance_list[1].append(lengthB_dict[bound]) print('distance_list',distance_list[0]) print('distance_list',distance_list[1])
def findmultiplesource(self, infectionG, subinfectG, sourceNumber=2): # 首先需要判断是否多源。不断找源点去对这个区域。 tempGraph = nx.Graph() tempGraph = subinfectG tempGraphNodelist = [] for node in list(tempGraph.nodes): tempGraphNodelist.append(node) print('这个传播子图的节点个数,也是我们用来做u的备选集合的' + str(len(set(tempGraphNodelist)))) print('这个感染区域的传播图节点个数') print(tempGraph.number_of_nodes()) Alternativenodeset = list(tempGraph.nodes()) # 备选集合。 print('tempgraph的所有点数' + str(len(Alternativenodeset))) minCoverlist = [] print('在源点在' + str(sourceNumber) + '个数的情况下') # print('在h为' + str(h) + '的情况下') # 计算图的拉普拉斯 k = 1 sourceNum = 2 # while 1: minCoverlist = [] print('在源点在' + str(sourceNum) + '个数的情况下') # print('在h为' + str(h) + '的情况下') #基于k-means的方法。 if sourceNum == 2: partion_region = [] #选择距离最远的点。 distance_iter = nx.shortest_path_length(subinfectG) everynode_distance = [] for node, node_distance in distance_iter: # print(node_distance) sort_list = sorted(node_distance.items(), key=lambda x: x[1], reverse=True) # print('sort_list',sort_list) everynode_distance.append( [node, sort_list[0][0], sort_list[0][1]]) # print('everynode_idstance',everynode_distance) sort_every_distance = sorted(everynode_distance, key=lambda x: x[2], reverse=True) # print(sort_every_distance) node_twolist = [[], []] lengthA_dict = nx.single_source_bellman_ford_path_length( subinfectG, sort_every_distance[0][0], weight='weight') lengthB_dict = nx.single_source_bellman_ford_path_length( subinfectG, sort_every_distance[0][1], weight='weight') for node in list(subinfectG.nodes): if lengthA_dict[node] > lengthB_dict[node]: # 这个点离b近一些。 node_twolist[1].append(node) elif lengthA_dict[node] < lengthB_dict[node]: node_twolist[0].append(node) else: node_twolist[0].append(node) node_twolist[1].append(node) print('len(node_twolist[0]', len(node_twolist[0])) print('len(node_twolist[1]', len(node_twolist[1])) return node_twolist
def test_others(self): assert_equal(nx.bellman_ford_path(self.XG, 's', 'v'), ['s', 'x', 'u', 'v']) assert_equal(nx.bellman_ford_path_length(self.XG, 's', 'v'), 9) assert_equal(nx.single_source_bellman_ford_path(self.XG, 's')['v'], ['s', 'x', 'u', 'v']) assert_equal(dict(nx.single_source_bellman_ford_path_length(self.XG, 's'))['v'], 9) D, P = nx.single_source_bellman_ford(self.XG, 's', target='v') assert_equal(D['v'], 9) assert_equal(P['v'], ['s', 'x', 'u', 'v']) (P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, 's') assert_equal(P['v'], ['u']) assert_equal(D['v'], 9) (P, D) = nx.goldberg_radzik(self.XG, 's') assert_equal(P['v'], 'u') assert_equal(D['v'], 9) G = nx.path_graph(4) assert_equal(nx.single_source_bellman_ford_path(G, 0), {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]}) assert_equal(dict(nx.single_source_bellman_ford_path_length(G, 0)), {0: 0, 1: 1, 2: 2, 3: 3}) assert_equal(nx.single_source_bellman_ford(G, 0), ({0: 0, 1: 1, 2: 2, 3: 3}, {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({0: [None], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3})) assert_equal(nx.goldberg_radzik(G, 0), ({0: None, 1: 0, 2: 1, 3: 2}, {0: 0, 1: 1, 2: 2, 3: 3})) assert_equal(nx.single_source_bellman_ford_path(G, 3), {0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]}) assert_equal(dict(nx.single_source_bellman_ford_path_length(G, 3)), {0: 3, 1: 2, 2: 1, 3: 0}) assert_equal(nx.single_source_bellman_ford(G, 3), ({0: 3, 1: 2, 2: 1, 3: 0}, {0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 3), ({0: [1], 1: [2], 2: [3], 3: [None]}, {0: 3, 1: 2, 2: 1, 3: 0})) assert_equal(nx.goldberg_radzik(G, 3), ({0: 1, 1: 2, 2: 3, 3: None}, {0: 3, 1: 2, 2: 1, 3: 0})) G = nx.grid_2d_graph(2, 2) dist, path = nx.single_source_bellman_ford(G, (0, 0)) assert_equal(sorted(dist.items()), [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 2)]) assert_equal(sorted(path.items()), [((0, 0), [(0, 0)]), ((0, 1), [(0, 0), (0, 1)]), ((1, 0), [(0, 0), (1, 0)]), ((1, 1), [(0, 0), (0, 1), (1, 1)])]) pred, dist = nx.bellman_ford_predecessor_and_distance(G, (0, 0)) assert_equal(sorted(pred.items()), [((0, 0), [None]), ((0, 1), [(0, 0)]), ((1, 0), [(0, 0)]), ((1, 1), [(0, 1), (1, 0)])]) assert_equal(sorted(dist.items()), [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 2)]) pred, dist = nx.goldberg_radzik(G, (0, 0)) assert_equal(sorted(pred.items()), [((0, 0), None), ((0, 1), (0, 0)), ((1, 0), (0, 0)), ((1, 1), (0, 1))]) assert_equal(sorted(dist.items()), [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 2)])
def test_path_graph(self): G = nx.path_graph(4) assert nx.single_source_bellman_ford_path(G, 0) == { 0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3], } assert nx.single_source_bellman_ford_path_length(G, 0) == { 0: 0, 1: 1, 2: 2, 3: 3, } assert nx.single_source_bellman_ford(G, 0) == ( {0: 0, 1: 1, 2: 2, 3: 3}, {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]}, ) assert nx.bellman_ford_predecessor_and_distance(G, 0) == ( {0: [], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3}, ) assert nx.goldberg_radzik(G, 0) == ( {0: None, 1: 0, 2: 1, 3: 2}, {0: 0, 1: 1, 2: 2, 3: 3}, ) assert nx.single_source_bellman_ford_path(G, 3) == { 0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3], } assert nx.single_source_bellman_ford_path_length(G, 3) == { 0: 3, 1: 2, 2: 1, 3: 0, } assert nx.single_source_bellman_ford(G, 3) == ( {0: 3, 1: 2, 2: 1, 3: 0}, {0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]}, ) assert nx.bellman_ford_predecessor_and_distance(G, 3) == ( {0: [1], 1: [2], 2: [3], 3: []}, {0: 3, 1: 2, 2: 1, 3: 0}, ) assert nx.goldberg_radzik(G, 3) == ( {0: 1, 1: 2, 2: 3, 3: None}, {0: 3, 1: 2, 2: 1, 3: 0}, )
def single_source_bydistance_coverage(self, infectG, subinfectG, true_source): # for node in list(infectG.nodes()): # print(len(list(nx.neighbors(infectG,node)))) # # print(nx.find_cycle(infectG)) sort_dict = commons.partion_layer_dict(infectG, 10) # 分层 print('sort_list', sort_dict) node_cal = [] for node in subinfectG: node_import = 0 length_dict = nx.single_source_bellman_ford_path_length( subinfectG, node, weight='weight') for othernode, ditance in length_dict.items(): lens_degree = len(list(nx.neighbors(infectG, othernode))) node_import += sort_dict[othernode] * lens_degree / (ditance + 1) node_cal.append([node, node_import]) sort_list = sorted(node_cal, key=lambda x: x[1], reverse=True) print(sort_list) # print('在的', [x[0] for x in sort_list[:100] if x[0] == true_source]) # 只需要返回在你排序的集合中,源点在第几位就可以了。 index_list = [] print('sort_list', sort_list) print('true_list', true_source) for index in range(0, len(sort_list)): if true_source[0] == sort_list[index][0] or ( true_source[1] == sort_list[index][0]): index_list.append(index) return index_list
def test_single_source_shortest_path_length(self): ans = dict(nx.shortest_path_length(self.cycle, 0)) assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict(nx.single_source_shortest_path_length( self.cycle, 0)) ans = dict(nx.shortest_path_length(self.grid, 1)) assert ans[16] == 6 # now with weights ans = dict(nx.shortest_path_length(self.cycle, 0, weight="weight")) assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict(nx.single_source_dijkstra_path_length( self.cycle, 0)) ans = dict(nx.shortest_path_length(self.grid, 1, weight="weight")) assert ans[16] == 6 # weights and method specified ans = dict( nx.shortest_path_length(self.cycle, 0, weight="weight", method="dijkstra")) assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict(nx.single_source_dijkstra_path_length( self.cycle, 0)) ans = dict( nx.shortest_path_length(self.cycle, 0, weight="weight", method="bellman-ford")) assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict( nx.single_source_bellman_ford_path_length(self.cycle, 0))
def path_length(v): if method == "unweighted": return nx.single_source_shortest_path_length(G, v) elif method == "dijkstra": return nx.single_source_dijkstra_path_length(G, v, weight=weight) elif method == "bellman-ford": return nx.single_source_bellman_ford_path_length(G, v, weight=weight)
def test_single_source_shortest_path_length(self): ans = dict(nx.shortest_path_length(self.cycle, 0)) assert_equal(ans, {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}) assert_equal(ans, dict(nx.single_source_shortest_path_length(self.cycle, 0))) ans = dict(nx.shortest_path_length(self.grid, 1)) assert_equal(ans[16], 6) # now with weights ans = dict(nx.shortest_path_length(self.cycle, 0, weight='weight')) assert_equal(ans, {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}) assert_equal(ans, dict(nx.single_source_dijkstra_path_length( self.cycle, 0))) ans = dict(nx.shortest_path_length(self.grid, 1, weight='weight')) assert_equal(ans[16], 6) # weights and method specified ans = dict(nx.shortest_path_length(self.cycle, 0, weight='weight', method='dijkstra')) assert_equal(ans, {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}) assert_equal(ans, dict(nx.single_source_dijkstra_path_length( self.cycle, 0))) ans = dict(nx.shortest_path_length(self.cycle, 0, weight='weight', method='bellman-ford')) assert_equal(ans, {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}) assert_equal(ans, dict(nx.single_source_bellman_ford_path_length( self.cycle, 0)))
def single_source_bydistance_coverage(self, infectG, subinfectG, true_source): sort_dict = commons.partion_layer_dict(infectG, 10) # 分层 print('sort_list', sort_dict) node_cal = [] for node in subinfectG: node_import = 0 length_dict = nx.single_source_bellman_ford_path_length( infectG, source=node, weight='weight') #获取附近3层节点得覆盖率来计算某个点的重要性,越靠近中心,覆盖率越高。 root = node edges = nx.bfs_edges(infectG, root, depth_limit=3) nodes = [root] + [v for u, v in edges] neihbor_h_len = len(nodes) count1 = 0 for neihbor_h_node in nodes: if infectG.node[neihbor_h_node]['SI'] == 2: count1 += 1 node_import = count1 / neihbor_h_len # for neihbor_h in nodes: # lens_degree = len(list(nx.neighbors(infectG, neihbor_h))) # node_import += sort_dict[neihbor_h] * lens_degree/neihbor_h_len node_cal.append([node, node_import]) sort_list = sorted(node_cal, key=lambda x: x[1], reverse=True) print(sort_list) # print('在的', [x[0] for x in sort_list[:100] if x[0] == true_source]) #只需要返回在你排序的集合中,源点在第几位就可以了。 for index in range(0, len(sort_list)): if true_source == sort_list[index][0]: return index
def correctness(self): #initialize the boolean value for testing Dijkstra's correctness boolean = True print("testing for correctness of Dijkstra...") #looping through graphs from my graphs and graphs by networkx for answer, my_graph in zip(self.test_list, self.compare_list): # if the graph has no nodes, break, automatically true if len(answer.nodes) > 0: #pick the smallest id to be source source = min(answer.nodes()) #run networkx's dijkstra length, path = nx.single_source_dijkstra(answer, source, weight='weight') #run my dijkstra my_solution = Dijkstra(my_graph) dist, path = my_solution.solver(source) #getting rid of all the node that cannot be reached by the source for k, v in dist.items(): if v == float("inf"): del dist[k] #testing for correctness boolean = boolean and dist == length if boolean: print("Dijkstra test passed") else: print("No") #initialize the boolean value for testing BF's correctness boolean = True print("testing for correctness of BF algorithm ...") #looping through graphs from my graphs and graphs by networkx for answer, my_graph in zip(self.test_list, self.compare_list): # if the graph has no nodes, break, automatically true if len(answer.nodes) > 0: #pick the smallest id to be source source = min(answer.nodes()) #run networkx's Bellman_ford length = nx.single_source_bellman_ford_path_length( answer, source, weight='weight') #run my Bellman_ford my_solution = Bellman_Ford(my_graph) dist, path = my_solution.solver(source) #getting rid of all the node that cannot be reached by the source for k, v in dist.items(): if v == float("inf"): del dist[k] #correctness boolean = boolean and dist == length if boolean: print("Bellman_Ford test passed") else: print("No")
def test_single_node_graph(self): G = nx.DiGraph() G.add_node(0) assert nx.single_source_bellman_ford_path(G, 0) == {0: [0]} assert nx.single_source_bellman_ford_path_length(G, 0) == {0: 0} assert nx.single_source_bellman_ford(G, 0) == ({0: 0}, {0: [0]}) assert nx.bellman_ford_predecessor_and_distance(G, 0) == ({0: []}, {0: 0}) assert nx.goldberg_radzik(G, 0) == ({0: None}, {0: 0})
def test_single_node_graph(self): G = nx.DiGraph() G.add_node(0) assert_equal(nx.single_source_bellman_ford_path(G, 0), {0: [0]}) assert_equal(nx.single_source_bellman_ford_path_length(G, 0), {0: 0}) assert_equal(nx.single_source_bellman_ford(G, 0), ({0: 0}, {0: [0]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({0: []}, {0: 0})) assert_equal(nx.goldberg_radzik(G, 0), ({0: None}, {0: 0}))
def get_partion(self, subinfecG, two_center_list): node_twolist = [[], []] lengthA_dict = nx.single_source_bellman_ford_path_length( subinfecG, two_center_list[0], weight='weight') lengthB_dict = nx.single_source_bellman_ford_path_length( subinfecG, two_center_list[1], weight='weight') for node in list(subinfecG.nodes): if lengthA_dict[node] > lengthB_dict[node]: # 这个点离b近一些。 node_twolist[1].append(node) elif lengthA_dict[node] < lengthB_dict[node]: node_twolist[0].append(node) else: node_twolist[0].append(node) node_twolist[1].append(node) print('len(node_twolist[0]', len(node_twolist[0])) print('len(node_twolist[1]', len(node_twolist[1])) return node_twolist
def test_single_node_graph(self): G = nx.DiGraph() G.add_node(0) assert_equal(nx.single_source_bellman_ford_path(G, 0), {0: [0]}) assert_equal(nx.single_source_bellman_ford_path_length(G, 0), {0: 0}) assert_equal(nx.single_source_bellman_ford(G, 0), ({0: 0}, {0: [0]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({0: [None]}, {0: 0})) assert_equal(nx.goldberg_radzik(G, 0), ({0: None}, {0: 0})) assert_raises(nx.NodeNotFound, nx.bellman_ford_predecessor_and_distance, G, 1) assert_raises(nx.NodeNotFound, nx.goldberg_radzik, G, 1)
def path_length(v): if method == 'unweighted': return nx.single_source_shortest_path_length(G, v) elif method == 'dijkstra': return nx.single_source_dijkstra_path_length(G, v, weight=weight) elif method == 'bellman-ford': return nx.single_source_bellman_ford_path_length(G, v, weight=weight) else: raise ValueError('method not supported: {}'.format(method))
def single_source_bydistance(self, subinfectG): node_cal = [] for node in subinfectG: node_import = 0 length_dict = nx.single_source_bellman_ford_path_length( subinfectG, node, weight='weight') for othernode, ditance in length_dict.items(): node_import += ditance node_cal.append([node, node_import]) sort_list = sorted(node_cal, key=lambda x: x[1]) print(sort_list) return sort_list[0]
def test_path_graph(self): G = nx.path_graph(4) assert_equal(nx.single_source_bellman_ford_path(G, 0), {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]}) assert_equal(nx.single_source_bellman_ford_path_length(G, 0), {0: 0, 1: 1, 2: 2, 3: 3}) assert_equal(nx.single_source_bellman_ford(G, 0), ({0: 0, 1: 1, 2: 2, 3: 3}, {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({0: [], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3})) assert_equal(nx.goldberg_radzik(G, 0), ({0: None, 1: 0, 2: 1, 3: 2}, {0: 0, 1: 1, 2: 2, 3: 3})) assert_equal(nx.single_source_bellman_ford_path(G, 3), {0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]}) assert_equal(nx.single_source_bellman_ford_path_length(G, 3), {0: 3, 1: 2, 2: 1, 3: 0}) assert_equal(nx.single_source_bellman_ford(G, 3), ({0: 3, 1: 2, 2: 1, 3: 0}, {0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 3), ({0: [1], 1: [2], 2: [3], 3: []}, {0: 3, 1: 2, 2: 1, 3: 0})) assert_equal(nx.goldberg_radzik(G, 3), ({0: 1, 1: 2, 2: 3, 3: None}, {0: 3, 1: 2, 2: 1, 3: 0}))
def findPath_SingleTarget(self, startPoints, endPoint): dist = euclidean_distances([endPoint], self.gridPoints) self.targetConfigIdx = np.argmin(dist) dist = euclidean_distances(startPoints, self.gridPoints) self.startConfigIdx = np.argmin(dist, axis=1) allLength = dict( nx.single_source_bellman_ford_path_length(self.NX_G, self.targetConfigIdx)) queryLength = [allLength[i] for i in self.startConfigIdx] return queryLength
def std_bellman_ford(graph, src_vertex): """ From a given start vertex, finds the shortest paths to every other (reachable) vertex in the graph. graph: weighted graph src_vertex: source vertex return: Vector of computed distances """ res = nx.single_source_bellman_ford_path_length(graph, src_vertex) return [dist for _, dist in sorted(res.items())]
def check_th7(g, c): # O(V^3) bfg = nx.MultiDiGraph() bfg.add_weighted_edges_from([(e[1], e[0], w(g, e)) for e in g.edges]) bfg.add_weighted_edges_from([ (v, u, W[u, v] - 1) for u in g.nodes for v in g.nodes if (u, v) in W and (u, v) in D and D[u, v] > c and not (D[u, v] - d(g, v) > c or D[u, v] - d(g, u) > c) ]) root = 'root' bfg.add_weighted_edges_from([(root, n, 0) for n in bfg.nodes]) try: return nx.single_source_bellman_ford_path_length(bfg, root) except nx.exception.NetworkXUnbounded: return None
def test_others(self): assert_equal(nx.bellman_ford_path(self.XG, 's', 'v'), ['s', 'x', 'u', 'v']) assert_equal(nx.bellman_ford_path_length(self.XG, 's', 'v'), 9) assert_equal(nx.single_source_bellman_ford_path(self.XG, 's')['v'], ['s', 'x', 'u', 'v']) assert_equal(nx.single_source_bellman_ford_path_length(self.XG, 's')['v'], 9) D, P = nx.single_source_bellman_ford(self.XG, 's', target='v') assert_equal(D, 9) assert_equal(P, ['s', 'x', 'u', 'v']) (P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, 's') assert_equal(P['v'], ['u']) assert_equal(D['v'], 9) (P, D) = nx.goldberg_radzik(self.XG, 's') assert_equal(P['v'], 'u') assert_equal(D['v'], 9)
def test_others(self): assert nx.bellman_ford_path(self.XG, 's', 'v') == ['s', 'x', 'u', 'v'] assert nx.bellman_ford_path_length(self.XG, 's', 'v') == 9 assert nx.single_source_bellman_ford_path(self.XG, 's')['v'] == ['s', 'x', 'u', 'v'] assert nx.single_source_bellman_ford_path_length(self.XG, 's')['v'] == 9 D, P = nx.single_source_bellman_ford(self.XG, 's', target='v') assert D == 9 assert P == ['s', 'x', 'u', 'v'] (P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, 's') assert P['v'] == ['u'] assert D['v'] == 9 (P, D) = nx.goldberg_radzik(self.XG, 's') assert P['v'] == 'u' assert D['v'] == 9
def test_not_connected(self): G = nx.complete_graph(6) G.add_edge(10, 11) G.add_edge(10, 12) assert_equal(nx.single_source_bellman_ford_path(G, 0), {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]}) assert_equal(nx.single_source_bellman_ford_path_length(G, 0), {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}) assert_equal(nx.single_source_bellman_ford(G, 0), ({0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}, {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({0: [], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})) assert_equal(nx.goldberg_radzik(G, 0), ({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})) # not connected, with a component not containing the source that # contains a negative cost cycle. G = nx.complete_graph(6) G.add_edges_from([('A', 'B', {'load': 3}), ('B', 'C', {'load': -10}), ('C', 'A', {'load': 2})]) assert_equal(nx.single_source_bellman_ford_path(G, 0, weight='load'), {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]}) assert_equal(nx.single_source_bellman_ford_path_length(G, 0, weight='load'), {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}) assert_equal(nx.single_source_bellman_ford(G, 0, weight='load'), ({0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}, {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0, weight='load'), ({0: [], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})) assert_equal(nx.goldberg_radzik(G, 0, weight='load'), ({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
def test_not_connected(self): G = nx.complete_graph(6) G.add_edge(10, 11) G.add_edge(10, 12) assert_equal(nx.single_source_bellman_ford_path(G, 0), {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]}) assert_equal(nx.single_source_bellman_ford_path_length(G, 0), {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}) assert_equal(nx.single_source_bellman_ford(G, 0), ({0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}, {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({0: [None], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})) assert_equal(nx.goldberg_radzik(G, 0), ({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})) # not connected, with a component not containing the source that # contains a negative cost cycle. G = nx.complete_graph(6) G.add_edges_from([('A', 'B', {'load': 3}), ('B', 'C', {'load': -10}), ('C', 'A', {'load': 2})]) assert_equal(nx.single_source_bellman_ford_path(G, 0, weight='load'), {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]}) assert_equal(nx.single_source_bellman_ford_path_length(G, 0, weight='load'), {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}) assert_equal(nx.single_source_bellman_ford(G, 0, weight='load'), ({0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}, {0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0, weight='load'), ({0: [None], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})) assert_equal(nx.goldberg_radzik(G, 0, weight='load'), ({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
def produce_source(self, initG, source_number): #从某个树图中产生某个离边界点近的节点。 #从0出发,找出最长的路径,然后取一半路径长度的为源点。 length_dict = nx.single_source_bellman_ford_path_length( initG, 0, weight='weight') sort_list = sorted(length_dict.items(), key=lambda x: x[1], reverse=True) print('最长的为', sort_list[0][1]) true_source = None for node, distance in sort_list: if distance == sort_list[0][1] // 2: true_source = node print('实验结果', length_dict[true_source]) return [true_source]
def _bellman_ford_checker(self, clock: int): """ Check if a legal retiming exists given a clock duration using Bellman Ford algorithm :param clock: :return: If the retiming is legal and the retiming to apply """ feasibility_graph = nx.DiGraph() feasibility_graph.add_nodes_from(self.graph.nodes) # add first type of constraint from the original graph -> r(u) - r(v) <= w(e), so create arc v -> u feasibility_graph.add_weighted_edges_from([ (target, source, weight[self._wire_delay]) for (source, target, weight) in self.graph.edges.data() ]) # add second type of constraint from the original graph: r(u) - r(v) <= W(u,v) - 1 if D(u,v) > c feasibility_graph.add_weighted_edges_from([ (target, source, self.w[int(source)][int(target)] - 1) for (source, target) in #Do the nodes cartesian product list( itertools.product(feasibility_graph.nodes, feasibility_graph.nodes)) if self.d[int(source)][int(target)] > clock ]) # add extra node for Bellman Ford extra_node = 'extra_node' feasibility_graph.add_node(extra_node) # add extra edges from the extra node to all the other ones feasibility_graph.add_weighted_edges_from([ (extra_node, node, 0) for node in self.graph.nodes ]) try: retimings = nx.single_source_bellman_ford_path_length( G=feasibility_graph, source=extra_node) retimings.pop(extra_node) return True, np.array([ x[1] for x in sorted(retimings.items(), key=lambda x: int(x[0])) ], dtype=int) except nx.exception.NetworkXUnbounded: print("Negative cost cycle detected for clock {}...".format(clock)) return False, None
def single_source_bydistance_coverage_SECOND(self, infectG, subinfectG, true_source): sort_dict = commons.partion_layer_dict(infectG, 10) # 分层 print('sort_list', sort_dict) node_cal = [] for node in subinfectG: node_import = 0 length_dict = nx.single_source_bellman_ford_path_length( subinfectG, node, weight='weight') for othernode, ditance in length_dict.items(): lens_degree = len(list(nx.neighbors(infectG, othernode))) node_import += sort_dict[othernode] * lens_degree / (ditance + 1) node_cal.append([node, node_import]) sort_list = sorted(node_cal, key=lambda x: x[1], reverse=True) print(sort_list) print('在的', [x[0] for x in sort_list[:200] if x[0] == true_source]) return sort_list[0]
def test_others(self): assert nx.bellman_ford_path(self.XG, "s", "v") == ["s", "x", "u", "v"] assert nx.bellman_ford_path_length(self.XG, "s", "v") == 9 assert nx.single_source_bellman_ford_path(self.XG, "s")["v"] == [ "s", "x", "u", "v", ] assert nx.single_source_bellman_ford_path_length(self.XG, "s")["v"] == 9 D, P = nx.single_source_bellman_ford(self.XG, "s", target="v") assert D == 9 assert P == ["s", "x", "u", "v"] (P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, "s") assert P["v"] == ["u"] assert D["v"] == 9 (P, D) = nx.goldberg_radzik(self.XG, "s") assert P["v"] == "u" assert D["v"] == 9
def single_source_byQuality_centrality(self, infectG, subinfectG): #你好,再见 for edge in infectG.edges: # G.add_edge(edge[0], edge[1], weight=1) randomnum = random.random() infectG.add_edge(edge[0], edge[1], weight=self.effectDistance(randomnum)) m_list_add = [ x for x in list(infectG.nodes()) if infectG.node[x]['SI'] == 2 ] m_list_dif = [ x for x in list(infectG.nodes()) if infectG.node[x]['SI'] == 1 ] print('len(m_list_dif', len(m_list_add)) print(subinfectG.number_of_nodes()) len_add = len(m_list_add) len_dif = len(m_list_dif) CQ_dict = defaultdict(int) for node_temp in m_list_add: length_dict = nx.single_source_bellman_ford_path_length( infectG, source=node_temp, weight='weight') d_add_all = 0 d_dif_all = 0 d_dif_avg = 0 d_add_avg = 0 for add in m_list_add: d_dif_all += length_dict[add] for dif in m_list_dif: d_add_all += length_dict[dif] d_dif_avg = d_dif_all / len_dif d_add_avg = d_add_all / len_add CQ_dict[node_temp] = (d_dif_avg - d_add_avg) / d_add_avg CQ_dict_sort = sorted(CQ_dict.items(), key=lambda x: x[1], reverse=True) print('CQ_dict_sort', CQ_dict_sort) return CQ_dict_sort[0]
def single_source_bydistance_coverage_SECOND(self, infectG, subinfectG, true_source): sort_dict = commons.partion_layer_dict(infectG, 10) # 分层 print('sort_list', sort_dict) node_cal = [] for node in subinfectG: node_import = 0 length_dict = nx.single_source_bellman_ford_path_length( subinfectG, node, weight='weight') for othernode, ditance in length_dict.items(): lens_degree = len(list(nx.neighbors(infectG, othernode))) node_import += sort_dict[othernode] / (ditance + 1) node_cal.append([node, node_import]) sort_list = sorted(node_cal, key=lambda x: x[1], reverse=True) print('sort_list', sort_list) print('true_list', true_source) index_list = [] for index in range(0, len(sort_list)): if true_source[0] == sort_list[index][0] or ( true_source[1] == sort_list[index][0]): index_list.append(index) return index_list
def test_negative_weight_cycle(self): G = nx.cycle_graph(5, create_using=nx.DiGraph()) G.add_edge(1, 2, weight=-7) for i in range(5): assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, i) assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, i) assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, i) assert_raises(nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, i) assert_raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, i) G = nx.cycle_graph(5) # undirected Graph G.add_edge(1, 2, weight=-3) for i in range(5): assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, i) assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, i) assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, i) assert_raises(nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, i) assert_raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, i) G = nx.DiGraph([(1, 1, {'weight': -1})]) assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, 1) assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, 1) assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, 1) assert_raises(nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, 1) assert_raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, 1) # no negative cycle but negative weight G = nx.cycle_graph(5, create_using=nx.DiGraph()) G.add_edge(1, 2, weight=-3) assert_equal(nx.single_source_bellman_ford_path(G, 0), {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3], 4: [0, 1, 2, 3, 4]}) assert_equal(nx.single_source_bellman_ford_path_length(G, 0), {0: 0, 1: 1, 2: -2, 3: -1, 4: 0}) assert_equal(nx.single_source_bellman_ford(G, 0), ({0: 0, 1: 1, 2: -2, 3: -1, 4: 0}, {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3], 4: [0, 1, 2, 3, 4]})) assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({0: [], 1: [0], 2: [1], 3: [2], 4: [3]}, {0: 0, 1: 1, 2: -2, 3: -1, 4: 0})) assert_equal(nx.goldberg_radzik(G, 0), ({0: None, 1: 0, 2: 1, 3: 2, 4: 3}, {0: 0, 1: 1, 2: -2, 3: -1, 4: 0}))