def gen_bonded_tuples(g, num, bond_pair):
"""Generates tuples of different size, based on the graph and input edge.
Args:
g: The networkx Graph object.
num: The length of the tuple.
bond_pair: The edge which has to be included in all tuples.
Returns:
The set of all tuples of defined length from graph `g`.
"""
b0, b1 = bond_pair
paths = []
if num > 3:
for nb0 in g[b0]:
paths.extend(nx.single_source_shortest_path(g, nb0, num-1).values())
for nb1 in g[b1]:
paths.extend(nx.single_source_shortest_path(g, nb1, num-1).values())
paths.extend(nx.single_source_shortest_path(g, b0, num-1).values())
paths.extend(nx.single_source_shortest_path(g, b1, num-1).values())
output = set()
for b in paths:
if len(b) == num and b0 in b and b1 in b:
if tuple(reversed(b)) not in output:
output.add(tuple(b))
return output
def test_single_source_shortest_path(self):
p = nx.single_source_shortest_path(self.directed_cycle, 3)
assert_equal(p[0], [3, 4, 5, 6, 0])
p = nx.single_source_shortest_path(self.cycle, 0)
assert_equal(p[3], [0, 1, 2, 3])
p = nx.single_source_shortest_path(self.cycle, 0, cutoff=0)
assert_equal(p, {0: [0]})
def test_single_source_shortest_path(self):
p = nx.single_source_shortest_path(self.directed_cycle, 3)
assert p[0] == [3, 4, 5, 6, 0]
p = nx.single_source_shortest_path(self.cycle, 0)
assert p[3] == [0, 1, 2, 3]
p = nx.single_source_shortest_path(self.cycle, 0, cutoff=0)
assert p == {0: [0]}
def get_upstream_reaches(self, outlet_reach, broken_at_gages=True):
"""Returns the comIDs of the upstream reaches for a given reach.
If no comID is specified, then all reaches in the network are
returned."""
if broken_at_gages == True:
return single_source_shortest_path(self._g_rev, outlet_reach)
else:
return single_source_shortest_path(self._g_unbroken_reverse, outlet_reach)
def create_transaction_list(self, numTransactions, transList):
numNodes = len(self.graph.nodes())
time = 0
tList = []
if (self.model == "LN"):
lowDegreeTransaction = int(numTransactions / 2)
midDegreeTransaction = int(numTransactions / 3)
highDegreeTransaction = int(numTransactions / 9)
elif (self.model == "XRP"):
lowDegreeTransaction = int(numTransactions / 3)
midDegreeTransaction = int(numTransactions / 3)
highDegreeTransaction = int(numTransactions / 3)
for x in range(0, lowDegreeTransaction):
node = int(random.randint(0, len(self.lowDegreeNodeList) - 1))
hop_count = random.randint(1, 4)
paths = (nx.single_source_shortest_path(self.graph, 3))
path_with_hop_count = []
for key in paths.keys():
if (hop_count == len(paths[key])):
path_with_hop_count.append(int(key))
destIndex = random.randint(0, len(path_with_hop_count) - 1)
dest = path_with_hop_count[destIndex]
tList.append((node, dest, self.create_transaction_amount(0)))
for x in range(0, midDegreeTransaction):
node = int(random.randint(0, len(self.midDegreeNodeList) - 1))
hop_count = random.randint(1, 4)
paths = (nx.single_source_shortest_path(self.graph, 3))
path_with_hop_count = []
for key in paths.keys():
if (hop_count == len(paths[key])):
path_with_hop_count.append(int(key))
destIndex = random.randint(0, len(path_with_hop_count) - 1)
dest = path_with_hop_count[destIndex]
tList.append((node, dest, self.create_transaction_amount(1)))
for x in range(0, highDegreeTransaction):
node = int(random.randint(0, len(self.highDegreeNodeList) - 1))
hop_count = random.randint(1, 4)
paths = (nx.single_source_shortest_path(self.graph, 3))
path_with_hop_count = []
for key in paths.keys():
if (hop_count == len(paths[key])):
path_with_hop_count.append(int(key))
destIndex = random.randint(0, len(path_with_hop_count) - 1)
dest = path_with_hop_count[destIndex]
tList.append((node, dest, self.create_transaction_amount(2)))
time = 0
elements = len(tList)
for x in range(0, elements):
tranI = random.randint(0, len(tList) - 1)
transList.append(
(time, tList[tranI][0], tList[tranI][1], tList[tranI][2]))
time = time + random.uniform(0, 5)
def m_reaching_centrality(graph, m=None, direction=None):
'''
The network must be connected.
The local reaching centrality (LRC) of a node is
the proportion of the nodes that could be reached from a given node
and the number of nodes in the network minus 1.
The m-LRC is a cutoff after the n-th step from the given node.
Parameters:
----------
graph: networkx object, must be connected
m : cutoff after n step distance
direction: (None|"in"|"out") A node could reach another one only through in- or out-edge,
or both of them, if the network is undirected.
Returns:
-------
reaches: Dict of nodes with LRC values.
'''
# if not nx.is_connected(graph):# it works only on undirected graphs
# print('Graph must be connected.')
# return {}
nr_nodes = graph.number_of_nodes()
if direction == None:
graph = graph.copy()
graph = graph.to_undirected()
reaches = [
(len(nx.single_source_shortest_path(graph, n, cutoff=m)) - 1) /
(nr_nodes - 1) for n in graph.nodes()
]
elif direction == 'in':
graph = graph.copy()
graph = graph.reverse()
reaches = [
(len(nx.single_source_shortest_path(graph, n, cutoff=m)) - 1) /
(nr_nodes - 1) for n in graph.nodes()
]
elif direction == 'out':
reaches = [
(len(nx.single_source_shortest_path(graph, n, cutoff=m)) - 1) /
(nr_nodes - 1) for n in graph.nodes()
]
else:
print('Direction format is not correct.')
return dict(zip(graph.nodes(), reaches))
def get_upstream_reaches(self, outlet_reach, broken_at_gages=True):
"""Returns the comIDs of the upstream reaches for a given reach.
If no comID is specified, then all reaches in the network are
returned."""
if broken_at_gages == True:
return single_source_shortest_path(self._g_rev, outlet_reach)
else:
return single_source_shortest_path(self._g_unbroken_reverse,
outlet_reach)
def neighbor_overlap_orderK(G,node1,node2,k):
nei1=nx.single_source_shortest_path(G,node1,cutoff=k).keys()
nei2=nx.single_source_shortest_path(G,node2,cutoff=k).keys()
# return (x1, x2)
# where x1 = the number of overlapped neighboring nodes
# and x2 = the number of overlapped neighboring nodes / the number of union(two neighborhood nodes)
shared_neighbor=set(nei1).intersection(set(nei2))
unioned_neighbor=set(nei1).union(set(nei2))
return (len(shared_neighbor),float(len(shared_neighbor))/float(len(unioned_neighbor)))
def edge_parent_finder(abstract, graph):
'''
moved this here since i think that it is forgi specific
'''
# find out to which abstract node the edges belong
# finding out where the edge-nodes belong, because the contractor cant possibly do this
# draw.graphlearn_draw([abstract,graph],size=10, contract=False,vertex_label='id')
getabstr = {
contra: node
for node, d in abstract.nodes(data=True)
for contra in d.get('contracted', [])
}
# print getabstr
for n, d in graph.nodes(data=True):
if 'edge' in d:
# if we have found an edge node...
# lets see whos left and right of it:
# if len is 2 then we hit a basepair, in that case we already have both neighbors
zomg = graph.neighbors(n)
if len(zomg) == 1:
zomg += graph.predecessors(n)
n1, n2 = zomg
# case1: ok those belong to the same gang so we most likely also belong there.
if getabstr[n1] == getabstr[n2]:
abstract.node[getabstr[n1]]['contracted'].add(n)
# case2: neighbors belong to different gangs...
else:
abstract_intersect = set(abstract.neighbors(getabstr[n1])) & \
set(abstract.neighbors(getabstr[n2]))
# case 3: abstract intersect in radius 1 failed, so lets try radius 2
if not abstract_intersect:
abstract_intersect = set(
nx.single_source_shortest_path(
abstract, getabstr[n1], 2)) & set(
nx.single_source_shortest_path(
abstract, getabstr[n2], 2))
if len(abstract_intersect) > 1:
print("weired abs intersect...")
for ai_node in abstract_intersect:
if 'contracted' in abstract.node[ai_node]:
abstract.node[ai_node]['contracted'].add(n)
else:
abstract.node[ai_node]['contracted'] = set([n])
return abstract
def my_shortest_path(G,
source=None,
target=None,
weight=None,
orient=None,
stop_pt=None):
if source is None:
if target is None:
## Find paths between all pairs.
if weight is None:
paths = nx.all_pairs_shortest_path(G)
else:
paths = nx.all_pairs_dijkstra_path(G, weight=weight)
else:
## Find paths from all nodes co-accessible to the target.
with nx.utils.reversed(G):
if weight is None:
paths = nx.single_source_shortest_path(G, target)
else:
paths = nx.single_source_dijkstra_path(G,
target,
weight=weight)
# Now flip the paths so they go from a source to the target.
for target in paths:
paths[target] = list(reversed(paths[target]))
else:
if target is None:
## Find paths to all nodes accessible from the source.
if weight is None:
paths = nx.single_source_shortest_path(G, source)
else:
paths = nx.single_source_dijkstra_path(G,
source,
weight=weight)
else:
## Find shortest source-target path.
if weight is None:
paths = nx.bidirectional_shortest_path(G, source, target)
else:
if orient is None:
paths = nx.dijkstra_path(G, source, target, weight)
else:
paths = my_dijkstra_path(G,
source,
target,
weight,
orient=orient,
stop_pt=stop_pt)
return paths
def _construct_k_neighborhood(self, k: int, G: Graph):
'''
Função que constrói todas as k-vizinhanças dos vértices defendidos na
solução.
Args:
k (int): profundidade da vizinhança.
G (Graph): o grafo de entrada.
'''
# Conjunto de todas as k-vizinhanças
kn = set()
for d in self.defended:
kn.update(
# Menores caminhos de profundidade k (as chaves retornam os
# destinos)
v_n for v_n in list(single_source_shortest_path(G, d, k)
.keys())
# Ignorar vértices defendidos
if v_n not in self.defended
)
self.kn = kn
def nearest(source, bibles_only=True):
#select graph
if bibles_only:
tree = bib_tree
else:
tree = full_tree
#get a directed tree to find the leaves (the other viable ISO codes)
dG = nx.dfs_tree(tree, 'ROOT')
leaves = [
node for node in dG.nodes()
if dG.in_degree(node) != 0 and dG.out_degree(node) == 0
]
leaves.remove(source)
#find the distance to all other nodes from the rouce
spaths = nx.single_source_shortest_path(tree, source)
#check which of the leaves is the best
bestd = len(spaths[leaves[0]])
best = leaves[0]
for l in leaves:
ld = len(spaths[l])
if ld < bestd:
bestd = ld
best = l
return best
def neighborhood(graph, source, max_length, min_length=1):
"""
Returns all neighbours of `source` that are less or equal
to `cutoff` nodes away and more or equal to `start` away
within a graph excluding the node itself.
Parameters
----------
graph: :class:`networkx.Graph`
A networkx graph definintion
source:
A node key matching one in the graph
max_length: :type:`int`
The maxdistance between the node and its
neighbours.
min_length: :type:`int`
The minimum length of a path. Default
is zero
Returns
--------
list
list of all nodes distance away from reference
"""
paths = nx.single_source_shortest_path(G=graph,
source=source,
cutoff=max_length)
neighbours = [
node for node, path in paths.items() if min_length <= len(path)
]
return neighbours
def take_similarity_of_the_beginning(self, conclusion: dict,
premise: tuple):
"""
This calculates the score between the conclusion and one premise by the PageRank of the premise.
This takes the similarity between the conclusion and the fist premise of the argumentation into account.
This catches up:
"Even though, in cases of doubt, short ar-guments are preferable, we expect that the mostrelevant arguments
need some space to lay out theirreasoning. However, to investigate such hypothe-ses, ranking functions are
required that go beyondthe words in an argument and its context."
by:
Wachsmuth, H., Potthast, M., Khatib, K.A., Ajjour, Y., Puschmann, J., Qu, J., Dorsch, J., Morari, V.,
Bevendorff, J., & Stein, B. (2017). Building an Argument Search Engine for the Web. ArgMining@EMNLP.
The PageRank is divided by the frequency of the premise since the premise may occur in several arguments.
:param conclusion: Conclusion which should be taken into account.
:param premise: Premise which should be taken into account.
:return: Score between the conclusion and one premise.
"""
premise_id: int = premise[2]
paths = nx.single_source_shortest_path(self.G_reversed,
source=premise_id)
paths = [(key, paths[key]) for key in paths]
max_path = max(paths, key=lambda x: len(x[1]))
first_premise = max_path[1][len(max_path[1]) - 1]
return wordnet_similarity(conclusion['conclusion_text'].lower(),
self.argument_unit_text[first_premise].lower()) * \
self.page_rank_dict[premise_id] / self.frequency[premise_id]
def analyzeGraph(self, jsonFile, level=10):
data = []
nxg = json_graph.load(open(jsonFile))
for n in nxg.nodes(data=True):
if nxg.in_degree(n[0]) == 0:
rootNode = n
break
paths = nx.single_source_shortest_path(nxg,rootNode[0],level)
nodes = {} # Dictionary to keep track of nodes at length x from root node
for k,v in paths.items():
if k == rootNode[0]: continue # exclude root node
if not nodes.has_key(len(v) - 1):
nodes[len(v) - 1] = []
nodes[len(v) - 1].append(k)
# cTotal = 0 # cumulative total
for k in sorted(nodes.keys()):
bunch = [rootNode[0]]
for i in range(1,k + 1):
bunch.extend(nodes[i])
subgraph = nxg.subgraph(bunch)
data.append({'name' : rootNode[1]['name'],
'level' : k,
'node_cnt' : subgraph.number_of_nodes(),
'edge_cnt' : subgraph.number_of_edges()})
return data
def calc_star_uptime(self, n, link_fail):
'''Calc star uptime.
NOTE: n is the number of nodes.'''
# Correct for NetworkX, which adds one to n.
g = nx.star_graph(n - 1)
# Node 0 is the center of the star.
edges = g.number_of_edges()
nodes = g.number_of_nodes()
paths = nx.single_source_shortest_path(g, list(g.nodes())[1])
used = flatten(paths)
sssp_edges = used.number_of_edges()
if sssp_edges != g.number_of_edges():
raise Exception("edge not on sssp for star graph")
# consider those times when a link failed:
# first, consider failure on outside of graph
exp_uptime_outer = link_fail * edges * ((float(edges - 1) / edges) * float(edges) / nodes + \
(float(1) / edges) * float(1) / nodes)
exp_uptime_outer += (1.0 - (link_fail * sssp_edges)) * 1.0
# consider only the hub as a controller:
exp_uptime_inner = link_fail * edges * ((float(edges) / edges) * float(edges) / nodes)
exp_uptime_inner += (1.0 - (link_fail * edges)) * 1.0
# merge:
exp_uptime_weighted = float(edges * exp_uptime_outer + 1 * exp_uptime_inner) / nodes
return exp_uptime_weighted
def get_cosine_radius(G, u, r):
real_paths1 = nx.single_source_shortest_path(G, u, r)
g = G.subgraph(list(real_paths1.keys()))
sims = cosine(g)
my_nodes = []
my_degree = []
my_sims = []
for i in sims:
my_nodes.append(i)
my_degree.append(G.degree(i))
for node in my_nodes:
if node == u:
my_sims.append(1)
continue
if sims[u].get(node) != None:
my_sims.append(sims[u][node])
else:
my_sims.append(0)
d = {'node_name': my_nodes, 'degree': my_degree, 'cos_sim': my_sims}
df = pd.DataFrame(d)
# df['cos_sim'] = (1-df['cos_sim'])
df['cos_sim'] = normalize_rdd(df, 1, 1000, 'cos_sim')
df['cos_sim'] = np.log(df['cos_sim'])
return df
def ListInsert(graph, metadata):
'''
Function takes a list of tuples (all triples comprising shortest path between two NETS nodes) and a list of out
edges for each NETS node in an edge. The function returns a list of tuples containing all triples except those
used to retrieve NETS nodes identifiers or labels.
:param graph: a directed graphical representation where nodes are subjects/objects of the triple and edges are the
labeled predicates
:param metadata:list of tuples (all triples comprising shortest path between two NETS nodes)
:return: a list of tuples sorted in ascending order
'''
# finds nodes on path between NETS nodes subclasses
triple_path = []
for edge in metadata:
for part in graph.out_edges(edge[2]):
preds = [
x for x in nx.single_source_shortest_path(graph, (
part[1])).values() if len(x) != 1
]
if preds:
triple_path += [
tuple([x[0], graph[x[0]][x[1]]['predicate'], x[1]])
for x in preds
]
else:
triple_path.append(
tuple([
part[0], graph[part[0]][part[1]]['predicate'], part[1]
]))
return sorted(list(set(metadata + triple_path)))
def optimize_header_second_pass(header: ir0.Header):
template_defns_by_name = {
elem.name: elem
for elem in header.template_defns
}
template_dependency_graph = nx.DiGraph()
for elem in itertools.chain(header.template_defns,
header.toplevel_content):
if isinstance(elem, ir0.TemplateDefn):
elem_name = elem.name
else:
# We'll use a dummy name for non-template toplevel elems.
elem_name = ''
template_dependency_graph.add_node(elem_name)
if elem_name in header.public_names:
# We also add an edge from the node '' to all public template defns, so that we can use '' as a source below.
template_dependency_graph.add_edge('', elem_name)
for identifier in elem.get_referenced_identifiers():
if identifier in template_defns_by_name.keys():
template_dependency_graph.add_edge(elem_name, identifier)
used_templates = nx.single_source_shortest_path(template_dependency_graph,
source='').keys()
return ir0.Header(template_defns=[
template_defn for template_defn in header.template_defns
if template_defn.name in used_templates
],
toplevel_content=header.toplevel_content,
public_names=header.public_names)
def check_loads_connected(model, verbose=True):
all_sources = []
all_loads = set()
load_source_map = {}
result = True
for i in model.models:
if isinstance(i, PowerSource) and i.connecting_element is not None:
all_sources.append(i)
elif isinstance(i, PowerSource):
print(
'Warning - a PowerSource element has a None connecting element'
)
if isinstance(i, Load):
all_loads.add(i)
load_source_map[i.name] = []
if len(all_sources) == 0:
print('Model does not contain any power source')
return False
for source in all_sources:
ditto_graph = Network()
ditto_graph.build(model, source.connecting_element)
ditto_graph.set_attributes(model)
ditto_graph.remove_open_switches(
model) # This deletes the switches inside the networkx graph only
source_name = source.connecting_element
all_paths = nx.single_source_shortest_path(ditto_graph.graph,
source_name)
for load in all_loads:
min_dist = float('inf')
load_connection = load.connecting_element
if load_connection in all_paths:
load_source_map[load.name].append(source_name)
result = True
sourceless_loads = []
multi_source_loads = {}
for load in load_source_map:
if len(load_source_map[load]) == 0:
result = False
sourceless_loads.append(load)
if len(load_source_map[load]) > 1:
result = False
multi_source_loads[load.name] = load_source_map[load]
if verbose:
if len(sourceless_loads) > 0:
print('Loads missing sources:')
for load in sourceless_loads:
print(load)
if len(multi_source_loads) > 0:
print('Loads with multiple sources:')
for load in multi_source_loads:
print(load + ': ' + multi_source_loads[load])
return result
def get_forwarding_policy(topo, link_port_map):
#rules = []
pol = None
base_ip = "10.0.%d.1"
edge_nodes = [n for n in topo.nodes() if topo.node[n]["isHost"]]
core_nodes = [n for n in topo.nodes() if topo.node[n]["isHost"] == False]
# print "start"
for u in edge_nodes:
dst_ip = base_ip % (u - 1)
paths = nx.single_source_shortest_path(topo, u)
for v in edge_nodes:
if u != v:
pass
# print u, v, paths[v]
for s in core_nodes:
next_hop = paths[s][-2]
#m = match(switch = s, dstip = dst_ip).compile().rules[0].match
#act = fwd(link_port_map[s][next_hop]).compile().rules[0].actions
if pol:
pol += match(switch = s, dstip = dst_ip) >> fwd(link_port_map[s][next_hop])
else:
pol = match(switch = s, dstip = dst_ip) >> fwd(link_port_map[s][next_hop])
#rules.append(Rule(m, act))
return pol
def chiral_order(atoms, chiral_atom, depth=6):
# Create a list of ordered atoms to be passed back
ordered = []
# Do a quick check whether there are multiple hydrogens
neighbors = atoms.neighbors(chiral_atom)
hydrogens = [atom for atom in neighbors if atom.element == "H"]
if len(hydrogens) < 2:
tree = nx.bfs_tree(atoms, chiral_atom)
# Generate the list of shortest paths in the molecule, neglecting the trivial path [chiral_atom]
paths = sorted(nx.single_source_shortest_path(tree, chiral_atom,
depth).values(),
reverse=True)[:-1]
while paths:
# Pop the first element (highest priority path) from the list of paths and remove any duplicates.
path = paths.pop(0)
paths_no_dups = [
unpruned for unpruned in paths if unpruned != path
]
# If there are any duplicates, the paths list will be smaller and we can't resolve a highest priority yet.
if len(paths_no_dups) != len(paths):
paths = paths_no_dups
# Otherwise, the path is higher priority than all the other paths, so its second atom is the neighbour with
# highest priority.
else:
ranked_atom = path[1]
ordered.append(ranked_atom)
# Drop all the paths containing our ranked atom.
paths = [
unpruned for unpruned in paths
if unpruned[1] is not ranked_atom
]
return ordered
def SampledDiameter(g):
ns=g.nodes()
pathLengths=[]
for n in ns:
paths=nx.single_source_shortest_path(g, n)
pathLengths.extend([len(paths[n]) for n in paths.keys()])
return max(pathLengths)
def calc_star_uptime(self, n, link_fail):
'''Calc star uptime.
NOTE: n is the number of nodes.'''
# Correct for NetworkX, which adds one to n.
g = nx.star_graph(n - 1)
# Node 0 is the center of the star.
edges = g.number_of_edges()
nodes = g.number_of_nodes()
paths = nx.single_source_shortest_path(g, g.nodes()[1])
used = flatten(paths)
sssp_edges = used.number_of_edges()
if sssp_edges != g.number_of_edges():
raise Exception("edge not on sssp for star graph")
# consider those times when a link failed:
# first, consider failure on outside of graph
exp_uptime_outer = link_fail * edges * ((float(edges - 1) / edges) * float(edges) / nodes + \
(float(1) / edges) * float(1) / nodes)
exp_uptime_outer += (1.0 - (link_fail * sssp_edges)) * 1.0
# consider only the hub as a controller:
exp_uptime_inner = link_fail * edges * ((float(edges) / edges) * float(edges) / nodes)
exp_uptime_inner += (1.0 - (link_fail * edges)) * 1.0
# merge:
exp_uptime_weighted = float(edges * exp_uptime_outer + 1 * exp_uptime_inner) / nodes
return exp_uptime_weighted
def get_reachability(server, subscribers, topologies):
"""Returns the average probability of reaching any of the subscribers from the
server in each of the given topologies. Also includes the result for using
all topologies at once.
:returns list: containing reachability for each topology (in order),
with the last entry representing using all topologies at the same time
"""
subscribers = set(subscribers)
subs_reachable_by_tree = []
all_subscribers_reachable = set()
for topology in topologies:
nodes_reachable = set(
nx.single_source_shortest_path(topology, server))
# could also use has_path()
subscribers_reachable = subscribers.intersection(nodes_reachable)
subs_reachable_by_tree.append(
len(subscribers_reachable) / float(len(subscribers)))
all_subscribers_reachable.update(subscribers_reachable)
log.debug(
"%s heuristic reached %d subscribers in this topo" %
(topology.graph['heuristic'], len(subscribers_reachable)))
log.debug("ALL subscribers reached by these topos: %d" %
len(all_subscribers_reachable))
# Lastly, include all of them reachable
subs_reachable_by_tree.append(
float(len(all_subscribers_reachable)) / len(subscribers))
return subs_reachable_by_tree
def _longest_path_in_tree(self, G):
""" Given a tree graph, compute the longest path and return it
Given an undirected tree graph, compute the longest path and return it.
The approach use two shortest path transversals (shortest path in a
tree is the same as longest path). This could be improve but would
require implement it:
https://cs.stackexchange.com/questions/11263/longest-path-in-an-undirected-tree-with-only-one-traversal
Args:
G (nx.Graph): Graph which should be an undirected tree graph
Returns:
list(int): Returns a list of indexes of the nodes belonging to the
longest path.
"""
if not isinstance(G, nx.Graph):
raise TypeError('G must be a nx.Graph instance')
if not nx.is_tree(G):
raise ValueError('Graph G must be a tree (graph without cycles)')
# Compute the furthest node to the random node v
v = list(G.nodes())[0]
distance = nx.single_source_shortest_path_length(G, v)
vp = max(distance.items(), key=lambda x: x[1])[0]
# From this furthest point v' find again the longest path from it
distance = nx.single_source_shortest_path(G, vp)
longest_path = max(distance.values(), key=len)
# Return the longest path
return list(longest_path)
def test_load_gml_for_debugging(self):
g: nx.DiGraph = nx.read_gml('real-nodes.gml',
destringizer=self.make_points)
all_paths = nx.single_source_shortest_path(g, source=Point(0, 0))
max_distance = 0
i = 0
node_count = len(g.nodes)
greater_than_1000 = 0
for k in all_paths.keys():
i += 1
if len(all_paths[k]) > max_distance:
max_distance = len(all_paths[k])
if len(all_paths[k]) >= 1001:
greater_than_1000 += 1
print('{}/{}'.format(i, node_count))
print('max: {}'.format(max_distance - 1))
print('more than 1000: {}'.format(greater_than_1000))
for node in g.nodes:
i += 1
distance = nx.shortest_path_length(g,
source=Point(0, 0),
target=node)
if distance > max_distance:
max_distance = distance
print(max_distance)
def day7():
"""Counting matryoshka bags."""
x = open("7.txt").read().strip().split("\n")
g = nx.DiGraph()
for i in x:
i, outs = re.match("^(.*?) bags contain (.*).$", i).groups()
outs = filter(None, re.findall("(?:[0-9]+ (.*?)|no other) bags?",
outs))
for j in outs:
g.add_edge(j, i)
res1 = len(nx.single_source_shortest_path(g, "shiny gold")) - 1
g = nx.DiGraph()
for i in x:
i, outs = re.match("^(.*?) bags contain (.*).$", i).groups()
outs = re.findall(r"\b([0-9]+|no) (.*?) bags?", outs)
for k, j in outs:
if (k, j) != ("no", "other"):
g.add_edge(i, j, weight=int(k))
@lru_cache(maxsize=len(g))
def get_sum(i):
return 1 + sum(get_sum(j) * k["weight"] for j, k in g[i].items())
res2 = sum(get_sum(j) * k["weight"] for j, k in g["shiny gold"].items())
return res1, res2
def reset(self, config):
self.n_node = config.n_node
self.k_ring = config.k_ring
self.p_rewiring = config.p_rewiring
self.num_actions = config.num_actions
self.path_len_limit = config.path_len_limit
self.ndigits = config.ndigits
self.nway = config.nway
self.num_step = 0
self.reset_graph()
while 1:
self.target_state = np.random.randint(0, self.n_node)
self.done = False
self.path = nx.single_source_shortest_path(self.graph,
self.target_state)
self.src_prob = np.zeros(len(self.path))
for i in self.path:
self.path[i] = list(reversed(self.path[i]))
self.src_prob[i] = len(self.path[i]) > 2 and (
len(self.path[i]) - 1) <= self.path_len_limit
if self.src_prob.sum() > 0:
self.src_prob /= self.src_prob.sum()
break
self.src_state = np.random.choice(self.n_node, p=self.src_prob)
self.current_state = self.src_state
return self.current_state
def _make_join_graph(join_clauses, root):
"""Constructs nx.Graph and nx.DiGraph representations of the specified join.
Constructs an undirected graph in which vertices are tables, and edges are
joins.
Also returns an arborescence (directed tree) in which edges originate from
the join root to every joined table.
"""
clauses = []
for line in join_clauses:
groups = match_join_clause_or_fail(line).groups()
clauses.append(groups)
g = nx.Graph()
for t1, c1, t2, c2 in clauses:
assert not g.has_edge(t1, t2)
g.add_edge(t1, t2, join_keys={t1: c1, t2: c2})
assert nx.is_tree(g), g.edges
paths = nx.single_source_shortest_path(g, root)
dg = nx.DiGraph()
for path in paths.values():
prev = None
for t in path:
if prev is not None:
dg.add_edge(prev, t)
prev = t
assert set(g.nodes) == set(dg.nodes)
return g, dg
def shortest_path_subgraph(kg_graph,
prev_graph,
nodes,
path_len=2,
add_all_path=False):
# Get non-neighbor nodes: nodes without edges between them
new_graph = kg_graph.subgraph(nodes).copy()
new_graph.remove_edges_from(nx.selfloop_edges(new_graph))
world_graph = nx.compose(prev_graph, new_graph)
if path_len < 2:
return world_graph
triplets = []
sg_nodes = list(nx.isolates(world_graph))
for source in sg_nodes:
nb = nx.single_source_shortest_path(kg_graph, source, cutoff=path_len)
if add_all_path:
triplets.extend([[source, target, ' '.join(nb[target][1:-1])]
for target in nodes
if source != target and target in nb
and len(nb[target]) == path_len + 1])
else:
for target in nodes: # Just add one link
if source != target and target in nb and len(
nb[target]) == path_len + 1:
triplets.append(
[source, target, ' '.join(nb[target][1:-1])])
break
add_triplets_to_graph(world_graph, triplets)
return world_graph
def get_permission_details(self, name):
""" Get a permission and what groups it's assigned to. """
with self.lock:
data = {
"groups": {},
}
# Get all mapped versions of the permission. This is only direct relationships.
direct_groups = set()
for groupname, permissions in self.permission_metadata.iteritems():
for permission in permissions:
if permission.permission == name:
data["groups"][groupname] = self.get_group_details(
groupname, show_permission=name)
direct_groups.add(groupname)
# Now find all members of these groups going down the tree.
checked_groups = set()
for groupname in direct_groups:
group = ("Group", groupname)
paths = single_source_shortest_path(self._graph, group, None)
for member, path in paths.iteritems():
if member == group:
continue
member_type, member_name = member
if member_type != 'Group':
continue
if member_name in checked_groups:
continue
checked_groups.add(member_name)
data["groups"][member_name] = self.get_group_details(
member_name, show_permission=name)
return data
def to_rule_cpd(self):
"""
Returns a RuleCPD object which represents the TreeCPD
Examples
--------
>>> from pgmpy.factors import TreeCPD, Factor
>>> tree = TreeCPD([('B', factors(['A'], [2], [0.8, 0.2]), '0'),
... ('B', 'C', '1'),
... ('C', factors(['A'], [2], [0.1, 0.9]), '0'),
... ('C', 'D', '1'),
... ('D', factors(['A'], [2], [0.9, 0.1]), '0'),
... ('D', factors(['A'], [2], [0.4, 0.6]), '1')])
>>> tree.to_rule_cpd()
"""
# TODO: This method assumes that factors class has a get_variable method. Check this after merging navin's PR.
root = [node for node, in_degree in self.in_degree().items() if in_degree == 0][0]
paths_root_to_factors = {target: path for target, path in nx.single_source_shortest_path(self, root).items() if
isinstance(target, Factor)}
for node in self.nodes_iter():
if isinstance(node, Factor):
rule_cpd = RuleCPD(node.scope()[0])
for factor, path in paths_root_to_factors.items():
rule_key = []
for node_index in range(len(path) - 1):
rule_key.append(path[node_index] + '_' + self.edge[path[node_index]][path[node_index + 1]]['label'])
for value_index in range(len(factor.values)):
rule_key.append(factor.get_variables()[0] + '_' + str(value_index))
rule_cpd.add_rules({tuple(sorted(rule_key)): factor.values[value_index]})
return rule_cpd
def networkx_Call(M, source):
print('Format conversion ... ')
M = M.tocsr()
if M is None:
raise TypeError('Could not read the input graph')
if M.shape[0] != M.shape[1]:
raise TypeError('Shape is not square')
# should be autosorted, but check just to make sure
if not M.has_sorted_indices:
print('sort_indices ... ')
M.sort_indices()
# Directed NetworkX graph
Gnx = nx.DiGraph(M)
print('NX Solving... ')
t1 = time.time()
path = nx.single_source_shortest_path(Gnx, source)
t2 = time.time() - t1
print('Time : ' + str(t2))
return path
def get_permission_details(self, name):
""" Get a permission and what groups it's assigned to. """
with self.lock:
data = {
"groups": {},
}
# Get all mapped versions of the permission. This is only direct relationships.
direct_groups = set()
for groupname, permissions in self.permission_metadata.iteritems():
for permission in permissions:
if permission.permission == name:
data["groups"][groupname] = self.get_group_details(
groupname, show_permission=name)
direct_groups.add(groupname)
# Now find all members of these groups going down the tree.
checked_groups = set()
for groupname in direct_groups:
group = ("Group", groupname)
paths = single_source_shortest_path(self._graph, group, None)
for member, path in paths.iteritems():
if member == group:
continue
member_type, member_name = member
if member_type != 'Group':
continue
if member_name in checked_groups:
continue
checked_groups.add(member_name)
data["groups"][member_name] = self.get_group_details(
member_name, show_permission=name)
return data
def mst_of_g(g,terminals,verbose=False,weighted=True,cutoff=7,return_gL=False,bidir=False):
STARTTIME=time.time()
if verbose:
logger.info("Starting MST construction")
sys.stdout.flush()
STARTTIME=time.time()
gLedges=[]
shortest_network=model.AnnotatedGraph()
for i in range(len(terminals)):
src=terminals[i]
if src not in g:
if verbose:
logger.info("Node %s not in g"%(src))
continue
if weighted:
costs,paths=nx.single_source_dijkstra(g, src, weight='weight',cutoff=cutoff)
else:
paths=nx.single_source_shortest_path(g,src,cutoff=cutoff)
costs=dict([(k,len(v)) for k,v in paths.items()])
if bidir:
span=range(len(terminals))
else:
span=range(i+1,len(terminals))
for j in span:
if j==i:
continue
tgt=terminals[j]
if tgt not in paths:
if verbose:
logger.info("no paths between %s and %s"%(src,tgt))
continue
shortest_network.add_path(paths[tgt])
gLedges.append((src,tgt,{'weight':costs[tgt],'path':paths[tgt]}))
if verbose:
logger.info("Done %s. Still %d to go"%(src,len(terminals)-i))
sys.stdout.flush()
if verbose:
logger.info("Computed Metric closure in %f seconds"%(time.time() - STARTTIME))
STARTTIME=time.time()
sys.stdout.flush()
gL=nx.Graph()
gL.add_edges_from(gLedges)
# Min spanning Tree
tL=nx.minimum_spanning_tree(gL)
if verbose:
logger.info("Computed Min spanning tree in %f seconds"%(time.time() - STARTTIME))
STARTTIME=time.time()
sys.stdout.flush()
mst=model.AnnotatedGraph()
for e in tL.edges(data=True):
mst.add_path(e[2]["path"])
copy_attributes_from_g(mst,g)
if return_gL:
return mst,gL,shortest_network
else:
return mst
def chiral_order(atoms, chiral_atom, depth=6):
# Create a list of ordered atoms to be passed back
ordered = []
# Do a quick check whether there are multiple hydrogens
neighbors = atoms.neighbors(chiral_atom)
hydrogens = [atom for atom in neighbors if atom.element == "H"]
if len(hydrogens) < 2:
tree = nx.bfs_tree(atoms, chiral_atom)
# Generate the list of shortest paths in the molecule, neglecting the trivial path [chiral_atom]
paths = sorted(nx.single_source_shortest_path(tree, chiral_atom, depth).values(), reverse = True)[:-1]
while paths:
# Pop the first element (highest priority path) from the list of paths and remove any duplicates.
path = paths.pop(0)
paths_no_dups = [unpruned for unpruned in paths if unpruned != path]
# If there are any duplicates, the paths list will be smaller and we can't resolve a highest priority yet.
if len(paths_no_dups) != len(paths):
paths = paths_no_dups
# Otherwise, the path is higher priority than all the other paths, so its second atom is the neighbour with
# highest priority.
else:
ranked_atom = path[1]
ordered.append(ranked_atom)
# Drop all the paths containing our ranked atom.
paths = [unpruned for unpruned in paths if unpruned[1] is not ranked_atom]
return ordered
def betweenness(g): #Function to find the betweenness in the graph
count = 0
res = []
mat = []
for i in xrange(len(
g.nodes())): #Making the matrix to store the betweenness value.
mat.append([])
for j in xrange(len(g.nodes())):
mat[i].append(0.0) #Initialising it with 0.
for i in range(len(g.nodes())
): #Finding the shortest path between every pair of node.
path = nx.single_source_shortest_path(
g, i) #Function to get the shortest path.
for p in range(len(path)):
for k in range(len(path[p]) - 1):
mat[path[p][k]][path[p][k + 1]] += 1.0
count = count + len(path)
for i in range(len(g.nodes())): #finding the betweenness.
for j in range(len(g.nodes())):
mat[i][j] = mat[i][j] / count
"""for i in range(len(g.nodes())):
for j in range(i+1,len(g.nodes())):
list1 = nx.shortest_path(g,source=i,target=j)
for k in range(len(list1)):
res.append(list1)"""
return mat #returning the matrix.
def make_graph_from(self, minima, cutoff=1):
"""rebuild the graph using only the passed minima and those in self.from_minima"""
# cutoff += 1
self.from_minima.update(minima)
minima = self.from_minima
nodes = set()
# make a graph from the minima in self.minima and nearest neighbors
outer_layer = set()
for m in minima:
nodesdir = nx.single_source_shortest_path(self.full_graph,
m,
cutoff=cutoff)
for n, path in nodesdir.items():
d = len(path) - 1
if d < cutoff:
# n is close to m, remove it from outer layer
outer_layer.discard(n)
elif d == cutoff:
if n not in nodes:
# n is in the outer layer of m and not near any other nodes.
outer_layer.add(n)
nodes.update(nodesdir)
self.boundary_nodes = outer_layer
self.graph = self.full_graph.subgraph(nodes)
# remove nodes not in the graph from the dictionary positions
difference = set(self.positions.keys())
difference.difference_update(self.graph.nodes())
for m in difference:
self.positions.pop(m)
print("boundary nodes", len(self.boundary_nodes),
self.graph.number_of_nodes())
def make_graph_from(self, minima, cutoff=1):
"""rebuild the graph using only the passed minima and those in self.from_minima"""
# cutoff += 1
self.from_minima.update(minima)
minima = self.from_minima
nodes = set()
# make a graph from the minima in self.minima and nearest neighbors
outer_layer = set()
for m in minima:
nodesdir = nx.single_source_shortest_path(self.full_graph, m, cutoff=cutoff)
for n, path in nodesdir.iteritems():
d = len(path) - 1
if d < cutoff:
# n is close to m, remove it from outer layer
outer_layer.discard(n)
elif d == cutoff:
if n not in nodes:
# n is in the outer layer of m and not near any other nodes.
outer_layer.add(n)
nodes.update(nodesdir)
self.boundary_nodes = outer_layer
self.graph = self.full_graph.subgraph(nodes)
# remove nodes not in the graph from the dictionary positions
difference = set(self.positions.viewkeys())
difference.difference_update(self.graph.nodes())
for m in difference:
self.positions.pop(m)
print "boundary nodes", len(self.boundary_nodes), self.graph.number_of_nodes()
def simrank_radius(G, u, r):
real_paths1 = nx.single_source_shortest_path(G, u, r)
g = G.subgraph(list(real_paths1.keys()))
sim = nx.simrank_similarity(g, u)
sim_list = []
node_list = []
degree_list = []
for n in sim:
sim_list.append(sim[n])
node_list.append(n)
degree_list.append(G.degree(n))
d = {'node_name': node_list, 'degree': degree_list, 'simrank': sim_list}
df = pd.DataFrame(d)
# print(df)
df['simrank'] = normalize_rdd(df, 1, 1000, 'simrank')
df['simrank'] = np.log10(df['simrank'])
# print(df)
return df
def get_forwarding_policy(topo, link_port_map):
#rules = []
pol = None
base_ip = "10.0.%d.1"
edge_nodes = [n for n in topo.nodes() if topo.node[n]["isHost"]]
core_nodes = [n for n in topo.nodes() if topo.node[n]["isHost"] == False]
# print "start"
for u in edge_nodes:
dst_ip = base_ip % (u - 1)
paths = nx.single_source_shortest_path(topo, u)
for v in edge_nodes:
if u != v:
pass
# print u, v, paths[v]
for s in core_nodes:
next_hop = paths[s][-2]
#m = match(switch = s, dstip = dst_ip).compile().rules[0].match
#act = fwd(link_port_map[s][next_hop]).compile().rules[0].actions
if pol:
pol += match(switch=s, dstip=dst_ip) >> fwd(
link_port_map[s][next_hop])
else:
pol = match(switch=s, dstip=dst_ip) >> fwd(
link_port_map[s][next_hop])
#rules.append(Rule(m, act))
return pol
def connect_shortest_v3(weigthed_graph,nodes,weighted=True,cutoff=None,verbose=False): STARTTIME=time.time() if verbose: print "Starting SHOV3 construction" sys.stdout.flush() STARTTIME=time.time() res=nx.Graph() for i in range(len(nodes)): src=nodes[i] if src not in weigthed_graph: continue if weighted: costs,spaths=nx.single_source_dijkstra(weigthed_graph, src, weight='weight',cutoff=cutoff) else: spaths=nx.single_source_shortest_path(weigthed_graph, src,cutoff=cutoff) for j in range(i+1, len(nodes)): t=nodes[j] if t not in spaths: continue if cutoff and (len(spaths[t])>cutoff): continue res.add_path(spaths[t]) if verbose: print "Done",src,"to go:",len(nodes)-i sys.stdout.flush() if verbose: print "Computed SHOV3,",time.time() - STARTTIME,"seconds" STARTTIME=time.time() sys.stdout.flush() return res
def get_bw_cost(g, source, hops):
counter = 0
paths = nx.single_source_shortest_path(g, source, hops)
no_friends = len(paths) - 1
for k, v in paths.iteritems():
if (len(v) <= hops):
counter += g.degree(k)
return no_friends, counter - no_friends
def neighbors_genotyped_selective(self, node, depth=1):
'''Return all neighbors of a node in the entire pedigree (if genotyped = False) or
all genotyped neighbors (if genotyped = True) of depth <= depth. Selects only neighbors
that have genotyped neighbors on the path between the neighbor and node.'''
return list(reduce(set.union,
(v for (k, v) in
nx.single_source_shortest_path(self._graph_undirected, node, cutoff=depth).iteritems()
if self.is_genotyped(k)), set([])))
def neighbors(self, node, depth=1, genotyped=False, add_parents=False):
'''Return all neighbors of a node in the entire pedigree (if genotyped = False) or
all genotyped neighbors (if genotyped = True) of depth <= depth.
If add_parents=False, adds all parents of all neighbors to complete the pedigree.'''
nbhrs = [x for x in nx.single_source_shortest_path(self._graph_undirected, node, cutoff=depth).iterkeys()
if (self.is_genotyped(x) if genotyped else True)]
if add_parents: nbhrs = list(set(nbhrs + [parent for x in nbhrs for parent in self.parents(x).itervalues()]))
return nbhrs
def edge_parent_finder(abstract, graph):
'''
moved this here since i think that it is forgi specific
'''
# find out to which abstract node the edges belong
# finding out where the edge-nodes belong, because the contractor cant possibly do this
#draw.graphlearn_draw([abstract,graph],size=10, contract=False,vertex_label='id')
getabstr = {contra: node for node, d in abstract.nodes(data=True) for contra in d.get('contracted', [])}
# print getabstr
for n, d in graph.nodes(data=True):
if 'edge' in d:
# if we have found an edge node...
# lets see whos left and right of it:
# if len is 2 then we hit a basepair, in that case we already have both neighbors
zomg = graph.neighbors(n)
if len(zomg)==1:
zomg+=graph.predecessors(n)
n1, n2 = zomg
# case1: ok those belong to the same gang so we most likely also belong there.
if getabstr[n1] == getabstr[n2]:
abstract.node[getabstr[n1]]['contracted'].add(n)
# case2: neighbors belong to different gangs...
else:
abstract_intersect = set(abstract.neighbors(getabstr[n1])) & set(abstract.neighbors(getabstr[n2]))
# case 3: abstract intersect in radius 1 failed, so lets try radius 2
if not abstract_intersect:
abstract_intersect = set(nx.single_source_shortest_path(abstract, getabstr[n1], 2)) & set(
nx.single_source_shortest_path(abstract, getabstr[n2], 2))
if len(abstract_intersect) > 1:
print "weired abs intersect..."
for ai_node in abstract_intersect:
if 'contracted' in abstract.node[ai_node]:
abstract.node[ai_node]['contracted'].add(n)
else:
abstract.node[ai_node]['contracted'] = set([n])
return abstract
def _solve_graph(self):
sols = []
j = self.state.to_json()
d = hashlib.md5(j).hexdigest()
for a,p in nx.single_source_shortest_path(self.gr,d).items():
if a in self.gr.graph['finals']:
sols.append(p)
sols = sorted(sols, key=lambda sol: len(sol))
return sols
def get_shortest_paths(topo):
edge_nodes = [n for n in topo.nodes() if topo.node[n]["isHost"]]
shortest_paths = []
for u in edge_nodes:
paths = nx.single_source_shortest_path(topo, u)
for v in edge_nodes:
if u != v:
shortest_paths.append(paths[v])
return shortest_paths
def is_connected(G):
"""Return True if G is connected.
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."""
return len(single_source_shortest_path(G, G.nodes_iter().next()))==len(G)
def sum_edges(g, hops):
for source in g.nodes_iter():
count = 0
paths = nx.single_source_shortest_path(g, source, hops-1)
for node in paths.iterkeys():
count += g.degree(node)
print >> out_file, count
def wiener(self , last_previous_level_vertex_number , previous_level_wiener):
sum=0
n=self.level_number
for i in range(last_previous_level_vertex_number , n):
path=nx.single_source_shortest_path(self.g2,i)
for j in range(0,last_previous_level_vertex_number):
sum+= (len(path[j]) -1)*(len(path[j]) -1)*(len(path[j]) - 1)
for j in range(i+1,n):
sum += (len(path[j]) - 1)*(len(path[j]) - 1)*(len(path[j]) - 1)
return sum+previous_level_wiener
def random_shortest_path(graphs):
mu, sigma = cutoff_params
cutoff = int(random.gauss(mu, sigma))
graph = graphs[random.randint(0,len(graphs)-1)]
source = randnode(graph)
paths = nx.single_source_shortest_path(graph, source, cutoff)
targets = paths.keys()
target = targets[random.randint(0,len(targets)-1)]
path = nx.shortest_path(graph, source, target, 'weight')
return tuple(path)
def get_riaa_path(self, label_id):
shortest = []
paths = nx.single_source_shortest_path(self.db, label_id)
for path in paths.values():
if self.is_riaa(path[-1]):
if len(shortest) == 0:
shortest = path
elif len(path) < len(shortest):
shortest = path
return shortest
def generate_SP(G, N = 100, seeds_num = 3):
Gcc = sorted(nx.connected_component_subgraphs(G.to_undirected()), key = len, reverse = True)
nodes = set()
i = 0
seeds = set()
leaf = []
infection_order = []
infection_track = {}
for i in xrange(len(Gcc)):
nodes.update(set(Gcc[i].nodes()))
seeds.add(Gcc[i].nodes()[np.random.choice(range(Gcc[i].number_of_nodes()))])
if len(nodes) >= N:
break
G = G.subgraph(nodes).to_undirected()
#if len(seeds) < seeds_num:
rest_seeds_num = max(0, seeds_num - len(seeds))
nodes = list(nodes.difference(seeds))
chosen = [nodes[j] for j in np.random.choice(range(len(nodes)), size = N)]
seeds.update(chosen[:rest_seeds_num])
to_infect = chosen[rest_seeds_num:]
#seeds_num = len(seeds)
SSSP = {}
for s in seeds:
SPs = nx.single_source_shortest_path(G, s)
SSSP[s] = SPs
inf_paths = []
maxpath = -sys.maxint
for i in to_infect:
src = -1
for s in SSSP.keys():
if (src == -1 and i in SSSP[s]) or (i in SSSP[s] and len(SSSP[s][i]) < len(SSSP[src][i])):
src = s
infection_track[src] = infection_track.get(src, []) + [i]
if len(SSSP[src][i]) == 1:
inf_paths.append([(src, src)])
else:
inf_paths.append([tuple(SSSP[src][i][ind:ind+2]) for ind in range(len(SSSP[src][i])-1)])
if len(SSSP[src][i]) > maxpath:
maxpath = len(SSSP[src][i])-1
for ind in xrange(maxpath):
for path in inf_paths:
if ind < len(path) and path[ind] not in infection_order:
infection_order.append(path[ind])
return infection_order, infection_track, seeds, to_infect
def test_single_source_shortest_path(self):
p = nx.shortest_path(self.cycle, 0)
assert_equal(p[3], [0, 1, 2, 3])
assert_equal(p, nx.single_source_shortest_path(self.cycle, 0))
p = nx.shortest_path(self.grid, 1)
validate_grid_path(4, 4, 1, 12, p[12])
# now with weights
p = nx.shortest_path(self.cycle, 0, weight='weight')
assert_equal(p[3], [0, 1, 2, 3])
assert_equal(p, nx.single_source_dijkstra_path(self.cycle, 0))
p = nx.shortest_path(self.grid, 1, weight='weight')
validate_grid_path(4, 4, 1, 12, p[12])
# weights and method specified
p = nx.shortest_path(self.cycle, 0, method='dijkstra', weight='weight')
assert_equal(p[3], [0, 1, 2, 3])
assert_equal(p, nx.single_source_shortest_path(self.cycle, 0))
p = nx.shortest_path(self.cycle, 0, method='bellman-ford',
weight='weight')
assert_equal(p[3], [0, 1, 2, 3])
assert_equal(p, nx.single_source_shortest_path(self.cycle, 0))
def sum_edges(g, source, hops):
""" Sum edges that are hops away in undirected graph """
edges = 0
paths = nx.single_source_shortest_path(g, source, hops)
for node in paths.iterkeys():
edges += len(g.neighbors(node))
return edges
def test_single_source_shortest_path(self):
p=nx.shortest_path(self.cycle,0)
assert_equal(p[3],[0,1,2,3])
assert_equal(p,nx.single_source_shortest_path(self.cycle,0))
p=nx.shortest_path(self.grid,1)
assert_equal(p[12],[1, 2, 3, 4, 8, 12])
# now with weights
p=nx.shortest_path(self.cycle,0,weighted=True)
assert_equal(p[3],[0,1,2,3])
assert_equal(p,nx.single_source_dijkstra_path(self.cycle,0))
p=nx.shortest_path(self.grid,1,weighted=True)
assert_equal(p[12],[1, 2, 3, 4, 8, 12])
def test_single_source_shortest_path(self):
p=nx.shortest_path(self.cycle,0)
assert_equal(p[3],[0,1,2,3])
assert_equal(p,nx.single_source_shortest_path(self.cycle,0))
p=nx.shortest_path(self.grid,1)
validate_grid_path(4, 4, 1, 12, p[12])
# now with weights
p=nx.shortest_path(self.cycle,0,weight='weight')
assert_equal(p[3],[0,1,2,3])
assert_equal(p,nx.single_source_dijkstra_path(self.cycle,0))
p=nx.shortest_path(self.grid,1,weight='weight')
validate_grid_path(4, 4, 1, 12, p[12])
