def networkx_sp_tree(self, source, target): # compute source-rooted SP tree (preds_ab, self.dist_map_ab) = nx.dijkstra_predecessor_and_distance( self.graph, source, weight="weight") # transform because we want only one predecessor for each self.pred_map_ab = { key: int(next(iter(pred_list), key)) for key, pred_list in preds_ab.items() } # reverse edge directions self.graph = self.graph.reverse(copy=False) # compute target-rooted SP tree (preds_ba, self.dist_map_ba) = nx.dijkstra_predecessor_and_distance( self.graph, target, weight="weight") # fill the ones that are not in dictionary yet (self.pred_map_ba, self.pred_map_ba) = {}, {} vertices = np.unique(self.pos2node)[1:] for v in vertices: try: self.pred_map_ba[v] = int(next(iter(preds_ba[v]), v)) except KeyError: self.pred_map_ba[v] = v self.dist_map_ba[v] = np.inf try: self.pred_map_ab[v] = int(next(iter(preds_ab[v]), v)) except KeyError: self.pred_map_ab[v] = v self.dist_map_ab[v] = np.inf self.graph = self.graph.reverse(copy=False)
def test_dijkstra_predecessor(self): G = nx.path_graph(4) assert_equal(nx.dijkstra_predecessor_and_distance(G, 0), ({ 0: [], 1: [0], 2: [1], 3: [2] }, { 0: 0, 1: 1, 2: 2, 3: 3 })) G = nx.grid_2d_graph(2, 2) pred, dist = nx.dijkstra_predecessor_and_distance(G, (0, 0)) assert_equal(sorted(pred.items()), [((0, 0), []), ((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)]) XG = nx.DiGraph() XG.add_weighted_edges_from([ ('s', 'u', 10), ('s', 'x', 5), ('u', 'v', 1), ('u', 'x', 2), ('v', 'y', 1), ('x', 'u', 3), ('x', 'v', 5), ('x', 'y', 2), ('y', 's', 7), ('y', 'v', 6) ]) (P, D) = nx.dijkstra_predecessor_and_distance(XG, 's') assert_equal(P['v'], ['u']) assert_equal(D['v'], 9) (P, D) = nx.dijkstra_predecessor_and_distance(XG, 's', cutoff=8) assert_false('v' in D)
def test_dijkstra_predecessor(self): G = nx.path_graph(4) assert_equal( nx.dijkstra_predecessor_and_distance(G, 0), ({0: [], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3}) ) G = nx.grid_2d_graph(2, 2) pred, dist = nx.dijkstra_predecessor_and_distance(G, (0, 0)) assert_equal( sorted(pred.items()), [((0, 0), []), ((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)]) XG = nx.DiGraph() XG.add_weighted_edges_from( [ ("s", "u", 10), ("s", "x", 5), ("u", "v", 1), ("u", "x", 2), ("v", "y", 1), ("x", "u", 3), ("x", "v", 5), ("x", "y", 2), ("y", "s", 7), ("y", "v", 6), ] ) (P, D) = nx.dijkstra_predecessor_and_distance(XG, "s") assert_equal(P["v"], ["u"]) assert_equal(D["v"], 9)
def dijkstra_plan_networkX(product, beta=10): # requires a full construct of product automaton start = time.time() runs = {} loop = {} # minimal circles for prod_target in product.graph['accept']: #print 'prod_target', prod_target # accepting state in self-loop if prod_target in product.predecessors(prod_target): loop[prod_target] = ( product.edge[prod_target][prod_target]["weight"], [prod_target, prod_target]) continue else: cycle = {} loop_pre, loop_dist = dijkstra_predecessor_and_distance( product, prod_target) for target_pred in product.predecessors_iter(prod_target): if target_pred in loop_dist: cycle[target_pred] = product.edge[target_pred][ prod_target]["weight"] + loop_dist[target_pred] if cycle: opti_pred = min(cycle, key=cycle.get) suffix = compute_path_from_pre(loop_pre, opti_pred) loop[prod_target] = (cycle[opti_pred], suffix) # shortest line if not product.graph['initial']: print 'Initial set empty' for prod_init in product.graph['initial']: line = {} line_pre, line_dist = dijkstra_predecessor_and_distance( product, prod_init) for target in loop.iterkeys(): if target in line_dist: line[target] = line_dist[target] + beta * loop[target][0] if line: opti_targ = min(line, key=line.get) prefix = compute_path_from_pre(line_pre, opti_targ) precost = line_dist[opti_targ] runs[(prod_init, opti_targ)] = (prefix, precost, loop[opti_targ][1], loop[opti_targ][0]) # best combination if runs: prefix, precost, suffix, sufcost = min( runs.values(), key=lambda p: p[1] + beta * p[3]) run = ProdAut_Run(product, prefix, precost, suffix, sufcost, precost + beta * sufcost) print '==================' print 'Dijkstra_plan_networkX done within %.2fs: precost %.2f, sufcost %.2f' % ( time.time() - start, precost, sufcost) return run, time.time() - start #print '\n==================\n' print '==================' print 'No accepting run found in optimal planning!' return None, None
def test_dijkstra_predecessor3(self): XG = nx.DiGraph() XG.add_weighted_edges_from([('s', 'u', 10), ('s', 'x', 5), ('u', 'v', 1), ('u', 'x', 2), ('v', 'y', 1), ('x', 'u', 3), ('x', 'v', 5), ('x', 'y', 2), ('y', 's', 7), ('y', 'v', 6)]) (P, D) = nx.dijkstra_predecessor_and_distance(XG, 's') assert_equal(P['v'], ['u']) assert_equal(D['v'], 9) (P, D) = nx.dijkstra_predecessor_and_distance(XG, 's', cutoff=8) assert_false('v' in D)
def test_dijkstra_predecessor3(self): XG = nx.DiGraph() XG.add_weighted_edges_from([('s', 'u', 10), ('s', 'x', 5), ('u', 'v', 1), ('u', 'x', 2), ('v', 'y', 1), ('x', 'u', 3), ('x', 'v', 5), ('x', 'y', 2), ('y', 's', 7), ('y', 'v', 6)]) (P, D) = nx.dijkstra_predecessor_and_distance(XG, 's') assert_equal(P['v'], ['u']) assert_equal(D['v'], 9) (P, D) = nx.dijkstra_predecessor_and_distance(XG, 's', cutoff=8) assert_false('v' in D)
def test_dijkstra_predecessor3(self): XG = nx.DiGraph() XG.add_weighted_edges_from([ ('s', 'u', 10), ('s', 'x', 5), ('u', 'v', 1), ('u', 'x', 2), ('v', 'y', 1), ('x', 'u', 3), ('x', 'v', 5), ('x', 'y', 2), ('y', 's', 7), ('y', 'v', 6) ]) (P, D) = nx.dijkstra_predecessor_and_distance(XG, 's') assert P['v'] == ['u'] assert D['v'] == 9 (P, D) = nx.dijkstra_predecessor_and_distance(XG, 's', cutoff=8) assert 'v' not in D
def subtours(n, dist, model, x): # construindo grafo auxiliar (apenas uma vez) global F if not F: F = [] G = nx.DiGraph() for ((i, j), val) in dist.items(): G.add_edge(i, j, weight=val) for i in range(n): P, D = nx.dijkstra_predecessor_and_distance(G, source=i) DS = list(D.items()) DS.sort(key=lambda x: x[1]) F.append((i, DS[-1][0])) G = nx.DiGraph() for (i, j) in x.keys(): if x[(i,j)].x > EPS: G.add_edge(i, j, capacity=x[i,j].x) cycles = set() for (u, v) in F: val, (S, NS) = nx.minimum_cut(G, u, v) if len(S) > 1 and len(S) < n and val <= 0.99: arcs_S = [(i,j) for (i,j) in dist if i in S and j in S] if sum(x[arc].x for arc in arcs_S) >= len(S) - 1 + EPS: cycles.add(tuple(S)) return cycles
def dijkstra(self, v_inicial): if(self.vertices.count(v_inicial) == 0): print("El nodo que ha ingresado no pertenece al grafo") else: filas = columnas = len(self.matriz) #Matriz de peso con enteros matriz = [[0] * (filas) for i in range(columnas)] for f in range(filas): for c in range(columnas): if(self.matriz[f][c] is None): matriz[f][c] = 0 else: matriz[f][c] = int(self.matriz[f][c]) #Creo un array de numpy para analizar la matriz mas facilmente matriz = np.array(matriz) #Creo el grafico de la libreria networkx para usar sus metodos (Dijkstra) G = nx.from_numpy_matrix(matriz, create_using=nx.DiGraph()) pred, dist = nx.dijkstra_predecessor_and_distance(G, self.vertices.index(v_inicial)) dist = dist.items() # print(pred) #Antecesores como diccionario # print(pred.items()) #Antecesores como arreglo for i in dist: #Rearmando la ruta #Codigo del rearme de ruta (In progress...) #Distancias (working...) print("Distancia menor de " + v_inicial + "->" + self.vertices[i[0]] + ": " + str(i[1]))
def estimate(graph, runs): it = 0 max_id = max(graph.nodes()) it_since_last_update = 0 seen = set() est = {'src': -1, 'dst': -1, 'distance': 0, 'edges': 0} src = npr.randint(max_id) while not graph.has_node(src): src = npr.randint(max_id) while it_since_last_update < runs: seen.add(src) pred, dists = nx.dijkstra_predecessor_and_distance(graph, src) dst, dist = max(dists.items(), key=lambda x: x[1]) if dist > est['distance']: est['src'] = src est['dst'] = dst est['distance'] = dist edges = 0 x = dst while x != src: edges += 1 x = pred[x][0] est['edges'] = edges it_since_last_update = 0 print "{} | {} -- {} : {} (cur estimate {} standing {})".format( it, src, dst, dist, est, it_since_last_update) it += 1 src = npr.randint(max_id) if dst in seen else dst it_since_last_update += 1 return est
def test_dijkstra_pred_distance_multigraph(self): G = nx.MultiGraph() G.add_edge('a', 'b', key='short', foo=5, weight=100) G.add_edge('a', 'b', key='long', bar=1, weight=110) p, d = nx.dijkstra_predecessor_and_distance(G, 'a') assert_equal(p, {'a': [], 'b': ['a']}) assert_equal(d, {'a': 0, 'b': 100})
def test_dijkstra_pred_distance_multigraph(self): G = nx.MultiGraph() G.add_edge("a", "b", key="short", foo=5, weight=100) G.add_edge("a", "b", key="long", bar=1, weight=110) p, d = nx.dijkstra_predecessor_and_distance(G, "a") assert_equal(p, {"a": [], "b": ["a"]}) assert_equal(d, {"a": 0, "b": 100})
def test_dijkstra_pred_distance_multigraph(self): G = nx.MultiGraph() G.add_edge('a', 'b', key='short',foo=5, weight=100) G.add_edge('a', 'b', key='long',bar=1, weight=110) p,d= nx.dijkstra_predecessor_and_distance(G, 'a') assert_equal(p,{'a': [], 'b': ['a']}) assert_equal(d,{'a': 0, 'b': 100})
def list_dist(G, list_data, user, list_nodes): """Returns the list of distance between the user node and the other system nodes Parameters : =========================================================================== list_nodes :list of node object G : NetworkX graph user : string (user node label) Returns : =========================================================================== data_list : list of int """ l_dist = [] path = nx.dijkstra_predecessor_and_distance(G, user)[1] l_node = [] if user in list_nodes: list_nodes.remove(user) for node in list_nodes: l_dist.append(path[node]) l_dist.sort() for dist in l_dist: for node in list_node: if path[node] == dist: l_node.append(node) return l_node
def dijkstra_plan_networkX_suffix(product, beta=10): # requires a full construct of product automaton start = time.time() runs = {} loop = {} # minimal circles for prod_target in product.graph['accept']: #print 'prod_target', prod_target # accepting state in self-loop if prod_target in product.predecessors(prod_target): loop[prod_target] = ( product.edge[prod_target][prod_target]["weight"], [prod_target, prod_target]) continue else: cycle = {} loop_pre, loop_dist = dijkstra_predecessor_and_distance( product, prod_target) for target_pred in product.predecessors_iter(prod_target): if target_pred in loop_dist: cycle[target_pred] = product.edge[target_pred][ prod_target]["weight"] + loop_dist[target_pred] print 'one suffix found, cost', cycle[target_pred] if cycle: opti_pred = min(cycle, key=cycle.get) suffix = compute_path_from_pre(loop_pre, opti_pred) loop[prod_target] = (cycle[opti_pred], suffix) print 'optimal suffix found, cost', cycle[opti_pred] print '==================' print 'Dijkstra_plan_networkX_Suffix done within %.2fs: sufcost %.2f' % ( time.time() - start, cycle[opti_pred]) print '==================' print 'No accepting run found in optimal planning!' return None, None
def dijkstra_all_shortest_paths(G, source, target, weight=None): ''' This function is the networkX's implementation of the "all-shortest-paths-problem" algorithm and is used as ground truth for our implementation. It uses a modified version of the dijkstra algorithm that compute the shortest path length and predecessors on shortest paths.''' if weight is not None: pred,dist = nx.dijkstra_predecessor_and_distance(G,source,weight=weight) else: pred = nx.predecessor(G,source) if target not in pred: raise nx.NetworkXNoPath() stack = [[target,0]] top = 0 while top >= 0: node,i = stack[top] if node == source: yield [p for p,n in reversed(stack[:top+1])] if len(pred[node]) > i: top += 1 if top == len(stack): stack.append([pred[node][i],0]) else: stack[top] = [pred[node][i],0] else: stack[top-1][1] += 1 top -= 1
def test_dijkstra_pred_distance_multigraph(self): G = nx.MultiGraph() G.add_edge("a", "b", key="short", foo=5, weight=100) G.add_edge("a", "b", key="long", bar=1, weight=110) p, d = nx.dijkstra_predecessor_and_distance(G, "a") assert p == {"a": [], "b": ["a"]} assert d == {"a": 0, "b": 100}
def compute_mst(G, main_stem, nodes): # Set weights proportional to distance to node # (for computing minimum spanning tree) G = G.copy() distances = {} for i in nodes: _, distances[i] = nx.dijkstra_predecessor_and_distance(G, i) distance_to_node = {} for n in G.nodes(): distance_to_node[n] = min(distances[i][n] for i in nodes) def node_penalty(u, v): if u in main_stem or v in main_stem: return 0 if len(list(nx.neighbors(G, u))) > 2 or len(list(nx.neighbors(G, v))) > 2: print(">2", u, v) return 10000 + distance_to_node[u] + distance_to_node[v] return (distance_to_node[u] + distance_to_node[v]) for u, v in G.edges(): G[u][v]['weight'] = node_penalty(u, v) # Compute minimum spanning tree T = nx.minimum_spanning_tree(G) return T
def phase_from_node_shortest(gg1, startnode): hap0=[] hap1=[] if len(gg1)==1: hap0.append(get_phased_allele(gg1, startnode, 0)) hap1.append(get_phased_allele(gg1, startnode, 1)) else: dp=nx.dijkstra_predecessor_and_distance(gg1, startnode, weight='tot') kk=list(dp[0].keys()) for ii in range(len(kk)): if ii==0: curnode=startnode hap0.append(get_phased_allele(gg1, curnode, 0)) hap1.append(get_phased_allele(gg1, curnode, 1)) else: curnode=kk[ii] prevnode=dp[0][kk[ii]][0] edata=gg1.edges[curnode, prevnode] if 'phased_all' in gg1.nodes[prevnode]: alleles=gg1.nodes[prevnode]['phased_all'] oddsratio=(edata['cts'][0]+1.0)*(edata['cts'][3]+1.0)/((edata['cts'][1]+1.0)*(edata['cts'][2]+1.0)) if oddsratio>1: gg1.nodes[curnode]['phased_all']=alleles else: gg1.nodes[curnode]['phased_all']=[alleles[1], alleles[0]] hap0.append(get_phased_allele(gg1, curnode, 0)) hap1.append(get_phased_allele(gg1, curnode, 1)) return [hap0, hap1]
def _node_betweenness(G, source, cutoff=False, normalized=True, weighted_edges=False): """Node betweenness helper: see betweenness_centrality for what you probably want. This actually computes "load" and not betweenness. See https://networkx.lanl.gov/ticket/103 This calculates the load of each node for paths from a single source. (The fraction of number of shortests paths from source that go through each node.) To get the load for a node you need to do all-pairs shortest paths. If weighted_edges is True then use Dijkstra for finding shortest paths. In this case a cutoff is not implemented and so is ignored. """ # get the predecessor and path length data if weighted_edges: (pred, length) = nx.dijkstra_predecessor_and_distance(G, source) else: (pred, length) = nx.predecessor(G, source, cutoff=cutoff, return_seen=True) # order the nodes by path length onodes = [(l, vert) for (vert, l) in length.items()] onodes.sort() onodes[:] = [vert for (l, vert) in onodes if l > 0] # intialize betweenness between = {}.fromkeys(length, 1.0) while onodes: v = onodes.pop() if v in pred: num_paths = len(pred[v]) # Discount betweenness if more than for x in pred[v]: # one shortest path. if x == source: # stop if hit source because all remaining v break # also have pred[v]==[source] between[x] += between[v] / float(num_paths) # remove source for v in between: between[v] -= 1 # rescale to be between 0 and 1 if normalized: l = len(between) if l > 2: scale = 1.0 / float( (l - 1) * (l - 2)) # 1/the number of possible paths for v in between: between[v] *= scale return between
def make_paths_tree(nodes,origin): pred, length = nx.dijkstra_predecessor_and_distance(G, origin, cutoff=None, weight='length') tree = build_paths_tree(pred,nodes,origin) N = len(nodes) dist = np.empty(N) for i in range(N): dist[i] = length[nodes[i]] return tree, dist
def explore_shortestpath(G,K): cx,cy = position(entiers=True) _ , dist = nx.dijkstra_predecessor_and_distance( G,(cx,cy) ) dist = {ij:dist[ij] for ij in dist if ij not in K} if dist: closest, _ = min(dist.items(), key=itemgetter(1)) p = nx.shortest_path(G,(cx,cy),closest,weight='weight') suivre_chemin(p,aller)
def _node_betweenness(G, source, cutoff=False, weight=None, destIdentifier='destinations'): """Node betweenness_centrality helper: See betweenness_centrality for what you probably want. This actually computes "partial centrality" and not betweenness. See https://networkx.lanl.gov/ticket/103 This calculates the load of each node for paths from a single source. (The fraction of number of shortests paths from source that go through each node.) To get the load for a node you need to do all-pairs shortest paths. If weight is not None then use Dijkstra for finding shortest paths. """ # get the predecessor and path length data if weight is None: (pred, length) = nx.predecessor(G, source, cutoff=cutoff, return_seen=True) else: (pred, length) = nx.dijkstra_predecessor_and_distance(G, source, cutoff, weight) for predecessor in pred: newlist = [] if len(pred[predecessor]) > 0: minimo = pred[predecessor][0] for elem in pred[predecessor]: if int(elem) < int(minimo): minimo = elem newlist.append(minimo) pred[predecessor][:] = newlist onodes = [(l, vert) for (vert, l) in length.items()] onodes.sort() onodes[:] = [vert for (l, vert) in onodes if l > 0] between = {}.fromkeys(length, 1.0) for node in G.nodes: if destIdentifier not in G.nodes[node]: between[node] = 0.0 # No stub nodes does not propagate any contribute else: between[node] = 1.0 # Stub nodes propagate 1 contribute while onodes: v = onodes.pop() if v in pred: num_paths = len(pred[v]) # Discount betweenness if more than for x in pred[v]: # one shortest path. if x == source: # stop if hit source break # also have pred[v]==[source] between[x] += between[v] / float(num_paths) for node in G.nodes: if destIdentifier in G.nodes[node]: between[node] -= 1.0 return between
def dijkstra_plan_networkX(product, beta=10): # requires a full construct of product automaton start = time.time() runs = {} loop = {} # minimal circles for prod_target in product.graph['accept']: #print 'prod_target', prod_target # accepting state in self-loop if prod_target in product.predecessors(prod_target): loop[prod_target] = (product.edges[prod_target,prod_target]["weight"], [prod_target, prod_target]) continue else: cycle = {} loop_pre, loop_dist = dijkstra_predecessor_and_distance(product, prod_target) for target_pred in product.predecessors(prod_target): if target_pred in loop_dist: cycle[target_pred] = product.edges[target_pred,prod_target]["weight"] + loop_dist[target_pred] if cycle: opti_pred = min(cycle, key = cycle.get) suffix = compute_path_from_pre(loop_pre, opti_pred) loop[prod_target] = (cycle[opti_pred], suffix) # shortest line for prod_init in product.graph['initial']: line = {} line_pre, line_dist = dijkstra_predecessor_and_distance(product, prod_init) for target in loop.iterkeys(): if target in line_dist: line[target] = line_dist[target]+beta*loop[target][0] if line: opti_targ = min(line, key = line.get) prefix = compute_path_from_pre(line_pre, opti_targ) precost = line_dist[opti_targ] runs[(prod_init, opti_targ)] = (prefix, precost, loop[opti_targ][1], loop[opti_targ][0]) # best combination if runs: prefix, precost, suffix, sufcost = min(runs.values(), key = lambda p: p[1] + beta*p[3]) run = ProdAut_Run(product, prefix, precost, suffix, sufcost, precost+beta*sufcost) print '==================' print 'Dijkstra_plan_networkX done within %.2fs: precost %.2f, sufcost %.2f' %(time.time()-start, precost, sufcost) return run, time.time()-start #print '\n==================\n' print '==================' print 'No accepting run found in optimal planning!' return None, None
def test_dijkstra_predecessor2(self): # 4-cycle G = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 0)]) pred, dist = nx.dijkstra_predecessor_and_distance(G, (0)) assert_equal(pred[0], []) assert_equal(pred[1], [0]) assert_true(pred[2] in [[1, 3], [3, 1]]) assert_equal(pred[3], [0]) assert_equal(dist, {0: 0, 1: 1, 2: 2, 3: 1})
def test_dijkstra_predecessor2(self): # 4-cycle G = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 0)]) pred, dist = nx.dijkstra_predecessor_and_distance(G, (0)) assert pred[0] == [] assert pred[1] == [0] assert pred[2] in [[1, 3], [3, 1]] assert pred[3] == [0] assert dist == {0: 0, 1: 1, 2: 2, 3: 1}
def test_dijkstra_predecessor2(self): # 4-cycle G = nx.Graph([(0,1),(1,2),(2,3),(3,0)]) pred, dist = nx.dijkstra_predecessor_and_distance(G, (0)) assert_equal(pred[0],[]) assert_equal(pred[1],[0]) assert_true(pred[2] in [[1,3],[3,1]]) assert_equal(pred[3],[0]) assert_equal(dist, {0: 0, 1: 1, 2: 2, 3: 1})
def test_dijkstra_predecessor3(self): XG = nx.DiGraph() XG.add_weighted_edges_from([ ("s", "u", 10), ("s", "x", 5), ("u", "v", 1), ("u", "x", 2), ("v", "y", 1), ("x", "u", 3), ("x", "v", 5), ("x", "y", 2), ("y", "s", 7), ("y", "v", 6), ]) (P, D) = nx.dijkstra_predecessor_and_distance(XG, "s") assert P["v"] == ["u"] assert D["v"] == 9 (P, D) = nx.dijkstra_predecessor_and_distance(XG, "s", cutoff=8) assert "v" not in D
def Part1_4(house_nd,object_nd): N = len(house_nd) M = len(object_nd) tree_weights = np.empty(M) for j in range(M): pred, length_object2house = nx.dijkstra_predecessor_and_distance(G, object_nd[j], cutoff=None, weight='length') tree = build_paths_tree(pred,house_nd,object_nd[j]) tree_weights[j] = tree.size(weight='length') arg = np.argmin(tree_weights) return arg
def test_dijkstra_all_digraph(testgraph): """ Testing dijkstra_all function for directed graphs. """ a, b = testgraph[2:] s = randint(0, 99) nx_dijk = nx.dijkstra_predecessor_and_distance(a, s) nx_dijk = nx_dijk[1] sg_dijk = sg.dijkstra.dijkstra_all(b, s, directed = True) for i in range(len(nx_dijk)): assert sg_dijk[1][i] == nx_dijk[sg_dijk[0][i]]
def shortest_path_ts(ts, f_ts_node, t_ts_node): if (f_ts_node not in ts) or (t_ts_node not in ts): print 'either nodes not in ts' return None, None else: path_pre, path_dist = dijkstra_predecessor_and_distance(ts, f_ts_node) if t_ts_node not in path_dist: print 'destination not reached' else: path = compute_path_from_pre(path_pre, t_ts_node) cost = path_dist[t_ts_node] return (path, cost)
def test_dijkstra_predecessor(self): G=nx.path_graph(4) assert_equal(nx.dijkstra_predecessor_and_distance(G,0), ({0: [], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3})) G=nx.grid_2d_graph(2,2) pred,dist=nx.dijkstra_predecessor_and_distance(G,(0,0)) assert_equal(sorted(pred.items()), [((0, 0), []), ((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)]) XG=nx.DiGraph() XG.add_weighted_edges_from([('s','u',10) ,('s','x',5) , ('u','v',1) ,('u','x',2) , ('v','y',1) ,('x','u',3) , ('x','v',5) ,('x','y',2) , ('y','s',7) ,('y','v',6)]) (P,D)= nx.dijkstra_predecessor_and_distance(XG,'s') assert_equal(P['v'],['u']) assert_equal(D['v'],9)
def _node_betweenness(G, source, cutoff=False, normalized=True, weight=None): """Node betweenness_centrality helper: See betweenness_centrality for what you probably want. This actually computes "load" and not betweenness. See https://networkx.lanl.gov/ticket/103 This calculates the load of each node for paths from a single source. (The fraction of number of shortests paths from source that go through each node.) To get the load for a node you need to do all-pairs shortest paths. If weight is not None then use Dijkstra for finding shortest paths. """ # get the predecessor and path length data if weight is None: (pred, length) = nx.predecessor(G, source, cutoff=cutoff, return_seen=True) else: (pred, length) = nx.dijkstra_predecessor_and_distance(G, source, cutoff, weight) # order the nodes by path length onodes = [(l, vert) for (vert, l) in length.items()] onodes.sort() onodes[:] = [vert for (l, vert) in onodes if l > 0] # intialize betweenness between = {}.fromkeys(length, 1.0) while onodes: v = onodes.pop() if v in pred: num_paths = len(pred[v]) # Discount betweenness if more than for x in pred[v]: # one shortest path. if x == source: # stop if hit source because all remaining v break # also have pred[v]==[source] between[x] += between[v] / float(num_paths) # remove source for v in between: between[v] -= 1 # rescale to be between 0 and 1 if normalized: l = len(between) if l > 2: # scale by 1/the number of possible paths scale = 1.0 / float((l - 1) * (l - 2)) for v in between: between[v] *= scale return between
def get_farthest_point_list(self): # computing farthest point for each point, these will be checked first for # isolated subtours F = [] for i in self.graph.nodes(): P, D = nx.dijkstra_predecessor_and_distance(self.graph, source=i) DS = list(D.items()) farthest_point = max(DS, key=lambda x: x[1])[0] F.append((i, farthest_point)) return F
def test_dijkstra_predecessor1(self): G = nx.path_graph(4) assert (nx.dijkstra_predecessor_and_distance(G, 0) == ({ 0: [], 1: [0], 2: [1], 3: [2] }, { 0: 0, 1: 1, 2: 2, 3: 3 }))
def perform_tests(files): Time_nx = [] Time_custom = [] Num = [] for file in files: input_data = pd.read_csv(file, index_col=0) G = nx.DiGraph(input_data.values) N = len(G.nodes()) Num.append(N) #D_truth = np.empty([N,N]) #D = np.empty([N,N]) D_truth = [] D = [] t0 = tm.time() for i in range(N): D_truth.append( nx.dijkstra_predecessor_and_distance(G, i, weight='weight')[1]) t1 = tm.time() Time_nx.append(t1 - t0) t0 = tm.time() for i in range(N): D.append(custom_dijkstra(G, i, weight='weight')[1]) t1 = tm.time() Time_custom.append(t1 - t0) Dist = np.zeros([N, N]) Dist_truth = np.zeros([N, N]) for i in range(N): for e in D[i]: Dist[i, e] = D[i][e] for i in range(N): for e in D_truth[i]: Dist_truth[i, e] = D_truth[i][e] print(np.max(Dist - Dist_truth) == 0.0) Dist = np.append([np.arange(N)], Dist, axis=0) Dist = np.append(np.transpose([np.concatenate(([0], np.arange(N)))]), Dist, axis=1) np.savetxt( file[0:-4] + '_result.csv', Dist.astype(int), delimiter=',', fmt='%5.0f', ) return Time_nx, Time_custom, Num
def nx_dijkstra( graph: NetworkXGraph, source_node: NodeID # , max_path_length: float ) -> Tuple[PythonNodeMap, PythonNodeMap]: predecessors_map, distance_map = nx.dijkstra_predecessor_and_distance( graph.value, source_node, # cutoff=max_path_length, ) single_parent_map = { child: parents[0] if len(parents) > 0 else source_node for child, parents in predecessors_map.items() } return ( PythonNodeMap(single_parent_map, ), PythonNodeMap(distance_map, ), )
def checkMetricCompatibility(G, system, weights, strict=False): N = len(G.nodes) #This defines edge weight function def wghtFxn(i, j, dictEdge): edge = (i, j) if i < j else (j, i) return weights[edge] #Given a path gives its weight def pathWeight(p): sum = 0 for i in range(0, len(p) - 1): sum = sum + wghtFxn(p[i], p[i + 1], []) return sum #Get all the shortest distances between vtxs len_path = dict(nx.all_pairs_dijkstra_path_length(G, weight=wghtFxn)) #We check is all the paths in the system are geodesics wrt to weightStrings for i in range(1, N): for j in range(0, i): #shortest distance between ij wrt weights ijDist = len_path[i][j] #weight of ij path in the path system pthSysDist = pathWeight(system[i][j]) #If the actual disance is smaller than that of ij path from the system return false if ijDist < pthSysDist: return False #In the strict case we need to also check each path is unique if strict: for i in range(1, N): #pred is a dictionary which contains all the predeccesors of all paths with source i pred, _ = nx.dijkstra_predecessor_and_distance(G, i, weight=wghtFxn) for j in range(0, i): #If j has two predeccesors on the shortest ij path then it is not unique if len(pred[j]) > 1: return False return True
def get_main_stem_and_nodes(G, root_node): # Get main stem as shortest path to point furthest from root predecessors, distances_to_root = nx.dijkstra_predecessor_and_distance( G, root_node) i = max(distances_to_root.items(), key=operator.itemgetter(1))[0] main_stem = [i] current_node = i while current_node != root_node: current_node = predecessors[current_node][0] main_stem.append(current_node) main_stem = np.array(main_stem, dtype=int) # Get nodes, sorted from closest to furthest to the root n_neighbors = np.array([len(list(nx.neighbors(G, g))) for g in main_stem], dtype=int) nodes = main_stem[n_neighbors > 2] nodes = nodes[::-1] return main_stem[::-1], nodes
def all_shortest_paths(G, source, target, weight=None): if weight is not None: pred,dist = nx.dijkstra_predecessor_and_distance(G,source,weight=weight) else: pred = nx.predecessor(G,source) if target not in pred: raise nx.NetworkXNoPath() stack = [[target,0]] top = 0 while top >= 0: node,i = stack[top] if node == source: yield [p for p,n in reversed(stack[:top+1])] if len(pred[node]) > i: top += 1 if top == len(stack): stack.append([pred[node][i],0]) else: stack[top] = [pred[node][i],0] else: stack[top-1][1] += 1 top -= 1
def all_shortest_paths(G, source, target, weight=None): """Compute all shortest paths in the graph. Parameters ---------- G : NetworkX graph source : node Starting node for path. target : node Ending node for path. weight : None or string, optional (default = None) If None, every edge has weight/distance/cost 1. If a string, use this edge attribute as the edge weight. Any edge attribute not present defaults to 1. Returns ------- paths: generator of lists A generator of all paths between source and target. Examples -------- >>> G=nx.Graph() >>> G.add_path([0,1,2]) >>> G.add_path([0,10,2]) >>> print([p for p in nx.all_shortest_paths(G,source=0,target=2)]) [[0, 1, 2], [0, 10, 2]] Notes ----- There may be many shortest paths between the source and target. See Also -------- shortest_path() single_source_shortest_path() all_pairs_shortest_path() """ if weight is not None: pred,dist = nx.dijkstra_predecessor_and_distance(G,source,weight=weight) else: pred = nx.predecessor(G,source) if target not in pred: raise nx.NetworkXNoPath() stack = [[target,0]] top = 0 while top >= 0: node,i = stack[top] if node == source: yield [p for p,n in reversed(stack[:top+1])] if len(pred[node]) > i: top += 1 if top == len(stack): stack.append([pred[node][i],0]) else: stack[top] = [pred[node][i],0] else: stack[top-1][1] += 1 top -= 1
def dijkstra_plan_networkX(self, beta=10): # requires a full construct of product automaton start = time.time() runs = {} loop = {} # minimal circles for prod_target in self.graph['accept']: cycle = {} loop_pre, loop_dist = nx.dijkstra_predecessor_and_distance(self, prod_target) #print "\nTEST",prod_target for target_pred in self.predecessors_iter(prod_target): if target_pred in loop_dist: #print target_pred, prod_target cycle[target_pred] = self.edge[target_pred][prod_target]["weight"] + loop_dist[target_pred] if cycle: opti_pred = min(cycle, key = cycle.get) suffix = compute_path_from_pre(loop_pre, opti_pred) #print opti_pred,prod_target,suffix loop[prod_target] = (cycle[opti_pred], suffix) # print "loops" # for p in loop.keys(): # print p,"\t>>",loop[p] # shortest line for prod_init in self.graph['initial']: line = {} line_pre, line_dist = nx.dijkstra_predecessor_and_distance(self, prod_init) # print # print prod_init # print "line_dist" # for l,m in line_dist.items(): # print l,m # print "line_pre" # for l,m in line_pre.items(): # print l,m # print "loop" # for n in loop.iterkeys(): # print n # print "\n<<<<<<<<<<<<" for target in loop.iterkeys(): if target in line_dist.iterkeys(): line[target] = line_dist[target]+beta*loop[target][0] # print prod_init,target,line[target] # print "<<<<<<<<<<<<\n" if line: opti_targ = min(line, key = line.get) prefix = compute_path_from_pre(line_pre, opti_targ) precost = line_dist[opti_targ] runs[(prod_init, opti_targ)] = (prefix, precost, loop[opti_targ][1], loop[opti_targ][0]) # print prod_init,">>",opti_targ, ">>",loop[opti_targ][1] # print "Runs\n...................................." # for r,p in runs.items(): # print # print r # print p # print "...................................." # best combination if runs: prefix, precost, suffix, sufcost = min(runs.values(), key = lambda p: p[1] + beta*p[3]) #print '\n==================\n' return prefix, precost, suffix, sufcost #print '\n==================\n' print 'no accepting run found in optimal planning!'
def test_dijkstra_predecessor1(self): G = nx.path_graph(4) assert_equal(nx.dijkstra_predecessor_and_distance(G, 0), ({0: [], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3}))