def _edge_betweenness(G, source, nodes, cutoff=False): """ Edge betweenness helper. """ between = {} # get the predecessor data #(pred,length)=_fast_predecessor(G,source,cutoff=cutoff) (pred, length) = predecessor(G, source, cutoff=cutoff, return_seen=True) # order the nodes by path length onodes = [ nn for dd, nn in sorted((dist, n) for n, dist in length.iteritems()) ] # intialize betweenness, doesn't account for any edge weights for u, v in G.edges(nodes): between[(u, v)] = 1.0 between[(v, u)] = 1.0 while onodes: # work through all paths v = onodes.pop() if v in pred: num_paths = len(pred[v]) # Discount betweenness if more than for w in pred[v]: # one shortest path. if w in pred: num_paths = len(pred[w]) # Discount betweenness, mult path for x in pred[w]: between[(w, x)] += between[(v, w)] / num_paths between[(x, w)] += between[(w, v)] / num_paths return between
def _edge_betweenness(G,source,nodes,cutoff=False): """ Edge betweenness helper. """ between={} # get the predecessor data #(pred,length)=_fast_predecessor(G,source,cutoff=cutoff) (pred,length)=predecessor(G,source,cutoff=cutoff,return_seen=True) # order the nodes by path length onodes = [ nn for dd,nn in sorted( (dist,n) for n,dist in length.iteritems() )] # intialize betweenness, doesn't account for any edge weights for u,v in G.edges(nodes): between[(u,v)]=1.0 between[(v,u)]=1.0 while onodes: # work through all paths v=onodes.pop() if v in pred: num_paths=len(pred[v]) # Discount betweenness if more than for w in pred[v]: # one shortest path. if w in pred: num_paths=len(pred[w]) # Discount betweenness, mult path for x in pred[w]: between[(w,x)]+=between[(v,w)]/num_paths between[(x,w)]+=between[(w,v)]/num_paths return between
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) = dijkstra_predecessor_and_distance(G, source) else: (pred, length) = 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 _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)=dijkstra_predecessor_and_distance(G,source) else: (pred,length)=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