def Bestplacement(graph, colors,avg_weight,max_weight,inter_weight): subG = subGraph(graph,colors) controllers = [] for subg in subG: controllerplace = '' mintl = -1 for node in subg: lenghts = nx.single_source_shortest_path_length(subg,node) lenghts_graph = nx.single_source_shortest_path_length(graph,node) mx = -1 ag = 0.0 wg = 0.0 for l in lenghts: if lenghts[l]>mx: mx = lenghts[l] ag += lenghts[l] for l in lenghts_graph: wg += lenghts_graph[l] tl = tradeoff_function(ag/nx.number_of_nodes(subg),avg_weight,mx,max_weight,wg/nx.number_of_nodes(graph),inter_weight) #tl = avg_weight*(ag/nx.number_of_nodes(subg))+max_weight*mx if mintl < 0: mintl = tl controllerplace = node elif tl < mintl: mintl = tl controllerplace = node controllers.append(controllerplace) return controllers
def ego_graph(G,n,radius=1,center=True,undirected=False,distance=None): """Returns induced subgraph of neighbors centered at node n within a given radius. Parameters ---------- G : nxgraph A NetworkX Graph or DiGraph n : node A single node radius : number, optional Include all neighbors of distance<=radius from n. center : bool, optional If False, do not include center node in nxgraph undirected : bool, optional If True use both in- and out-neighbors of directed graphs. distance : key, optional Use specified edge data key as distance. For example, setting distance='weight' will use the edge weight to measure the distance from the node n. Notes ----- For directed graphs D this produces the "out" neighborhood or successors. If you want the neighborhood of predecessors first reverse the nxgraph with D.reverse(). If you want both directions use the keyword argument undirected=True. Node, edge, and nxgraph attributes are copied to the returned subgraph. """ if undirected: if distance is not None: sp,_=nx.single_source_dijkstra(G.to_undirected(), n,cutoff=radius, weight=distance) else: sp=nx.single_source_shortest_path_length(G.to_undirected(), n,cutoff=radius) else: if distance is not None: sp,_=nx.single_source_dijkstra(G, n,cutoff=radius, weight=distance) else: sp=nx.single_source_shortest_path_length(G,n,cutoff=radius) H=G.subgraph(sp).copy() if not center: H.remove_node(n) return H
def add_pseudo_edges(g, dg, threshold): """ flawed logic, needs to be fixed """ if threshold == -1 : return -1 if len(dg) == 0: dg = nx.read_edgelist(sys.argv[2], create_using=dg) new_edges = [] for n in dg.nodes(): if not g.has_node(n): continue fw_count = {} n_dists = nx.single_source_shortest_path_length(g,n,4) followings = set(dg.successors(n)) for node, dist in n_dists.iteritems(): if dist > 2: continue for f in dg.successors(node): if f not in followings: if f in fw_count: fw_count[f] = fw_count[f] + 1 else: fw_count[f] = 1 for k,v in fw_count.iteritems(): if v >= threshold and k in n_dists and n_dists[k] <= 4: new_edges.append((n,k)) for e in new_edges: dg.add_edge(*e) print >> sys.stderr, "new edges", len(new_edges) return 0
def test_shortest_path(self): deg = [3, 2, 2, 1] G = nx.generators.havel_hakimi_graph(deg) cs1 = nxt.creation_sequence(deg, with_labels=True) for n, m in [(3, 0), (0, 3), (0, 2), (0, 1), (1, 3), (3, 1), (1, 2), (2, 3)]: assert_equal(nxt.shortest_path(cs1, n, m), nx.shortest_path(G, n, m)) spl = nxt.shortest_path_length(cs1, 3) spl2 = nxt.shortest_path_length([t for v, t in cs1], 2) assert_equal(spl, spl2) spld = {} for j, pl in enumerate(spl): n = cs1[j][0] spld[n] = pl assert_equal(spld, nx.single_source_shortest_path_length(G, 3)) assert_equal(nxt.shortest_path(['d', 'd', 'd', 'i', 'd', 'd'], 1, 2), [1, 2]) assert_equal(nxt.shortest_path([3, 1, 2], 1, 2), [1, 2]) assert_raises(TypeError, nxt.shortest_path, [3., 1., 2.], 1, 2) assert_raises(ValueError, nxt.shortest_path, [3, 1, 2], 'a', 2) assert_raises(ValueError, nxt.shortest_path, [3, 1, 2], 1, 'b') assert_equal(nxt.shortest_path([3, 1, 2], 1, 1), [1])
def calc_LDEglob_node(G, xNode): ''' A function to calculate the nodal contribution of path length L, diameter D, and global efficiency Eglob from a node xNode. input parameters: G: A graph in networkX format. xNode: The node where the nodal global efficiency is calculated. returns: L: The nodal path length at xNode. D: The nodal diameter at xNode. EglobSum: The nodal global efficiency. ''' NNodes = len(G.nodes()) Dx = list(nx.single_source_shortest_path_length(G, xNode).values()) indZ = np.nonzero(np.array(Dx)==0)[0] nzDx = np.delete(Dx, indZ) if len(nzDx)>0: EglobSum = np.sum(1.0/nzDx) L = np.mean(nzDx) D = np.max(nzDx) else: EglobSum = 0 L = 0 D = 0 # returning the nodal global efficiency return L, D, EglobSum
def savegraph(G, i): G = nx.random_geometric_graph(200, 0.125) # position is stored as node attribute data for random_geometric_graph # pos=nx.get_node_attributes(G,'pos') # find node near center (0.5,0.5) # dmin=1 # ncenter=0 # for n in pos: # x,y=pos[n] # d=(x-0.5)**2+(y-0.5)**2 # if d<dmin: # ncenter=n # dmin=d ncenter = 0.5 dmin = 0.5 # color by path length from node near center p = nx.single_source_shortest_path_length(G, ncenter) plt.figure(figsize=(8, 8)) nx.draw_networkx_edges(G, pos, nodelist=[ncenter], alpha=0.4) nx.draw_networkx_nodes(G, pos, nodelist=p.keys(), node_size=80, node_color=p.values(), cmap=plt.cm.Reds_r) plt.xlim(-0.05, 1.05) plt.ylim(-0.05, 1.05) plt.axis("off") name = "graph " + str(i) + ".png" plt.savefig(name)
def obca(g): diameter = nx.diameter(g) lb_max = diameter + 1 # Rank the nodes according to their degree results = nx.degree_centrality(g) nodes = next(zip(*sorted(results.items(), key=operator.itemgetter(1)))) results = dict() for lb in range(2, lb_max): covered_frequency = [0] * len(g.nodes()) boxes = list() for i in range(0, len(nodes)): node = nodes[i] if covered_frequency[i] > 0: continue box = list(nx.single_source_shortest_path_length(g, node, lb-1).keys()) # Verify that all paths within the box have the length less then lb index = 0 while True: node = box[index] for j in range(index+1, len(box)): neighbor = box[j] if nx.shortest_path_length(g, node, neighbor) >= lb: box.remove(neighbor) index += 1 if index >= len(box): break for node in box: node_index = nodes.index(node) covered_frequency[node_index] += 1 boxes.append(box) for box in boxes: redundant_box = True for node in box: node_index = nodes.index(node) if covered_frequency[node_index] == 1: redundant_box = False break if redundant_box: for node in box: node_index = nodes.index(node) covered_frequency[node_index] -= 1 boxes.remove(box) print("lb: {}, boxes: {}, cf: {}".format(lb, boxes, covered_frequency)) results[lb] = boxes return results
def show_geo_graph(graph): node_position = nx.get_node_attributes(graph,'pos') # Find node near center (0.5,0.5) d_min = 1 node_near_center = 0 for node in node_position: x, y = node_position[node] distance = (x - 0.5)**2 + (y - 0.5)**2 if distance < d_min: node_near_center = node d_min = distance # Color by path length from node near center color_node = dict(nx.single_source_shortest_path_length(graph, node_near_center)) array_color_node = np.array(list(color_node.values())) sns.set_style('darkgrid') cmap = sns.cubehelix_palette(start = .5, rot = -.65, dark = .4, light = .6, as_cmap = True) plt.figure(figsize = (10, 8)) nx.draw_networkx_edges(graph, node_position, nodelist=[node_near_center],alpha=0.4) nx.draw_networkx_nodes(graph, node_position, nodelist=color_node.keys(), node_size = 80, node_color = array_color_node, cmap = cmap) plt.xlim(0,1) plt.ylim(0,1) plt.axis('off') file = str(graph_path) + "/graph.pdf" plt.savefig(file, transparent = True)
def neighbourhood(G, n, k=1): """Get k-neighbourhood of node n""" if k == 1: return G[n] dist = nx.single_source_shortest_path_length(G, n, k) del dist[n] return dist.keys()
def connected_components(G): """Return nodes in connected components of graph. Parameters ---------- G : NetworkX Graph An undirected graph. Returns ------- comp : list of lists A list of nodes for each component of G. See Also -------- strongly_connected_components Notes ----- The list is ordered from largest connected component to smallest. For undirected graphs only. """ if G.is_directed(): raise nx.NetworkXError("""Not allowed for directed graph G. Use UG=G.to_undirected() to create an undirected graph.""") seen={} components=[] for v in G: if v not in seen: c=nx.single_source_shortest_path_length(G,v) components.append(list(c.keys())) seen.update(c) components.sort(key=len,reverse=True) return components
def random_graph(): G=nx.random_geometric_graph(200,0.125) # position is stored as node attribute data for random_geometric_graph pos=nx.get_node_attributes(G,'pos') # find node near center (0.5,0.5) dmin=1 ncenter=0 for n in pos: x,y=pos[n] d=(x-0.5)**2+(y-0.5)**2 if d<dmin: ncenter=n dmin=d # color by path length from node near center p=nx.single_source_shortest_path_length(G,ncenter) plt.figure(figsize=(8,8)) nx.draw_networkx_edges(G,pos,nodelist=[ncenter],alpha=0.4) nx.draw_networkx_nodes(G,pos,nodelist=p.keys(), node_size=80, node_color=p.values(), cmap=plt.cm.Reds_r) plt.xlim(-0.05,1.05) plt.ylim(-0.05,1.05) plt.axis('off') #plt.savefig('random_geometric_graph.png') plt.show()
def _distances_from_function_exit(function): """ :param function: A normalized Function object. :returns: A dictionary of basic block addresses and their distance to the exit of the function. """ reverse_graph = function.graph.reverse() # we aren't guaranteed to have an exit from the function so explicitly add the node reverse_graph.add_node("start") found_exits = False for n in function.graph.nodes(): if len(function.graph.successors(n)) == 0: reverse_graph.add_edge("start", n) found_exits = True # if there were no exits (a function with a while 1) let's consider the block with the highest address to # be the exit. This isn't the most scientific way, but since this case is pretty rare it should be okay if not found_exits: last = max(function.graph.nodes(), key=lambda x:x.addr) reverse_graph.add_edge("start", last) dists = networkx.single_source_shortest_path_length(reverse_graph, "start") # remove temp node del dists["start"] # correct for the added node for n in dists: dists[n] -= 1 return dists
def _distances_from_function_start(function): """ :param function: A normalized Function object. :returns: A dictionary of basic block addresses and their distance to the start of the function. """ return networkx.single_source_shortest_path_length(function.graph, function.startpoint)
def graphStats(graph): pathlengths = [] #print("source vertex {target:length, }") for v in graph.nodes(): spl = networkx.single_source_shortest_path_length(graph, v) #print('%s %s' % (v,spl)) for p in spl.values(): pathlengths.append(p) print('') print( "average shortest path length %s" % (sum(pathlengths) / len(pathlengths))) # histogram of path lengths dist = {} for p in pathlengths: if p in dist: dist[p] += 1 else: dist[p] = 1 print('')
def r2_neighbors(graph, n): dict = nx.single_source_shortest_path_length(graph, n, 2) dict = gt.invert_dict(dict) if 2 in dict: return dict[2] else: return []
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 get_neighbors(graph, node, level): """Get neighbors of a given node up to a certain level""" min_level = int(level) if min_level < level: max_level = min_level + 1 percentaje = level - min_level else: max_level = level percentaje = 0 # All neighbors up to max_level all_neighbors = nx.single_source_shortest_path_length(graph, node, cutoff=max_level) if percentaje > 0: neighbors_min_level = [k for (k, v) in all_neighbors.items() if (1 <= v <= min_level)] neighbors_max_level = [k for (k, v) in all_neighbors.items() if v == max_level] n = np.round(len(neighbors_max_level) * percentaje) additional_neighbors = random.sample(neighbors_max_level, int(n)) neighbors = neighbors_min_level + additional_neighbors else: neighbors = [k for (k, v) in all_neighbors.items() if (1 <= v <= max_level)] return neighbors
def depth_crawl(web, depth): random.seed(42) page_db = aduana.PageDB(tempfile.mkdtemp(prefix='test-', dir='./')) backend = aduana.frontera.Backend( aduana.BFScheduler.from_settings( page_db, settings={ 'MAX_CRAWL_DEPTH': depth } ) ) backend.frontier_start() backend.add_seeds([FakeLink('https://news.ycombinator.com/', 1.0)]) crawled = [] requests = True while requests: requests = backend.get_next_requests(10) for req in requests: crawled.append(req.url) links = web.crawl(req.url) backend.page_crawled(FakeResponse(req.url), map(FakeLink, links)) dist = nx.single_source_shortest_path_length( web.graph, 'https://news.ycombinator.com/', cutoff=depth ) for page in crawled: assert dist[page] <= (depth - 1) backend.frontier_stop()
def node_connected_component(G,n): """Return nodes in connected components of graph containing node n. Parameters ---------- G : NetworkX Graph An undirected graph. n : node label A node in G Returns ------- comp : lists A list of nodes in component of G containing node n. See Also -------- connected_components Notes ----- For undirected graphs only. """ if G.is_directed(): raise nx.NetworkXError("""Not allowed for directed graph G. Use UG=G.to_undirected() to create an undirected graph.""") return list(nx.single_source_shortest_path_length(G,n).keys())
def approximate_cpl(graph, q=0.5, delta=0.15, eps=0.05): """ Computes the approximate CPL for the specified graph :param graph: the graph :param q: the q-median to use (default 1/2-median, i.e., median) :param delta: used to compute the size of the sample :param eps: used to compute the size of the sample :return: the median :rtype: float """ import networkx assert isinstance(graph, networkx.Graph) s = _estimate_s(q, delta, eps) s = int(math.ceil(s)) if graph.number_of_nodes() <= s: sample = graph.nodes_iter() else: sample = random.sample(graph.adj.keys(), s) averages = [] for node in sample: path_lengths = networkx.single_source_shortest_path_length(graph, node) average = sum(path_lengths.values()) / float(len(path_lengths)) averages.append(average) averages.sort() median_index = int(len(averages) * q + 1) return averages[median_index]
def findNeighbours_of_Nulls(fileName, writer): G = nx.Graph() with open(fileName, 'r') as meterFile: distReader = csv.reader(meterFile, delimiter=',') next(distReader, None) for row in distReader: G.add_node(row[0], lat=row[1], lng=row[2]) G.add_node(row[3], lat=row[4], lng=row[5]) G.add_edge(row[0],row[3], length= row[-1]) coord_neighbors = {} nulls = [n for n in G.nodes() if G.node[n]['lat'] == "null" and G.node[n]['lng'] == "null"] for node in nulls: length = nx.single_source_shortest_path_length(G,node) sorted_length = sorted(length.items(), key=operator.itemgetter(1)) neighCoords = [] # exclude the firs item of list from the loop which is the node itself with the distance of zero from the node! i.e. ('node',0) for l in sorted_length[1:]: # check the distance of node from the neigbor and if the neighbor has coordinate if 0 < l[1] and G.node[l[0]]['lat'] != "null" and G.node[l[0]]['lng'] != "null": # add the neighbor to array neighCoords.append( l[1]) # limit the neighbors to two to have at leat two neighbours with if len(neighCoords) >= 2: break writer.writerow([node,neighCoords])
def _global_relabeling_heuristic(G, t, labels_dict=None, res_capacity='res_capacity', capacity='capacity',preflow='preflow', distance='distance',excess='excess'): """ The global relabeling heuristic updates the distance function by computing shortest path distances in the residual graph from all nodes to the sink. """ res_G = nx.DiGraph() for u,v in G.edges_iter(): if G[u][v][capacity] - G[u][v][preflow] > 0: res_G.add_edge(u,v,res_capacity=G[u][v][capacity]-G[u][v][preflow]) if G[u][v][preflow] > 0: res_G.add_edge(v,u,res_capacity=G[u][v][preflow]) distances = nx.single_source_shortest_path_length( res_G.reverse(copy=False), t) for v in distances: G.node[v][distance] = distances[v] if labels_dict is not None: for v in distances: if G.node[v][excess] > 0 and labels_dict.has_key(G.node[v][distance]): labels_dict[G.node[v][distance]].remove(v) if labels_dict.has_key(distances[v]): labels_dict[distances[v]].append(v) else: labels_dict[distances[v]] = [v]
def average_shortest_path_length(G, weight=None): r"""Return the average shortest path length. The average shortest path length is .. math:: a =\sum_{s,t \in V} \frac{d(s, t)}{n(n-1)} where `V` is the set of nodes in `G`, `d(s, t)` is the shortest path from `s` to `t`, and `n` is the number of nodes in `G`. Parameters ---------- G : NetworkX graph 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. Raises ------ NetworkXError: if the graph is not connected. Examples -------- >>> G=nx.path_graph(5) >>> print(nx.average_shortest_path_length(G)) 2.0 For disconnected graphs you can compute the average shortest path length for each component: >>> G=nx.Graph([(1,2),(3,4)]) >>> for g in nx.connected_component_subgraphs(G): ... print(nx.average_shortest_path_length(g)) 1.0 1.0 """ if G.is_directed(): if not nx.is_weakly_connected(G): raise nx.NetworkXError("Graph is not connected.") else: if not nx.is_connected(G): raise nx.NetworkXError("Graph is not connected.") avg=0.0 if weight is None: for node in G: path_length=nx.single_source_shortest_path_length(G, node) avg += sum(path_length.values()) else: for node in G: path_length=nx.single_source_dijkstra_path_length(G, node, weight=weight) avg += sum(path_length.values()) n=len(G) return avg/(n*(n-1))
def getEdgeDepthMap(og): """returns the depth of each edge measured by the first node in the edge""" depthMap = nx.single_source_shortest_path_length(og,og.graph['root']) edgeDepthMap = [] for e in og.edges(): edgeDepthMap.append((depthMap[e[0]],(e[0],e[1]))) edgeDepthMap.sort() return edgeDepthMap
def get_Neib_one(self,ipt,l): nei=nx.single_source_shortest_path_length(self.G,ipt,cutoff=l) NB={} for key,value in nei.iteritems(): NB.setdefault(value,set()).add(key) NB.setdefault('AllNb',set()).add(key) return NB
def addDistDAttr(dag, d='Dst'): dag.reverse(copy=False) distD = nx.single_source_shortest_path_length(dag, d) for v in dag.nodes(): dag.add_node(v, distD=distD.get(v, NaN)) pass dag.reverse(copy=False) return
def efficiency(G): avg = 0.0 n = len(G) for node in G: path_length = nx.single_source_shortest_path_length(G, node) avg += sum(1.0/v for v in path_length.values() if v !=0) avg *= 1.0/(n*(n-1)) return avg
def shortest_path_test(vertices): """Computes the single-source shortest path using NetworkX.""" G = nx.DiGraph() for u in vertices: for v in u.out_vertices: G.add_edge(u.id, v.id) sp = nx.single_source_shortest_path_length(G, source) return sp
def eccentricity(G, v=None, sp=None): """Return the eccentricity of nodes in G. The eccentricity of a node v is the maximum distance from v to all other nodes in G. Parameters ---------- G : NetworkX graph A graph v : node, optional Return value of specified node sp : dict of dicts, optional All pairs shortest path lengths as a dictionary of dictionaries Returns ------- ecc : dictionary A dictionary of eccentricity values keyed by node. """ # nodes= # nodes=[] # if v is None: # none, use entire graph # nodes=G.nodes() # elif v in G: # is v a single node # nodes=[v] # else: # assume v is a container of nodes # nodes=v order=G.order() e={} for n in G.nbunch_iter(v): if sp is None: length = dict(networkx.single_source_shortest_path_length(G, n)) L = len(length) else: try: length = sp[n] L = len(length) except TypeError: raise networkx.NetworkXError('Format of "sp" is invalid.') if L != order: if G.is_directed(): msg = ('Found infinite path length because the digraph is not' ' strongly connected') else: msg = ('Found infinite path length because the graph is not' ' connected') raise networkx.NetworkXError(msg) e[n]=max(length.values()) if v in G: return e[v] # return single value else: return e
def check_path(g, source, dists, followers): nodes = nx.single_source_shortest_path_length(g,source,2) count = 0 for n in nodes.iterkeys(): if n in followers and n in dists and dists[n] <= 4: count += 1 return count
def test_shortest_path(self): deg = [3, 2, 2, 1] G = nx.generators.havel_hakimi_graph(deg) cs1 = nxt.creation_sequence(deg, with_labels=True) for n, m in [(3, 0), (0, 3), (0, 2), (0, 1), (1, 3), (3, 1), (1, 2), (2, 3)]: assert_equal(nxt.shortest_path(cs1, n, m), nx.shortest_path(G, n, m)) spl = nxt.shortest_path_length(cs1, 3) spl2 = nxt.shortest_path_length([t for v, t in cs1], 2) assert_equal(spl, spl2) spld = {} for j, pl in enumerate(spl): n = cs1[j][0] spld[n] = pl assert_equal(spld, nx.single_source_shortest_path_length(G, 3))
def dF_with_distance(G, src_a=None, src_b=None): allnodes = G.nodes() shortest_pathlengths = nx.single_source_shortest_path_length(G, src_a) shortest_pathlengths_ordered = [ shortest_pathlengths[node] for node in allnodes ] source_vector = csr_matrix((G.number_of_nodes(), 1)) src_a_ind = allnodes.index(src_a) source_vector[src_a_ind] = 1 if src_b: src_b_ind = allnodes.index(src_b) if src_b else None source_vector[src_b_ind] = -1 return shortest_pathlengths_ordered, solve(G.loopy_laplacian(), source_vector)
def display_node_attributes(node): """Accepts a node, calculates various attributes, and formats it into a string""" text = G[node]["name"] if hasattr(G[node], "name") else "Node: " + str(node) if nx.is_directed(G): text += ", In Degree: " + str(G.in_degree[node]) text += ", Out Degree: " + str(G.out_degree[node]) else: text += "Degree: " + str(G.degree[node]) eccentricity = max(nx.single_source_shortest_path_length(G, node)) text += ", Ecentricity: " + str(eccentricity) if nx.is_directed(G): text += ", Reciprocity: {:.2f}".format(reciprocities[node]) return text
def __compute_depth(self, df): self.logger.step_start('Compute depth...') df = df.sort_values(by=['cascade_id', 'new_tid']) all_depths = [] for cid in df.cascade_id.unique(): cascade = df[df['cascade_id'] == cid] g = nx.DiGraph() g.add_nodes_from(cascade.new_tid.values) g.add_edges_from([ (u, v) for u, v in zip(cascade.new_parent_tid, cascade.new_tid) ][1:]) depths = nx.single_source_shortest_path_length(g, 0) all_depths += [v for _, v in sorted(depths.items())] df['depth'] = all_depths self.logger.step_end() return df
def _recalc(self): """ Обходит граф, считая максимальные длины путей в центральную вершину и из неё. """ path_down = nx.single_source_shortest_path_length(self.nx_graph, self.pov_id) path_up = dict(nx.single_target_shortest_path_length(self.nx_graph, self.pov_id)) self.levels_down = max([length for length in path_down.values()]) self.levels_up = max([length for length in path_up.values()]) # поиск вершин без потомков for node in self.nx_graph.node: self.nx_graph.node[node]["is_blind"] = (not list(self.nx_graph.successors(node))) # поиск циклов, проходящих через точку отсчёта cycles = simple_cycles(self.nx_graph) cycles = list(filter(lambda cycle: self.pov_id in cycle, cycles)) for node in set([node for cycle in cycles for node in cycle]): self[node]["in_cycle"] = True
def setup_graph(self): color_map = [] self.base_stations = np.reshape(self.base_stations, (self.no_of_stations, 2)) dist = cdist(self.base_stations, self.base_stations, metric="euclidean") for i in range(self.no_of_stations): self.G.add_node(i, **{'MEC': self.if_mec[i]}) if self.if_mec[i] == "yes": color_map.append("green") else: color_map.append("red") for i in range(self.no_of_stations): for j in range(i + 1, self.no_of_stations): self.G.add_edge(i, j, weight=dist[i][j]) self.T = nx.minimum_spanning_tree(self.G) for i in range(self.no_of_stations): for j in range(self.no_of_stations): self.hop_to_hop[i][j] = len( nx.shortest_path(self.T, source=i, target=j)) - 1 edges = list(self.T.edges(data=True)) #nx.draw_networkx(self.T,self.pos_loc, node_color=color_map,with_labels=True, node_size = 500) self.hop_dist = defaultdict(list) for i in range(self.no_of_stations): for j in range(self.no_of_stations): x = nx.single_source_shortest_path_length(self.T, i, cutoff=j) x = [k for k, v in x.items() if v == j] self.hop_dist[tuple((i, j))] = x X = self.T.copy() x = 50 for i in range(len(self.usercoordinates)): if i % 2 == 0: X.add_node(x, pos=(self.usercoordinates[i], self.usercoordinates[i + 1])) color_map.append("blue") x += 1 pos = nx.get_node_attributes(X, 'pos') self.pos_loc.update(pos)
def calculate_graph_stats(): print('Calculating Graph Stats') pathlengths.clear() loads.clear() loadids.clear() for v in G.nodes(): if existing[v]: spl = dict(nx.single_source_shortest_path_length(G, v)) # print('*', v, " = ", end='') top = 0 cnt = 0 for p in spl: top += spl[p] cnt += 1 pathlengths.append(spl[p]) avgSP = top / cnt # print(top, " > ", avgSP) loads.append(10000 if avgSP == 0 else avgSP) loadids.append(v) else: loads.append(20000) loadids.append(v) print('') if (len(pathlengths) > 0): print("average load %s" % (sum(pathlengths) / len(pathlengths))) avgLoad[0] = sum(pathlengths) / len(pathlengths) print("minimum load %s" % (min(loads))) print("density: %s" % nx.density(G)) dist.clear() for p in pathlengths: if p in dist: dist[p] += 1 else: dist[p] = 1 print('') if (len(dist) > 0): print("length #paths") verts = dist.keys() for d in sorted(verts): print('%s %d' % (d, dist[d]))
def compute_candidate_paths(self, hops, min_pivot, bad_neighbors): # Get the feasible candidate paths # print('hops',hops,'min_pivot',min_pivot) all_paths = nx.single_source_shortest_path_length(self.graph, min_pivot, cutoff=hops) # print('all paths before',all_paths) all_paths = [(k,v) for k,v in all_paths.items() if v == hops] # print('all paths',all_paths) # print('bad neighbors',bad_neighbors) # Prune out those passing through bad neighbors feasible_paths = [] for candidate in all_paths: path = nx.shortest_path(self.graph, candidate[0], min_pivot) if path[-2] not in bad_neighbors: feasible_paths += [path] return feasible_paths
def ComputeLookahead(self): """Computes a basic block lookahead map for all bbls.""" self._ComposeInterProceduralCFG() logging.info('Reversing computed Interprocedural CFG ...') ipcfg_reverse = self._ipcfg.reverse(copy=True) logging.info('Computing shortest paths from each packet send site ...') for pkt_send_bbl_entry_node in self._packet_send_bbl_entry_nodes: length = nx.single_source_shortest_path_length( ipcfg_reverse, pkt_send_bbl_entry_node) for reachable_node in length: if (not re.match('__BBL_([0-9]+)_ENTRY', reachable_node) or length[reachable_node] < 0): continue self._bbl_lookahead[reachable_node] = \ min(self._bbl_lookahead[reachable_node], length[reachable_node]) logging.info('Lookahead computation completed for %d basic blocks ', len(self._bbl_lookahead))
def G_features(G, time): # section a is closeness centrality and b is betweenes centrality g_t = create_unweighted_G_t(G.train, 0) biggest_scc = g_t.subgraph(max(nx.strongly_connected_components(g_t), key=len)) a_dict = {} b_dict = dict.fromkeys(biggest_scc, 0.0) size = biggest_scc.number_of_nodes() reversed_scc = biggest_scc.reverse() for node in reversed_scc.nodes(): a_dict[node] = (size - 1) / sum(nx.single_source_shortest_path_length(reversed_scc,node).values()) for node in biggest_scc.nodes() : nodes_queue, predecessors, number_of_shortest_paths = BFS_With_Shortest_Paths(biggest_scc, node) b_dict = update_betweenness(b_dict, nodes_queue, predecessors, number_of_shortest_paths, node) for node in biggest_scc.nodes() : b_dict[node] = b_dict[node] * (1 / ((size - 1) * (size -2))) return {'a': a_dict, 'b': b_dict }
def __call__(self, data, root_idx=None): num_atoms = data.x.size()[0] G = graph_data_obj_to_nx(data) if root_idx is None: if self.center is True: root_idx = data.center_node_idx.item() else: root_idx = random.sample(range(num_atoms), 1)[0] # in the PPI case, the subgraph is the entire PPI graph data.x_substruct = data.x data.edge_attr_substruct = data.edge_attr data.edge_index_substruct = data.edge_index data.center_substruct_idx = data.center_node_idx # Get context that is between l1 and the max diameter of the PPI graph l1_node_idxes = nx.single_source_shortest_path_length(G, root_idx, self.l1).keys() # l2_node_idxes = nx.single_source_shortest_path_length(G, root_idx, # self.l2).keys() l2_node_idxes = range(num_atoms) context_node_idxes = set(l1_node_idxes).symmetric_difference(set(l2_node_idxes)) if len(context_node_idxes) > 0: context_G = G.subgraph(context_node_idxes) context_G, context_node_map = reset_idxes(context_G) # need to # reset node idx to 0 -> num_nodes - 1, other data obj does not # make sense context_data = nx_to_graph_data_obj(context_G, 0) # use a dummy # center node idx data.x_context = context_data.x data.edge_attr_context = context_data.edge_attr data.edge_index_context = context_data.edge_index # Get indices of overlapping nodes between substruct and context, # WRT context ordering context_substruct_overlap_idxes = list(context_node_idxes) if len(context_substruct_overlap_idxes) > 0: context_substruct_overlap_idxes_reorder = [ context_node_map[old_idx] for old_idx in context_substruct_overlap_idxes ] data.overlap_context_substruct_idx = torch.tensor(context_substruct_overlap_idxes_reorder) return data
def get_distance_distribution(network, n_process=4): # n_nodes = network.num_vertices() n_nodes = len(network) # n_edges = network.num_edges() n_edges = network.number_of_edges() vertices = list(network.nodes()) l = len(vertices) distance_distribution = {} # if n_nodes > 10000 or n_edges > 500000: # return None for i in range(1, len(vertices)): v = vertices[i] v_id = int(v) # distance_map = topology.shortest_distance( # network, # source=v, # target=None, # directed=False # ) # distance_map = nx.shortest_path(network, source=v, target=None, weight=None) distance_map = nx.single_source_shortest_path_length(network, source=v) # distance_map = nx.all_pairs_shortest_path_length(network) # distance_array = distance_map.get_array()[v_id:] # distance_array = distance_map.ToArray() # for j in np.nditer(distance_array): # for j in distance_map.items(): for key, value in distance_map.items(): # distance = int(j) distancewithsq = distance_map[key] distance = int(distancewithsq) if distance not in distance_distribution: distance_distribution[distance] = 0 # distance_distribution.insert(distance, 0) distance_distribution[distance] += 1 return distance_distribution
def cool_plot(G_temp): G = [] G = G_temp ncenter = 5 p = dict(nx.single_source_shortest_path_length(G, ncenter)) plt.figure(figsize=(8, 8)) nx.draw_networkx_edges(G, pos, nodelist=[ncenter], alpha=0.4) nx.draw_networkx_nodes(G, pos, nodelist=list(p.keys()), node_size=80, node_color=list(p.values()), cmap=plt.cm.Reds_r) plt.xlim(-0.05, 1.05) plt.ylim(-0.05, 1.05) plt.axis('off') plt.show()
def _get_hard_negative_path(self, scan_id, path): """ Create a negative path that starts along the path then goes to a random neighbor.""" g, d = self._graphs[scan_id], self._distances[scan_id] offset = np.random.randint(1, len(path) - 1) source, goal = path[offset], path[-1] # get valid neighbors within 4 and 6 hops and greater than 3m from the goal max_hops, min_hops, min_distance = 6 - offset, 4 - offset, 3 neighbors = nx.single_source_shortest_path_length(g, source, cutoff=max_hops) neighbors = [k for k, v in neighbors.items() if v >= min_hops] valid = [node for node in neighbors if d[goal][node] > min_distance] if len(valid) == 0: return # return the shortest path to a random negative target viewpoint negative = np.random.choice(valid) return path[:offset] + nx.dijkstra_path(g, source, negative)
def EfficiencyComputation(InputGraph): G=InputGraph.copy() N=G.order() vertexlist=G.nodes() EfficiencySum=0.0 for current_vertex in vertexlist: print 'current_vertex:',current_vertex CurrentVertexDistanceList=list(nx.single_source_shortest_path_length(G,current_vertex).values()) print 'CurrentVertexDistanceList:',CurrentVertexDistanceList InverseDistanceList=ElementwiseInvertList(CurrentVertexDistanceList) print 'InverseDistanceList:',InverseDistanceList EfficiencySum+=sum(InverseDistanceList) print 'EfficiencySum:',EfficiencySum print '------------------------' AverageEfficiency=(1.0*EfficiencySum)/(N*(N-1)) return AverageEfficiency
def path_length_distribution(H): """ Estimates shortest path length distribution between all node pairs. If the graph is not connected it uses the giant component instead. Parameters: G (NetworkX graph object): graph to estimate on. Returns: shortest path distribution (dict): keys are mean path length, median path length, std path length, skw path length, kurtosis path length """ G = H.copy() if not is_connected(H): print("graph is not connected, GC will be used instead") #use largest connected component #G = sorted(nx.connected_components(G), key=len, reverse=True) Gcc = sorted(nx.connected_components(G), key=len, reverse=True) G = G.subgraph(Gcc[0]) pathlengths = [] for v in G.nodes(): spl = dict(nx.single_source_shortest_path_length(G, v)) for p in spl: pathlengths.append(spl[p]) avg_path_length = (sum(pathlengths) / len(pathlengths)) median_path = statistics.median(pathlengths) std_path = statistics.stdev(pathlengths) skw_path = skew(pathlengths) kurt_path = kurtosis(pathlengths) return { "mean path length": avg_path_length, "median path length": median_path, "std path length": std_path, "skw path length": skw_path, "kurtosis path length": kurt_path }
def Verification(G_last_snapshot, G_current_snapshot, degree): #print "%d edges in G_last_snapshot" %(len(G_last_snapshot.edges())) #print "%d edges in G_current_snapshot" %(len(G_current_snapshot.edges())) #print "%d nodes in G_last_snapshot" %(len(G_last_snapshot.nodes())) #print "%d nodes in G_current_snapshot" %(len(G_current_snapshot.nodes())) for node in G_current_snapshot.nodes(): realistic_degree = len(nx.single_source_shortest_path_length(G_current_snapshot, node, 2)) - 1 record_degree = degree[node] if (record_degree != realistic_degree): print "now we check node %d, record_degree = %d, realistic_degree = %d" %(node, record_degree, realistic_degree) time.sleep(1000) return 0 print "every thing is OK!" return 1
def connected_components(G): """ Return a list of lists of nodes in each connected component of G. The list is ordered from largest connected component to smallest. For undirected graphs only. """ if G.is_directed(): raise networkx.NetworkXError,\ """Not allowed for directed graph G. Use UG=G.to_undirected() to create an undirected graph.""" seen = {} components = [] for v in G: if v not in seen: c = single_source_shortest_path_length(G, v) components.append(c.keys()) seen.update(c) components.sort(lambda x, y: cmp(len(y), len(x))) return components
def count_parameters(G): graph_parameters = [] N = nx.number_of_nodes(G) # print(N) nodes = nx.nodes(G) for i in nodes: deg = nx.degree(G, i) # if Sp=0, then the SP doesn't exist SP = nx.single_source_shortest_path_length(G, i) sum_SP = 0 Ecc = 0 for j in SP: if SP[j] > Ecc: Ecc = SP[j] sum_SP = sum_SP + SP[j] param = [i, deg, sum_SP, Ecc] graph_parameters.append(param) return graph_parameters
def average_all_pairs_shortest_path_estimate(G, max_num_sources=100): if nx.number_connected_components(G)>1: return METRIC_ERROR num_sources = min(G.number_of_nodes(), max_num_sources) baseline_sources = [] if hasattr(G, '_musketeer_data'): if 'all_pairs_shortest_path_estimate_SOURCES' in G._musketeer_data: baseline_sources = G._musketeer_data['all_pairs_shortest_path_estimate_SOURCES'] baseline_sources = filter(lambda s: s in G, baseline_sources) else: G._musketeer_data = {} sampled_sources = baseline_sources + random.sample(G.nodes(), num_sources - len(baseline_sources)) G._musketeer_data['all_pairs_shortest_path_estimate_SOURCES'] = sampled_sources total_distance = 0.0 for source in sampled_sources: lengths = nx.single_source_shortest_path_length(G, source) total_distance += np.average(lengths.values()) total_distance /= num_sources return total_distance
def n_closure(work_author_dict, coauthor_graph, n=2): if n < 1: raise AttributeError('cannot have `n` < 1') if n == 1: return work_author_dict work_n_closure_dict = {} for work, authors in work_author_dict.items(): n_auths = set() for author in authors: n_auths.add(author) if coauthor_graph.has_node(author): if n == 2: for neighbor in coauthor_graph.neighbors(author): n_auths.add(neighbor) else: for neighbor, l in nx.single_source_shortest_path_length(coauthor_graph, author, cutoff=n).items(): if l > 1 and l <= n: n_auths.add(neighbor) work_n_closure_dict[work] = list(n_auths) return work_n_closure_dict
def harm_cent(graph): shortest_paths = { } # Dictionary for storing the shortest paths from each vertex harmonic_centralities = { } # Dictionary for storing the harmonic centralities sum_of_geodesics = 0 for k in graph.nodes(): # Iterating through each node shortest_paths = nx.single_source_shortest_path_length(graph, k) # Fidning the SSSP length from each node to all other nodes sum_of_geodesics = sum(shortest_paths.values()) / (total_vertices - 1) # Summing over all the geodesics for each source vertex harmonic_centralities[k] = sum_of_geodesics # Storing the harmonic centrality for each node shortest_paths = {} sorted_harmonics = sorted(harmonic_centralities.items(), key=operator.itemgetter(1)) # Sorting the harmonic centralities in decreasing order of importance return sorted_harmonics
def _rigid_mode(self, mode): """Compute an eigenmode for the system given a rigid-body constraint""" # Fill mode with available values from the selected eigenvector of # the Hessian arr = np.zeros((self._top.n_atoms, 3)) arr[self._ind, :] = np.reshape(self.eigenvectors_[:, mode], (self.n_atoms_, 3)) # Initialize graph of bonded atoms G = nx.Graph([(i.index, j.index) for i, j in self._top.bonds]) # For each non-selected atom search the graph for the nearest bonded # atom that has been selected and have the query atom inherit its # gradient for i in (set(range(self._top.n_atoms)) - set(self._ind)): path_lengths = nx.single_source_shortest_path_length(G, i) d = np.array(list(path_lengths.values()))[self._ind] arr[i, :] = arr[np.argmin(d), :] return arr
def show_geo_graph(graph): node_position = nx.get_node_attributes(graph, 'pos') # Find node near center (0.5,0.5) d_min = 1 node_near_center = 0 for node in node_position: x, y = node_position[node] distance = (x - 0.5)**2 + (y - 0.5)**2 if distance < d_min: node_near_center = node d_min = distance # Color by path length from node near center color_node = dict( nx.single_source_shortest_path_length(graph, node_near_center)) array_color_node = np.array(list(color_node.values())) sns.set_style('darkgrid') cmap = sns.cubehelix_palette(start=.5, rot=-.65, dark=.4, light=.6, as_cmap=True) plt.figure(figsize=(10, 8)) nx.draw_networkx_edges(graph, node_position, nodelist=[node_near_center], alpha=0.4) nx.draw_networkx_nodes(graph, node_position, nodelist=color_node.keys(), node_size=80, node_color=array_color_node, cmap=cmap) plt.xlim(0, 1) plt.ylim(0, 1) plt.axis('off') file = str(graph_path) + "/graph.pdf" plt.savefig(file, transparent=True)
def main(): read_files() print(sp.artist((get_artist_id(ARTISTS[0]))).keys()) for artist_name in ARTISTS: artist_id = get_artist_id(artist_name) artist = sp.artist(artist_id) print(artist["name"], artist["popularity"], artist["genres"]) dash_size = 50 print("=" * dash_size) time(construct_graph) print("=" * dash_size) print(len(G), "rappers included.\n" + "=" * dash_size) yt = "Young Thug" for comp in nx.connected_components(G): if len(comp) == 1: continue s = G.subgraph(comp) print("eccentricity:\n", nx.eccentricity(s)) c = nx.center(s) print("center:\n", c) dists = nx.single_source_shortest_path_length(G, yt if yt in c else c[0]) print("distributions of distance:") freq = {} for _, d in dists.items(): if d not in freq: freq[d] = 0 freq[d] += 1 print(freq) print("distance from center:\n", dists) print("-" * dash_size) vis_graph()
def average_shortest_path_len(G): #return nx.average_shortest_path_length(G) if G.is_directed(): if not nx.is_weakly_connected(G): raise nx.NetworkXError("Graph is not connected.") else: if not nx.is_connected(G): raise nx.NetworkXError("Graph is not connected.") avg = 0.0 for node in G: path_length = nx.single_source_shortest_path_length(G, node) avg += sum(path_length.values()) #if node % 100 == 0: #print(node) n = len(G) return avg/(n*(n-1))
def plot_nests(nests): g = nx.DiGraph(nests) root = [n for n in g.nodes if g.in_degree(n) == 0][0] lengths = nx.single_source_shortest_path_length(g, root) pos = {} levels = [0] * (max(lengths.values()) + 1) for key, x in lengths.items(): pos[key] = [levels[x], -x] levels[x] += 1 plot = nx.draw(g, pos=pos, node_color='white', alpha=1, node_size=1000, arrows=False, edge_color='green', font_size=15, font_weight='normal', labels={k: k for k in g.nodes}) return plot
def get_subgraph (self, search_term, radius): """ use BFS to label nodes as part of a 'neighborhood' subgraph """ subgraph = set([]) paths = {} the_node_id = None for node_id, label in self.labels.items(): if label == search_term: the_node_id = node_id r = nx.bfs_edges(self.nxg, source=node_id, depth_limit=radius) subgraph = set([node_id]) for _, neighbor in r: subgraph.add(neighbor) paths = nx.single_source_shortest_path_length(self.nxg, node_id, cutoff=radius) break return subgraph, paths, str(the_node_id)
def __init__(self, map: dict, should_display: bool = True): nx.Graph.__init__(self) for site in map["sites"]: # populate sites in main graph self.add_node(site["id"]) self.node[site["id"]]["site"] = Site(site["id"], site["x"], site["y"]) self.add_edges_from([ (river["source"], river["target"]) for river in map["rivers"] ]) # populate edges in main graph self.mines = map["mines"] # get mines in self.mines for mine in self.mines: # add mines to main graph self.node[mine]["site"].isMine = True for mine in self.mines: # precalculate score for all site and all mines as it is static list = nx.single_source_shortest_path_length( self, mine) # get the path to the mine indexed by node nx.set_node_attributes(self, "pathForMine_" + str(mine), list) # set the attributes self.should_display = should_display if self.should_display: self.fig = plt.figure(figsize=(10, 30)) # initialize graphics
def networkx_call(M, source, edgevals=False): # Directed NetworkX graph Gnx = nx.from_pandas_edgelist(M, source='0', target='1', edge_attr='weight', create_using=nx.DiGraph()) print('NX Solving... ') t1 = time.time() if edgevals is False: path = nx.single_source_shortest_path_length(Gnx, source) else: path = nx.single_source_dijkstra_path_length(Gnx, source) t2 = time.time() - t1 print('NX Time : ' + str(t2)) return path, Gnx