def test_multigraph(self):
assert nx.bellman_ford_path(self.MXG, "s", "v") == ["s", "x", "u", "v"]
assert nx.bellman_ford_path_length(self.MXG, "s", "v") == 9
assert nx.single_source_bellman_ford_path(self.MXG, "s")["v"] == [
"s",
"x",
"u",
"v",
]
assert nx.single_source_bellman_ford_path_length(self.MXG,
"s")["v"] == 9
D, P = nx.single_source_bellman_ford(self.MXG, "s", target="v")
assert D == 9
assert P == ["s", "x", "u", "v"]
P, D = nx.bellman_ford_predecessor_and_distance(self.MXG, "s")
assert P["v"] == ["u"]
assert D["v"] == 9
P, D = nx.goldberg_radzik(self.MXG, "s")
assert P["v"] == "u"
assert D["v"] == 9
assert nx.bellman_ford_path(self.MXG4, 0, 2) == [0, 1, 2]
assert nx.bellman_ford_path_length(self.MXG4, 0, 2) == 4
assert nx.single_source_bellman_ford_path(self.MXG4, 0)[2] == [0, 1, 2]
assert nx.single_source_bellman_ford_path_length(self.MXG4, 0)[2] == 4
D, P = nx.single_source_bellman_ford(self.MXG4, 0, target=2)
assert D == 4
assert P == [0, 1, 2]
P, D = nx.bellman_ford_predecessor_and_distance(self.MXG4, 0)
assert P[2] == [1]
assert D[2] == 4
P, D = nx.goldberg_radzik(self.MXG4, 0)
assert P[2] == 1
assert D[2] == 4
def test_multigraph(self):
assert nx.bellman_ford_path(self.MXG, 's', 'v') == ['s', 'x', 'u', 'v']
assert nx.bellman_ford_path_length(self.MXG, 's', 'v') == 9
assert nx.single_source_bellman_ford_path(
self.MXG, 's')['v'] == ['s', 'x', 'u', 'v']
assert nx.single_source_bellman_ford_path_length(self.MXG,
's')['v'] == 9
D, P = nx.single_source_bellman_ford(self.MXG, 's', target='v')
assert D == 9
assert P == ['s', 'x', 'u', 'v']
P, D = nx.bellman_ford_predecessor_and_distance(self.MXG, 's')
assert P['v'] == ['u']
assert D['v'] == 9
P, D = nx.goldberg_radzik(self.MXG, 's')
assert P['v'] == 'u'
assert D['v'] == 9
assert nx.bellman_ford_path(self.MXG4, 0, 2) == [0, 1, 2]
assert nx.bellman_ford_path_length(self.MXG4, 0, 2) == 4
assert nx.single_source_bellman_ford_path(self.MXG4, 0)[2] == [0, 1, 2]
assert nx.single_source_bellman_ford_path_length(self.MXG4, 0)[2] == 4
D, P = nx.single_source_bellman_ford(self.MXG4, 0, target=2)
assert D == 4
assert P == [0, 1, 2]
P, D = nx.bellman_ford_predecessor_and_distance(self.MXG4, 0)
assert P[2] == [1]
assert D[2] == 4
P, D = nx.goldberg_radzik(self.MXG4, 0)
assert P[2] == 1
assert D[2] == 4
def test_multigraph(self):
assert_equal(nx.bellman_ford_path(self.MXG, 's', 'v'),
['s', 'x', 'u', 'v'])
assert_equal(nx.bellman_ford_path_length(self.MXG, 's', 'v'), 9)
assert_equal(
nx.single_source_bellman_ford_path(self.MXG, 's')['v'],
['s', 'x', 'u', 'v'])
assert_equal(
dict(nx.single_source_bellman_ford_path_length(self.MXG,
's'))['v'], 9)
D, P = nx.single_source_bellman_ford(self.MXG, 's', target='v')
assert_equal(D['v'], 9)
assert_equal(P['v'], ['s', 'x', 'u', 'v'])
P, D = nx.bellman_ford_predecessor_and_distance(self.MXG, 's')
assert_equal(P['v'], ['u'])
assert_equal(D['v'], 9)
P, D = nx.goldberg_radzik(self.MXG, 's')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
assert_equal(nx.bellman_ford_path(self.MXG4, 0, 2), [0, 1, 2])
assert_equal(nx.bellman_ford_path_length(self.MXG4, 0, 2), 4)
assert_equal(
nx.single_source_bellman_ford_path(self.MXG4, 0)[2], [0, 1, 2])
assert_equal(
dict(nx.single_source_bellman_ford_path_length(self.MXG4, 0))[2],
4)
D, P = nx.single_source_bellman_ford(self.MXG4, 0, target=2)
assert_equal(D[2], 4)
assert_equal(P[2], [0, 1, 2])
P, D = nx.bellman_ford_predecessor_and_distance(self.MXG4, 0)
assert_equal(P[2], [1])
assert_equal(D[2], 4)
P, D = nx.goldberg_radzik(self.MXG4, 0)
assert_equal(P[2], 1)
assert_equal(D[2], 4)
def _check_resource(r):
# check resource r's feasibility along a path
def __get_weight(i, j, attr_dict):
# returns number to use as weight for the algorithm
return attr_dict['res_cost'][r]
# Get paths from source to all other nodes
length_s, path_s = single_source_bellman_ford(G,
'Source',
weight=__get_weight)
length_t, path_t = single_source_bellman_ford(G.reverse(copy=True),
'Sink',
weight=__get_weight)
try:
# Collect nodes in paths that violate the resource bounds
# see note above
nodes_source.update({
path_s[key][-1]: (val, r)
for key, val in length_s.items()
if (key != 'Source') and (val > max_res[r])
})
nodes_sink.update({
path_t[key][-1]: (val, r)
for key, val in length_t.items()
if (key != 'Sink') and (val > max_res[r])
})
except IndexError: # No nodes violate resource limits
pass
def test_multigraph(self):
assert_equal(nx.bellman_ford_path(self.MXG, 's', 'v'), ['s', 'x', 'u', 'v'])
assert_equal(nx.bellman_ford_path_length(self.MXG, 's', 'v'), 9)
assert_equal(nx.single_source_bellman_ford_path(self.MXG, 's')['v'], ['s', 'x', 'u', 'v'])
assert_equal(nx.single_source_bellman_ford_path_length(self.MXG, 's')['v'], 9)
D, P = nx.single_source_bellman_ford(self.MXG, 's', target='v')
assert_equal(D, 9)
assert_equal(P, ['s', 'x', 'u', 'v'])
P, D = nx.bellman_ford_predecessor_and_distance(self.MXG, 's')
assert_equal(P['v'], ['u'])
assert_equal(D['v'], 9)
P, D = nx.goldberg_radzik(self.MXG, 's')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
assert_equal(nx.bellman_ford_path(self.MXG4, 0, 2), [0, 1, 2])
assert_equal(nx.bellman_ford_path_length(self.MXG4, 0, 2), 4)
assert_equal(nx.single_source_bellman_ford_path(self.MXG4, 0)[2], [0, 1, 2])
assert_equal(nx.single_source_bellman_ford_path_length(self.MXG4, 0)[2], 4)
D, P = nx.single_source_bellman_ford(self.MXG4, 0, target=2)
assert_equal(D, 4)
assert_equal(P, [0, 1, 2])
P, D = nx.bellman_ford_predecessor_and_distance(self.MXG4, 0)
assert_equal(P[2], [1])
assert_equal(D[2], 4)
P, D = nx.goldberg_radzik(self.MXG4, 0)
assert_equal(P[2], 1)
assert_equal(D[2], 4)
def test_others(self):
assert_equal(nx.bellman_ford_path(self.XG, 's', 'v'), ['s', 'x', 'u', 'v'])
assert_equal(nx.bellman_ford_path_length(self.XG, 's', 'v'), 9)
assert_equal(nx.single_source_bellman_ford_path(self.XG, 's')['v'], ['s', 'x', 'u', 'v'])
assert_equal(dict(nx.single_source_bellman_ford_path_length(self.XG, 's'))['v'], 9)
D, P = nx.single_source_bellman_ford(self.XG, 's', target='v')
assert_equal(D['v'], 9)
assert_equal(P['v'], ['s', 'x', 'u', 'v'])
(P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, 's')
assert_equal(P['v'], ['u'])
assert_equal(D['v'], 9)
(P, D) = nx.goldberg_radzik(self.XG, 's')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
G = nx.path_graph(4)
assert_equal(nx.single_source_bellman_ford_path(G, 0),
{0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]})
assert_equal(dict(nx.single_source_bellman_ford_path_length(G, 0)),
{0: 0, 1: 1, 2: 2, 3: 3})
assert_equal(nx.single_source_bellman_ford(G, 0),
({0: 0, 1: 1, 2: 2, 3: 3}, {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0),
({0: [None], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3}))
assert_equal(nx.goldberg_radzik(G, 0),
({0: None, 1: 0, 2: 1, 3: 2}, {0: 0, 1: 1, 2: 2, 3: 3}))
assert_equal(nx.single_source_bellman_ford_path(G, 3),
{0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]})
assert_equal(dict(nx.single_source_bellman_ford_path_length(G, 3)),
{0: 3, 1: 2, 2: 1, 3: 0})
assert_equal(nx.single_source_bellman_ford(G, 3),
({0: 3, 1: 2, 2: 1, 3: 0}, {0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 3),
({0: [1], 1: [2], 2: [3], 3: [None]}, {0: 3, 1: 2, 2: 1, 3: 0}))
assert_equal(nx.goldberg_radzik(G, 3),
({0: 1, 1: 2, 2: 3, 3: None}, {0: 3, 1: 2, 2: 1, 3: 0}))
G = nx.grid_2d_graph(2, 2)
dist, path = nx.single_source_bellman_ford(G, (0, 0))
assert_equal(sorted(dist.items()),
[((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 2)])
assert_equal(sorted(path.items()),
[((0, 0), [(0, 0)]), ((0, 1), [(0, 0), (0, 1)]),
((1, 0), [(0, 0), (1, 0)]), ((1, 1), [(0, 0), (0, 1), (1, 1)])])
pred, dist = nx.bellman_ford_predecessor_and_distance(G, (0, 0))
assert_equal(sorted(pred.items()),
[((0, 0), [None]), ((0, 1), [(0, 0)]),
((1, 0), [(0, 0)]), ((1, 1), [(0, 1), (1, 0)])])
assert_equal(sorted(dist.items()),
[((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 2)])
pred, dist = nx.goldberg_radzik(G, (0, 0))
assert_equal(sorted(pred.items()),
[((0, 0), None), ((0, 1), (0, 0)),
((1, 0), (0, 0)), ((1, 1), (0, 1))])
assert_equal(sorted(dist.items()),
[((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 2)])
def test_path_graph(self):
G = nx.path_graph(4)
assert nx.single_source_bellman_ford_path(G, 0) == {
0: [0],
1: [0, 1],
2: [0, 1, 2],
3: [0, 1, 2, 3],
}
assert nx.single_source_bellman_ford_path_length(G, 0) == {
0: 0,
1: 1,
2: 2,
3: 3,
}
assert nx.single_source_bellman_ford(G, 0) == (
{0: 0, 1: 1, 2: 2, 3: 3},
{0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]},
)
assert nx.bellman_ford_predecessor_and_distance(G, 0) == (
{0: [], 1: [0], 2: [1], 3: [2]},
{0: 0, 1: 1, 2: 2, 3: 3},
)
assert nx.goldberg_radzik(G, 0) == (
{0: None, 1: 0, 2: 1, 3: 2},
{0: 0, 1: 1, 2: 2, 3: 3},
)
assert nx.single_source_bellman_ford_path(G, 3) == {
0: [3, 2, 1, 0],
1: [3, 2, 1],
2: [3, 2],
3: [3],
}
assert nx.single_source_bellman_ford_path_length(G, 3) == {
0: 3,
1: 2,
2: 1,
3: 0,
}
assert nx.single_source_bellman_ford(G, 3) == (
{0: 3, 1: 2, 2: 1, 3: 0},
{0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]},
)
assert nx.bellman_ford_predecessor_and_distance(G, 3) == (
{0: [1], 1: [2], 2: [3], 3: []},
{0: 3, 1: 2, 2: 1, 3: 0},
)
assert nx.goldberg_radzik(G, 3) == (
{0: 1, 1: 2, 2: 3, 3: None},
{0: 3, 1: 2, 2: 1, 3: 0},
)
def optimal_path(g, s, t):
"""BEHAVIOUR: Given a graph g, a source date s and a target date t, find
the path from any currency at s to any currency at t that maximises profit.
PRECONDITIONS: Dates s and t are present in g with t after s. g only has
four currencies USDEUR, USDJPY, USDGBP and USDAUD. g has nodes and edges in
the form produced by make_graph.
POSTCONDITION: Returns a float which represents the profit as a percentage
and a list of nodes which represents the optimal path. If g has no path
which increases value, returns 0 and an empty list."""
currencies = ["USDEUR", "USDJPY", "USDGBP", "USDAUD"]
length = 0
path = []
for c in currencies:
for x in currencies:
t_length, t_path = nx.single_source_bellman_ford(g,
source=s + c,
target=t + x,
weight="weight")
# Our graphs can never have negative weight cycles so in theory
# Dijsktra should work. However, nx.dijsktra is not guaranteed to
# work for negative or float edge weights and we have both.
if t_length < length:
length = t_length
path = t_path
# Updates length and path if a more profitable path is found
# with a different source or target.
multiplier = math.exp(-length)
profit = multiplier * 100 - 100
return profit, path
def test_single_node_graph(self):
G = nx.DiGraph()
G.add_node(0)
assert nx.single_source_bellman_ford_path(G, 0) == {0: [0]}
assert nx.single_source_bellman_ford_path_length(G, 0) == {0: 0}
assert nx.single_source_bellman_ford(G, 0) == ({0: 0}, {0: [0]})
assert nx.bellman_ford_predecessor_and_distance(G, 0) == ({0: []}, {0: 0})
assert nx.goldberg_radzik(G, 0) == ({0: None}, {0: 0})
def test_single_node_graph(self):
G = nx.DiGraph()
G.add_node(0)
assert_equal(nx.single_source_bellman_ford_path(G, 0), {0: [0]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 0), {0: 0})
assert_equal(nx.single_source_bellman_ford(G, 0), ({0: 0}, {0: [0]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({0: []}, {0: 0}))
assert_equal(nx.goldberg_radzik(G, 0), ({0: None}, {0: 0}))
def cal_dist(Gn, q, p):
for edge in G.edges:
i, j = edge[0], edge[1]
G[i][j]['length'] = max(G[i][j]['reduce_cost'], 0)
length, path = nx.single_source_bellman_ford(G, q, weight='length')
for i in length:
G.node[i]['potential'] = G.node[i]['potential'] - length[i]
return path[p]
def test_single_node_graph(self):
G = nx.DiGraph()
G.add_node(0)
assert_equal(nx.single_source_bellman_ford_path(G, 0), {0: [0]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 0), {0: 0})
assert_equal(nx.single_source_bellman_ford(G, 0), ({0: 0}, {0: [0]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({0: [None]}, {0: 0}))
assert_equal(nx.goldberg_radzik(G, 0), ({0: None}, {0: 0}))
assert_raises(nx.NodeNotFound, nx.bellman_ford_predecessor_and_distance, G, 1)
assert_raises(nx.NodeNotFound, nx.goldberg_radzik, G, 1)
def timeComparison(self, total_iterations):
with open('Gnutella31.csv', mode='a+') as csv_file:
fieldnames = ['Start', 'End', 'Algorithm', 'HopNumber', 'Time']
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
i = 1
while (i < total_iterations):
node1 = RandomNodes(self.getMainGraph())
node2 = RandomNodes(self.getMainGraph())
print("From ", node1, " To ", node2, "İteration Number : ", i)
if (self.checkPath(node1, node2) == True):
start = time.process_time()
self.astar = astarpath(self.getMainGraph(), node1, node2)
time1 = time.process_time() - start
writer.writerow({
'Start': node1,
'End': node2,
'Algorithm': 'Astar',
'HopNumber': len(self.astar),
'Time': time1
})
start = time.process_time()
self.dij = nx.single_source_dijkstra(
self.getMainGraph(), node1, node2)
time2 = time.process_time() - start
writer.writerow({
'Start': node1,
'End': node2,
'Algorithm': 'Dijkstra',
'HopNumber': len(self.dij[1]),
'Time': time2
})
start = time.process_time()
self.bellmanford = nx.single_source_bellman_ford(
self.getMainGraph(), node1, node2)
time3 = time.process_time() - start
writer.writerow({
'Start': node1,
'End': node2,
'Algorithm': 'Bellman-Ford',
'HopNumber': len(self.bellmanford[1]),
'Time': time3
})
i = i + 1
else:
i = i + 1
continue
subGraph = GraphCreator(self.astar)
neighbor_list = AllNeighbors(self.getMainGraph(), self.astar)
GraphWithNeighbors(subGraph, neighbor_list, self.astar)
def test_path_graph(self):
G = nx.path_graph(4)
assert_equal(nx.single_source_bellman_ford_path(G, 0),
{0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 0),
{0: 0, 1: 1, 2: 2, 3: 3})
assert_equal(nx.single_source_bellman_ford(G, 0),
({0: 0, 1: 1, 2: 2, 3: 3}, {0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0),
({0: [], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3}))
assert_equal(nx.goldberg_radzik(G, 0),
({0: None, 1: 0, 2: 1, 3: 2}, {0: 0, 1: 1, 2: 2, 3: 3}))
assert_equal(nx.single_source_bellman_ford_path(G, 3),
{0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 3),
{0: 3, 1: 2, 2: 1, 3: 0})
assert_equal(nx.single_source_bellman_ford(G, 3),
({0: 3, 1: 2, 2: 1, 3: 0}, {0: [3, 2, 1, 0], 1: [3, 2, 1], 2: [3, 2], 3: [3]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 3),
({0: [1], 1: [2], 2: [3], 3: []}, {0: 3, 1: 2, 2: 1, 3: 0}))
assert_equal(nx.goldberg_radzik(G, 3),
({0: 1, 1: 2, 2: 3, 3: None}, {0: 3, 1: 2, 2: 1, 3: 0}))
def test_others(self):
assert nx.bellman_ford_path(self.XG, 's', 'v') == ['s', 'x', 'u', 'v']
assert nx.bellman_ford_path_length(self.XG, 's', 'v') == 9
assert nx.single_source_bellman_ford_path(self.XG, 's')['v'] == ['s', 'x', 'u', 'v']
assert nx.single_source_bellman_ford_path_length(self.XG, 's')['v'] == 9
D, P = nx.single_source_bellman_ford(self.XG, 's', target='v')
assert D == 9
assert P == ['s', 'x', 'u', 'v']
(P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, 's')
assert P['v'] == ['u']
assert D['v'] == 9
(P, D) = nx.goldberg_radzik(self.XG, 's')
assert P['v'] == 'u'
assert D['v'] == 9
def test_others(self):
assert_equal(nx.bellman_ford_path(self.XG, 's', 'v'), ['s', 'x', 'u', 'v'])
assert_equal(nx.bellman_ford_path_length(self.XG, 's', 'v'), 9)
assert_equal(nx.single_source_bellman_ford_path(self.XG, 's')['v'], ['s', 'x', 'u', 'v'])
assert_equal(nx.single_source_bellman_ford_path_length(self.XG, 's')['v'], 9)
D, P = nx.single_source_bellman_ford(self.XG, 's', target='v')
assert_equal(D, 9)
assert_equal(P, ['s', 'x', 'u', 'v'])
(P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, 's')
assert_equal(P['v'], ['u'])
assert_equal(D['v'], 9)
(P, D) = nx.goldberg_radzik(self.XG, 's')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
def test_others(self):
assert_equal(nx.bellman_ford_path(self.XG, 's', 'v'), ['s', 'x', 'u', 'v'])
assert_equal(nx.bellman_ford_path_length(self.XG, 's', 'v'), 9)
assert_equal(nx.single_source_bellman_ford_path(self.XG, 's')['v'], ['s', 'x', 'u', 'v'])
assert_equal(nx.single_source_bellman_ford_path_length(self.XG, 's')['v'], 9)
D, P = nx.single_source_bellman_ford(self.XG, 's', target='v')
assert_equal(D, 9)
assert_equal(P, ['s', 'x', 'u', 'v'])
(P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, 's')
assert_equal(P['v'], ['u'])
assert_equal(D['v'], 9)
(P, D) = nx.goldberg_radzik(self.XG, 's')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
def test_not_connected(self):
G = nx.complete_graph(6)
G.add_edge(10, 11)
G.add_edge(10, 12)
assert_equal(nx.single_source_bellman_ford_path(G, 0),
{0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 0),
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})
assert_equal(nx.single_source_bellman_ford(G, 0),
({0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
{0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0),
({0: [None], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
assert_equal(nx.goldberg_radzik(G, 0),
({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
# not connected, with a component not containing the source that
# contains a negative cost cycle.
G = nx.complete_graph(6)
G.add_edges_from([('A', 'B', {'load': 3}),
('B', 'C', {'load': -10}),
('C', 'A', {'load': 2})])
assert_equal(nx.single_source_bellman_ford_path(G, 0, weight='load'),
{0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 0, weight='load'),
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})
assert_equal(nx.single_source_bellman_ford(G, 0, weight='load'),
({0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
{0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0, weight='load'),
({0: [None], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
assert_equal(nx.goldberg_radzik(G, 0, weight='load'),
({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
def test_not_connected(self):
G = nx.complete_graph(6)
G.add_edge(10, 11)
G.add_edge(10, 12)
assert_equal(nx.single_source_bellman_ford_path(G, 0),
{0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 0),
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})
assert_equal(nx.single_source_bellman_ford(G, 0),
({0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
{0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0),
({0: [], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
assert_equal(nx.goldberg_radzik(G, 0),
({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
# not connected, with a component not containing the source that
# contains a negative cost cycle.
G = nx.complete_graph(6)
G.add_edges_from([('A', 'B', {'load': 3}),
('B', 'C', {'load': -10}),
('C', 'A', {'load': 2})])
assert_equal(nx.single_source_bellman_ford_path(G, 0, weight='load'),
{0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 0, weight='load'),
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})
assert_equal(nx.single_source_bellman_ford(G, 0, weight='load'),
({0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
{0: [0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0, weight='load'),
({0: [], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
assert_equal(nx.goldberg_radzik(G, 0, weight='load'),
({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
def test_others(self):
assert nx.bellman_ford_path(self.XG, "s", "v") == ["s", "x", "u", "v"]
assert nx.bellman_ford_path_length(self.XG, "s", "v") == 9
assert nx.single_source_bellman_ford_path(self.XG, "s")["v"] == [
"s",
"x",
"u",
"v",
]
assert nx.single_source_bellman_ford_path_length(self.XG, "s")["v"] == 9
D, P = nx.single_source_bellman_ford(self.XG, "s", target="v")
assert D == 9
assert P == ["s", "x", "u", "v"]
(P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, "s")
assert P["v"] == ["u"]
assert D["v"] == 9
(P, D) = nx.goldberg_radzik(self.XG, "s")
assert P["v"] == "u"
assert D["v"] == 9
def filter_shortest_path(read_df, aligner="minimap2"):
aligns = read_df[read_df.pass_filter]
num_aligns = len(aligns)
if num_aligns < 2:
# can't build a graph, so nothing is filtered by this method
return read_df
if aligner == "minimap2":
gap_fn = minimap_gapscore
elif aligner == "bwa":
gap_fn = bwa_gapscore
else:
raise ValueError(f"Unrecognised aligner: {aligner}")
graph = create_align_graph(aligns, gap_fn)
distance, shortest_path = nx.single_source_bellman_ford(graph, "ROOT", "SINK")
for idx in aligns.index:
if idx not in shortest_path:
read_df.at[idx, "pass_filter"] = False
read_df.at[idx, "filter_reason"] = "not_on_shortest_path"
return read_df
def test_negative_weight_cycle(self):
G = nx.cycle_graph(5, create_using=nx.DiGraph())
G.add_edge(1, 2, weight=-7)
for i in range(5):
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, i)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, i)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, i)
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, i)
assert_raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, i)
G = nx.cycle_graph(5) # undirected Graph
G.add_edge(1, 2, weight=-3)
for i in range(5):
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, i)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, i)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, i)
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, i)
assert_raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, i)
G = nx.DiGraph([(1, 1, {'weight': -1})])
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, 1)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, 1)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, 1)
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, 1)
assert_raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, 1)
# no negative cycle but negative weight
G = nx.cycle_graph(5, create_using=nx.DiGraph())
G.add_edge(1, 2, weight=-3)
assert_equal(nx.single_source_bellman_ford_path(G, 0),
{0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3], 4: [0, 1, 2, 3, 4]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 0),
{0: 0, 1: 1, 2: -2, 3: -1, 4: 0})
assert_equal(nx.single_source_bellman_ford(G, 0),
({0: 0, 1: 1, 2: -2, 3: -1, 4: 0},
{0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3], 4: [0, 1, 2, 3, 4]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0),
({0: [None], 1: [0], 2: [1], 3: [2], 4: [3]},
{0: 0, 1: 1, 2: -2, 3: -1, 4: 0}))
assert_equal(nx.goldberg_radzik(G, 0),
({0: None, 1: 0, 2: 1, 3: 2, 4: 3},
{0: 0, 1: 1, 2: -2, 3: -1, 4: 0}))
def test_negative_weight_cycle(self):
G = nx.cycle_graph(5, create_using=nx.DiGraph())
G.add_edge(1, 2, weight=-7)
for i in range(5):
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, i)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, i)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, i)
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, i)
assert_raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, i)
G = nx.cycle_graph(5) # undirected Graph
G.add_edge(1, 2, weight=-3)
for i in range(5):
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, i)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, i)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, i)
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, i)
assert_raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, i)
G = nx.DiGraph([(1, 1, {'weight': -1})])
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path, G, 1)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford_path_length, G, 1)
assert_raises(nx.NetworkXUnbounded, nx.single_source_bellman_ford, G, 1)
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford_predecessor_and_distance, G, 1)
assert_raises(nx.NetworkXUnbounded, nx.goldberg_radzik, G, 1)
# no negative cycle but negative weight
G = nx.cycle_graph(5, create_using=nx.DiGraph())
G.add_edge(1, 2, weight=-3)
assert_equal(nx.single_source_bellman_ford_path(G, 0),
{0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3], 4: [0, 1, 2, 3, 4]})
assert_equal(nx.single_source_bellman_ford_path_length(G, 0),
{0: 0, 1: 1, 2: -2, 3: -1, 4: 0})
assert_equal(nx.single_source_bellman_ford(G, 0),
({0: 0, 1: 1, 2: -2, 3: -1, 4: 0},
{0: [0], 1: [0, 1], 2: [0, 1, 2], 3: [0, 1, 2, 3], 4: [0, 1, 2, 3, 4]}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0),
({0: [], 1: [0], 2: [1], 3: [2], 4: [3]},
{0: 0, 1: 1, 2: -2, 3: -1, 4: 0}))
assert_equal(nx.goldberg_radzik(G, 0),
({0: None, 1: 0, 2: 1, 3: 2, 4: 3},
{0: 0, 1: 1, 2: -2, 3: -1, 4: 0}))
def skeleton_path(arr, base_id, dist, slice_interval):
slice_ids = (dist / slice_interval).astype(int)
G_skeleton = nx.Graph()
uids = np.unique(slice_ids)
pair = {}
pair_dist = {}
for u in range(len(uids[:-1])):
mask_current = np.where(slice_ids == uids[u])[0]
mask_next = np.where(slice_ids >= uids[u])[0]
nbr_dist, nbr_ids = tls.utility.set_nbrs_knn(arr[mask_current],
arr[mask_next],
1,
return_dist=True)
nbr_ids = nbr_ids.astype(int)
for i, (ni, nd) in enumerate(zip(nbr_ids, nbr_dist)):
if nd > 0:
current_id = mask_next[i]
back_id = mask_current[ni][0]
if current_id in pair:
pair[current_id].append(back_id)
pair_dist[current_id].append(nd)
else:
pair[current_id] = [back_id]
pair_dist[current_id] = [nd]
# WOOD STRUCTURE UP UNTIL HERE
for k, v in pair.iteritems():
d = pair_dist[k]
min_id = np.argmin(d)
G_skeleton.add_weighted_edges_from([(k, v[min_id], d[min_id])])
path_distance, path_ids = nx.single_source_bellman_ford(
G_skeleton, base_id)
return path_ids, path_distance
def test_4_cycle(self):
# 4-cycle
G = nx.Graph([(0,1),(1,2),(2,3),(3,0)])
dist, path = nx.single_source_bellman_ford(G, 0)
assert_equal(dist, {0: 0, 1: 1, 2: 2, 3: 1})
assert_equal(path[0],[0])
assert_equal(path[1],[0,1])
assert_true(path[2] in [[0,1,2],[0,3,2]])
assert_equal(path[3],[0,3])
pred, dist = nx.bellman_ford_predecessor_and_distance(G, 0)
assert_equal(pred[0],[None])
assert_equal(pred[1],[0])
assert_true(pred[2] in [[1,3],[3,1]])
assert_equal(pred[3],[0])
assert_equal(dist, {0: 0, 1: 1, 2: 2, 3: 1})
pred, dist = nx.goldberg_radzik(G, 0)
assert_equal(pred[0],None)
assert_equal(pred[1],0)
assert_true(pred[2] in [1,3])
assert_equal(pred[3],0)
assert_equal(dist, {0: 0, 1: 1, 2: 2, 3: 1})
def test_4_cycle(self):
# 4-cycle
G = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 0)])
dist, path = nx.single_source_bellman_ford(G, 0)
assert_equal(dist, {0: 0, 1: 1, 2: 2, 3: 1})
assert_equal(path[0], [0])
assert_equal(path[1], [0, 1])
assert_true(path[2] in [[0, 1, 2], [0, 3, 2]])
assert_equal(path[3], [0, 3])
pred, dist = nx.bellman_ford_predecessor_and_distance(G, 0)
assert_equal(pred[0], [])
assert_equal(pred[1], [0])
assert_true(pred[2] in [[1, 3], [3, 1]])
assert_equal(pred[3], [0])
assert_equal(dist, {0: 0, 1: 1, 2: 2, 3: 1})
pred, dist = nx.goldberg_radzik(G, 0)
assert_equal(pred[0], None)
assert_equal(pred[1], 0)
assert_true(pred[2] in [1, 3])
assert_equal(pred[3], 0)
assert_equal(dist, {0: 0, 1: 1, 2: 2, 3: 1})
def test_4_cycle(self):
# 4-cycle
G = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 0)])
dist, path = nx.single_source_bellman_ford(G, 0)
assert dist == {0: 0, 1: 1, 2: 2, 3: 1}
assert path[0] == [0]
assert path[1] == [0, 1]
assert path[2] in [[0, 1, 2], [0, 3, 2]]
assert path[3] == [0, 3]
pred, dist = nx.bellman_ford_predecessor_and_distance(G, 0)
assert pred[0] == []
assert pred[1] == [0]
assert pred[2] in [[1, 3], [3, 1]]
assert pred[3] == [0]
assert dist == {0: 0, 1: 1, 2: 2, 3: 1}
pred, dist = nx.goldberg_radzik(G, 0)
assert pred[0] is None
assert pred[1] == 0
assert pred[2] in [1, 3]
assert pred[3] == 0
assert dist == {0: 0, 1: 1, 2: 2, 3: 1}
def test_others(self):
assert_equal(nx.bellman_ford_path(self.XG, 's', 'v'),
['s', 'x', 'u', 'v'])
assert_equal(nx.bellman_ford_path_length(self.XG, 's', 'v'), 9)
assert_equal(
nx.single_source_bellman_ford_path(self.XG, 's')['v'],
['s', 'x', 'u', 'v'])
assert_equal(
dict(nx.single_source_bellman_ford_path_length(self.XG, 's'))['v'],
9)
D, P = nx.single_source_bellman_ford(self.XG, 's', target='v')
assert_equal(D['v'], 9)
assert_equal(P['v'], ['s', 'x', 'u', 'v'])
(P, D) = nx.bellman_ford_predecessor_and_distance(self.XG, 's')
assert_equal(P['v'], ['u'])
assert_equal(D['v'], 9)
(P, D) = nx.goldberg_radzik(self.XG, 's')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
G = nx.path_graph(4)
assert_equal(nx.single_source_bellman_ford_path(G, 0), {
0: [0],
1: [0, 1],
2: [0, 1, 2],
3: [0, 1, 2, 3]
})
assert_equal(dict(nx.single_source_bellman_ford_path_length(G, 0)), {
0: 0,
1: 1,
2: 2,
3: 3
})
assert_equal(nx.single_source_bellman_ford(G, 0), ({
0: 0,
1: 1,
2: 2,
3: 3
}, {
0: [0],
1: [0, 1],
2: [0, 1, 2],
3: [0, 1, 2, 3]
}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({
0: [None],
1: [0],
2: [1],
3: [2]
}, {
0: 0,
1: 1,
2: 2,
3: 3
}))
assert_equal(nx.goldberg_radzik(G, 0), ({
0: None,
1: 0,
2: 1,
3: 2
}, {
0: 0,
1: 1,
2: 2,
3: 3
}))
assert_equal(nx.single_source_bellman_ford_path(G, 3), {
0: [3, 2, 1, 0],
1: [3, 2, 1],
2: [3, 2],
3: [3]
})
assert_equal(dict(nx.single_source_bellman_ford_path_length(G, 3)), {
0: 3,
1: 2,
2: 1,
3: 0
})
assert_equal(nx.single_source_bellman_ford(G, 3), ({
0: 3,
1: 2,
2: 1,
3: 0
}, {
0: [3, 2, 1, 0],
1: [3, 2, 1],
2: [3, 2],
3: [3]
}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 3), ({
0: [1],
1: [2],
2: [3],
3: [None]
}, {
0: 3,
1: 2,
2: 1,
3: 0
}))
assert_equal(nx.goldberg_radzik(G, 3), ({
0: 1,
1: 2,
2: 3,
3: None
}, {
0: 3,
1: 2,
2: 1,
3: 0
}))
G = nx.grid_2d_graph(2, 2)
dist, path = nx.single_source_bellman_ford(G, (0, 0))
assert_equal(sorted(dist.items()), [((0, 0), 0), ((0, 1), 1),
((1, 0), 1), ((1, 1), 2)])
assert_equal(sorted(path.items()), [((0, 0), [(0, 0)]),
((0, 1), [(0, 0), (0, 1)]),
((1, 0), [(0, 0), (1, 0)]),
((1, 1), [(0, 0), (0, 1),
(1, 1)])])
pred, dist = nx.bellman_ford_predecessor_and_distance(G, (0, 0))
assert_equal(sorted(pred.items()), [((0, 0), [None]),
((0, 1), [(0, 0)]),
((1, 0), [(0, 0)]),
((1, 1), [(0, 1), (1, 0)])])
assert_equal(sorted(dist.items()), [((0, 0), 0), ((0, 1), 1),
((1, 0), 1), ((1, 1), 2)])
pred, dist = nx.goldberg_radzik(G, (0, 0))
assert_equal(sorted(pred.items()), [((0, 0), None), ((0, 1), (0, 0)),
((1, 0), (0, 0)),
((1, 1), (0, 1))])
assert_equal(sorted(dist.items()), [((0, 0), 0), ((0, 1), 1),
((1, 0), 1), ((1, 1), 2)])
def creategraph(algo, data):
file = data
a1 = []
a2 = []
a3 = []
a4 = []
a5 = []
splat = file.split("\r\n\r\n")
for number, section in enumerate(splat, 1):
if number % 5 == 1:
a1 += [section]
elif number % 5 == 2:
a2 += [section]
elif number % 5 == 3:
a3 += [section]
elif number % 5 == 4:
a4 += [section]
elif number % 5 == 0:
a5 += [section]
a2 = int(a2[0])
a5 = int(a5[0])
Ad = adjency_matrix(a4, a2)
G = nx.from_numpy_matrix(Ad)
labels = []
a3 = a3[0].split("\r\n")
Xn = []
Yn = []
for i in range(0, a2):
a3[i] = a3[i].split("\t")
Xn.append(float(a3[i][1]))
Yn.append(float(a3[i][2]))
for i in range(0, a2):
labels.append(i)
if algo == "Prims":
mst = tree.minimum_spanning_edges(G, algorithm='prim', data=False)
path = list(mst)
length = 0
for i in range(0, len(path)):
length = length + Ad[path[i][0]][path[i][1]]
title = "Prims Cost : " + str(length)
Xe = []
Ye = []
Xe2 = []
Ye2 = []
for e in G.edges():
for i in range(0, len(path) - 1):
if (e[0] == path[i][0] and e[1] == path[i + 1][1]):
Xe2.extend([Xn[e[0]], Xn[e[1]], None])
Ye2.extend([Yn[e[0]], Yn[e[1]], None])
Xe.extend([Xn[e[0]], Xn[e[1]], None])
Ye.extend([Yn[e[0]], Yn[e[1]], None])
elif algo == "Kruskals":
mst = tree.minimum_spanning_edges(G, algorithm='prim', data=False)
path = list(mst)
length = 0
for i in range(0, len(path)):
length = length + Ad[path[i][0]][path[i][1]]
title = "Kruskal Cost : " + str(length)
Xe = []
Ye = []
Xe2 = []
Ye2 = []
for e in G.edges():
for i in range(0, len(path) - 1):
if (e[0] == path[i][0] and e[1] == path[i + 1][1]):
Xe2.extend([Xn[e[0]], Xn[e[1]], None])
Ye2.extend([Yn[e[0]], Yn[e[1]], None])
Xe.extend([Xn[e[0]], Xn[e[1]], None])
Ye.extend([Yn[e[0]], Yn[e[1]], None])
elif algo == "Dijkstra":
length, path = nx.bidirectional_dijkstra(G, a5, a2 - 1)
title = "Dijkstra Cost : " + str(length)
Xe = []
Ye = []
Xe2 = []
Ye2 = []
for e in G.edges():
for i in range(0, len(path) - 1):
if (e[0] == path[i] and e[1] == path[i + 1]):
Xe2.extend([Xn[e[0]], Xn[e[1]], None])
Ye2.extend([Yn[e[0]], Yn[e[1]], None])
Xe.extend([Xn[e[0]], Xn[e[1]], None])
Ye.extend([Yn[e[0]], Yn[e[1]], None])
elif algo == "Bellman Ford":
length, path = nx.single_source_bellman_ford(G, 6, a2 - 1)
title = "Bellman Ford Cost : " + str(length)
Xe = []
Ye = []
Xe2 = []
Ye2 = []
for e in G.edges():
for i in range(0, len(path) - 1):
if (e[0] == path[i] and e[1] == path[i + 1]):
Xe2.extend([Xn[e[0]], Xn[e[1]], None])
Ye2.extend([Yn[e[0]], Yn[e[1]], None])
Xe.extend([Xn[e[0]], Xn[e[1]], None])
Ye.extend([Yn[e[0]], Yn[e[1]], None])
elif algo == "Floyd Warshall":
path = nx.floyd_warshall_numpy(G)
np.fill_diagonal(path, path.max())
title = "Floyd Warshall Cost : " + str(path.min())
Xe = []
Ye = []
Xe2 = []
Ye2 = []
for e in G.edges():
Xe.extend([Xn[e[0]], Xn[e[1]], None])
Ye.extend([Yn[e[0]], Yn[e[1]], None])
elif algo == "Clustering":
c = nx.average_clustering(G)
title = "Clustering Cost : " + str(c)
Xe = []
Ye = []
Xe2 = []
Ye2 = []
for e in G.edges():
Xe.extend([Xn[e[0]], Xn[e[1]], None])
Ye.extend([Yn[e[0]], Yn[e[1]], None])
trace_nodes = dict(type='scatter',
x=Xn,
y=Yn,
mode='markers',
marker=dict(size=28, color='peru'),
text=labels,
hoverinfo='text')
trace_edges = dict(type='scatter',
mode='lines',
arrowstyle='->',
x=Xe,
y=Ye,
line=dict(width=1, color='royalblue'),
hoverinfo='none')
trace_edges2 = dict(type='scatter',
mode='lines',
x=Xe2,
y=Ye2,
line=dict(width=4.1, color="firebrick"),
hoverinfo='none')
axis = dict(
showline=True, # hide axis line, grid, ticklabels and title
zeroline=False,
showgrid=True,
showticklabels=True,
title='')
layout = dict(
title=title,
font=dict(family='Balto'),
showlegend=True,
xaxis=axis,
yaxis=axis,
)
annotations = []
for k in range(a2):
annotations.append(
dict(
text=labels[k],
x=Xn[k],
y=Yn[k], #this additional value is chosen by trial and error
xref='x1',
yref='y1',
font=dict(color='rgb(10,10,10)', size=14),
showarrow=False))
data = dict(data=[trace_edges, trace_edges2, trace_nodes], layout=layout)
data['layout'].update(annotations=annotations)
return data
def skeleton_path(centres, max_dist=.1, verbose=False):
"""
parameters
----------
max_dist; float (default .1)
maximum distance between nodes, designed to stop large gaps being spanned
i.e. it is better to have a disconnection than an unrealistic conncetion
"""
edges = pd.DataFrame(columns=['node1', 'node2', 'length'])
if verbose: print('generating graph...')
for i, row in tqdm(enumerate(centres.itertuples()),
total=len(centres),
disable=False if verbose else True):
# first node
if row.distance_from_base == centres.distance_from_base.min(): continue
n, dist = 3, np.inf
while n < 10 and dist > max_dist:
# between required incase of small gap in pc
nbrs = centres.loc[centres.slice_id.between(
row.slice_id - n, row.slice_id - 1)]
nbrs.loc[:, 'dist'] = np.linalg.norm(
np.array([row.cx, row.cy, row.cz]) -
nbrs[['cx', 'cy', 'cz']].values,
axis=1)
dist = nbrs.dist.min()
n += 1
if np.isnan(nbrs.dist.min()
): # prob an outlying cluster that can be removed
continue
edges = edges.append(
{
'node1':
int(row.node_id),
'node2':
int(nbrs.loc[nbrs.dist == nbrs.dist.min()].node_id.values[0]),
'length':
nbrs.dist.min()
},
ignore_index=True)
idx = centres.distance_from_base.idxmin()
base_id = centres.loc[idx].node_id
G_skeleton = nx.Graph()
G_skeleton.add_weighted_edges_from([(int(row.node1), int(row.node2),
row.length)
for row in edges.itertuples()])
path_distance, path_ids = nx.single_source_bellman_ford(
G_skeleton, base_id)
path_distance = {
k: v if not isinstance(v, np.ndarray) else v[0]
for k, v in path_distance.items()
}
centres.distance_from_base = centres.node_id.map(path_distance)
# required as sometimes pc2graph produces strange results
return path_distance, path_ids
create_using=nx.DiGraph())
fpath, fdist = fnx.single_source_shortest_path(frov_graph, src, \
return_distance=True)
FrovedisServer.shut_down()
except Exception as e:
sub_str = "sssp: negative cost cycle is detected!"
if sub_str in str(e):
exc1 = True
else:
print("status=Exception: " + str(e))
sys.exit(1)
#NetworkX
try:
nx_graph = nx.read_edgelist(DATASET, nodetype=np.int32, \
data=(("weight", float),), delimiter=' ', \
create_using=nx.DiGraph())
npath = nx.single_source_bellman_ford(nx_graph, src)
except Exception as e:
sub_str = "Negative cost cycle detected."
if sub_str in str(e):
exc2 = True
else:
print("status=Exception: " + str(e))
sys.exit(1)
if exc1 and exc2:
print("status=Passed")
else:
print("status=Failed")
def cal_potential(G):
length, path = nx.single_source_bellman_ford(G, 's', weight='c')
for i in length:
G.node[i]['potential'] = length[i]
def get_bellmanford(graph, src, dest):
return nx.single_source_bellman_ford(graph, src, dest)
def test_path_graph(self):
G = nx.path_graph(4)
assert_equal(nx.single_source_bellman_ford_path(G, 0), {
0: [0],
1: [0, 1],
2: [0, 1, 2],
3: [0, 1, 2, 3]
})
assert_equal(dict(nx.single_source_bellman_ford_path_length(G, 0)), {
0: 0,
1: 1,
2: 2,
3: 3
})
assert_equal(nx.single_source_bellman_ford(G, 0), ({
0: 0,
1: 1,
2: 2,
3: 3
}, {
0: [0],
1: [0, 1],
2: [0, 1, 2],
3: [0, 1, 2, 3]
}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({
0: [None],
1: [0],
2: [1],
3: [2]
}, {
0: 0,
1: 1,
2: 2,
3: 3
}))
assert_equal(nx.goldberg_radzik(G, 0), ({
0: None,
1: 0,
2: 1,
3: 2
}, {
0: 0,
1: 1,
2: 2,
3: 3
}))
assert_equal(nx.single_source_bellman_ford_path(G, 3), {
0: [3, 2, 1, 0],
1: [3, 2, 1],
2: [3, 2],
3: [3]
})
assert_equal(dict(nx.single_source_bellman_ford_path_length(G, 3)), {
0: 3,
1: 2,
2: 1,
3: 0
})
assert_equal(nx.single_source_bellman_ford(G, 3), ({
0: 3,
1: 2,
2: 1,
3: 0
}, {
0: [3, 2, 1, 0],
1: [3, 2, 1],
2: [3, 2],
3: [3]
}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 3), ({
0: [1],
1: [2],
2: [3],
3: [None]
}, {
0: 3,
1: 2,
2: 1,
3: 0
}))
assert_equal(nx.goldberg_radzik(G, 3), ({
0: 1,
1: 2,
2: 3,
3: None
}, {
0: 3,
1: 2,
2: 1,
3: 0
}))
def compute_all_pair_shortest_path(graphs_single_robot, trees_single_robot):
all_pairs_shortest_paths_per_robot = []
all_pairs_shortest_paths_per_robot_b = [
dict() for i in range(len(graphs_single_robot))
]
subgraph_nodes = [0] * len(graphs_single_robot)
for i in range(len(graphs_single_robot)):
all_pairs_shortest_paths_per_robot.append( \
nx.johnson(graphs_single_robot[i], weight='weight'))
subgraph_nodes[i] = random.sample(
graphs_single_robot[i].nodes,
math.ceil(len(graphs_single_robot[i].nodes) / 10))
if len(
subgraph_nodes[i]
) == 1: # single_source_bellman_ford gets stuck on single node graph, so this is an edge case
all_pairs_shortest_paths_per_robot_b[i][subgraph_nodes[i]
[0]] = dict()
all_pairs_shortest_paths_per_robot_b[i][subgraph_nodes[i][0]][
subgraph_nodes[i][0]] = [subgraph_nodes[i][0]]
else:
for j in range(len(subgraph_nodes[i])):
all_pairs_shortest_paths_per_robot_b[i][
subgraph_nodes[i][j]] = nx.single_source_bellman_ford(
graphs_single_robot[i],
subgraph_nodes[i][j],
target=None,
weight='weight')[1]
while len(all_pairs_shortest_paths_per_robot_b[i]) < len(
graphs_single_robot[i].nodes):
for node in list(all_pairs_shortest_paths_per_robot_b[i].keys()):
N = drrt_ao.adj(graphs_single_robot[i], node)
for neighbor in N:
if neighbor in all_pairs_shortest_paths_per_robot_b[i]:
continue
else:
all_pairs_shortest_paths_per_robot_b[i][
neighbor] = dict()
for key in all_pairs_shortest_paths_per_robot_b[i][
node].keys():
all_pairs_shortest_paths_per_robot_b[
i][neighbor][key] = list(
all_pairs_shortest_paths_per_robot_b[i]
[node][key]
) # attaching copy of the list of the neighbor
all_pairs_shortest_paths_per_robot_b[i][neighbor][
key].insert(0, neighbor)
if key == neighbor:
all_pairs_shortest_paths_per_robot_b[i][neighbor][
key] = all_pairs_shortest_paths_per_robot_b[
i][neighbor][key][:1]
for i in range(
len(graphs_single_robot)
): # A check to see the johnson and bellman ford dictionaries are equal
for key in all_pairs_shortest_paths_per_robot[i].keys():
if key not in all_pairs_shortest_paths_per_robot_b[i]:
print("check out")
else:
for inkey in all_pairs_shortest_paths_per_robot[i][key].keys():
if inkey not in all_pairs_shortest_paths_per_robot_b[i][
key]:
print("check in")
return all_pairs_shortest_paths_per_robot_b
def bellman_ford(G, initial_node, target_node, weight):
weight = Graph._weight(G, weight)
distance, route = nx.single_source_bellman_ford(G, initial_node,
target_node, weight)
return distance, route
def bellman_ford_explored(G, source, destination):
return " -> ".join(nx.single_source_bellman_ford(G, source)[1])
def test_not_connected(self):
G = nx.complete_graph(6)
G.add_edge(10, 11)
G.add_edge(10, 12)
assert nx.single_source_bellman_ford_path(G, 0) == {
0: [0],
1: [0, 1],
2: [0, 2],
3: [0, 3],
4: [0, 4],
5: [0, 5],
}
assert nx.single_source_bellman_ford_path_length(G, 0) == {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1,
}
assert nx.single_source_bellman_ford(G, 0) == (
{
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
},
{
0: [0],
1: [0, 1],
2: [0, 2],
3: [0, 3],
4: [0, 4],
5: [0, 5]
},
)
assert nx.bellman_ford_predecessor_and_distance(G, 0) == (
{
0: [],
1: [0],
2: [0],
3: [0],
4: [0],
5: [0]
},
{
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
},
)
assert nx.goldberg_radzik(G, 0) == (
{
0: None,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0
},
{
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
},
)
# not connected, with a component not containing the source that
# contains a negative cost cycle.
G = nx.complete_graph(6)
G.add_edges_from([
("A", "B", {
"load": 3
}),
("B", "C", {
"load": -10
}),
("C", "A", {
"load": 2
}),
])
assert nx.single_source_bellman_ford_path(G, 0, weight="load") == {
0: [0],
1: [0, 1],
2: [0, 2],
3: [0, 3],
4: [0, 4],
5: [0, 5],
}
assert nx.single_source_bellman_ford_path_length(G, 0,
weight="load") == {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1,
}
assert nx.single_source_bellman_ford(G, 0, weight="load") == (
{
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
},
{
0: [0],
1: [0, 1],
2: [0, 2],
3: [0, 3],
4: [0, 4],
5: [0, 5]
},
)
assert nx.bellman_ford_predecessor_and_distance(G, 0,
weight="load") == (
{
0: [],
1: [0],
2: [0],
3: [0],
4: [0],
5: [0]
},
{
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
},
)
assert nx.goldberg_radzik(G, 0, weight="load") == (
{
0: None,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0
},
{
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
},
)
