import pytest import networkx as nx from networkx.testing import almost_equal def validate_grid_path(r, c, s, t, p): assert isinstance(p, list) assert p[0] == s assert p[-1] == t s = ((s - 1) // c, (s - 1) % c) t = ((t - 1) // c, (t - 1) % c) assert len(p) == abs(t[0] - s[0]) + abs(t[1] - s[1]) + 1 p = [((u - 1) // c, (u - 1) % c) for u in p] for u in p: assert 0 <= u[0] < r assert 0 <= u[1] < c for u, v in zip(p[:-1], p[1:]): assert (abs(v[0] - u[0]), abs(v[1] - u[1])) in [(0, 1), (1, 0)] class TestGenericPath: @classmethod def setup_class(cls): from networkx import convert_node_labels_to_integers as cnlti cls.grid = cnlti(nx.grid_2d_graph(4, 4), first_label=1, ordering="sorted") cls.cycle = nx.cycle_graph(7) cls.directed_cycle = nx.cycle_graph(7, create_using=nx.DiGraph()) cls.neg_weights = nx.DiGraph() cls.neg_weights.add_edge(0, 1, weight=1) cls.neg_weights.add_edge(0, 2, weight=3) cls.neg_weights.add_edge(1, 3, weight=1) cls.neg_weights.add_edge(2, 3, weight=-2) def test_shortest_path(self): assert nx.shortest_path(self.cycle, 0, 3) == [0, 1, 2, 3] assert nx.shortest_path(self.cycle, 0, 4) == [0, 6, 5, 4] validate_grid_path(4, 4, 1, 12, nx.shortest_path(self.grid, 1, 12)) assert nx.shortest_path(self.directed_cycle, 0, 3) == [0, 1, 2, 3] # now with weights assert (nx.shortest_path(self.cycle, 0, 3, weight='weight') == [0, 1, 2, 3]) assert (nx.shortest_path(self.cycle, 0, 4, weight='weight') == [0, 6, 5, 4]) validate_grid_path(4, 4, 1, 12, nx.shortest_path(self.grid, 1, 12, weight='weight')) assert (nx.shortest_path(self.directed_cycle, 0, 3, weight='weight') == [0, 1, 2, 3]) # weights and method specified assert (nx.shortest_path(self.directed_cycle, 0, 3, weight='weight', method='dijkstra') == [0, 1, 2, 3]) assert (nx.shortest_path(self.directed_cycle, 0, 3, weight='weight', method='bellman-ford') == [0, 1, 2, 3]) # when Dijkstra's will probably (depending on precise implementation) # incorrectly return [0, 1, 3] instead assert (nx.shortest_path(self.neg_weights, 0, 3, weight='weight', method='bellman-ford') == [0, 2, 3]) # confirm bad method rejection pytest.raises(ValueError, nx.shortest_path, self.cycle, method='SPAM') # confirm absent source rejection pytest.raises(nx.NodeNotFound, nx.shortest_path, self.cycle, 8) def test_shortest_path_target(self): answer = {0: [0, 1], 1: [1], 2: [2, 1]} sp = nx.shortest_path(nx.path_graph(3), target=1) assert sp == answer # with weights sp = nx.shortest_path(nx.path_graph(3), target=1, weight='weight') assert sp == answer # weights and method specified sp = nx.shortest_path(nx.path_graph(3), target=1, weight='weight', method='dijkstra') assert sp == answer sp = nx.shortest_path(nx.path_graph(3), target=1, weight='weight', method='bellman-ford') assert sp == answer def test_shortest_path_length(self): assert nx.shortest_path_length(self.cycle, 0, 3) == 3 assert nx.shortest_path_length(self.grid, 1, 12) == 5 assert nx.shortest_path_length(self.directed_cycle, 0, 4) == 4 # now with weights assert (nx.shortest_path_length(self.cycle, 0, 3, weight='weight') == 3) assert (nx.shortest_path_length(self.grid, 1, 12, weight='weight') == 5) assert (nx.shortest_path_length(self.directed_cycle, 0, 4, weight='weight') == 4) # weights and method specified assert (nx.shortest_path_length(self.cycle, 0, 3, weight='weight', method='dijkstra') == 3) assert (nx.shortest_path_length(self.cycle, 0, 3, weight='weight', method='bellman-ford') == 3) # confirm bad method rejection pytest.raises(ValueError, nx.shortest_path_length, self.cycle, method='SPAM') # confirm absent source rejection pytest.raises(nx.NodeNotFound, nx.shortest_path_length, self.cycle, 8) def test_shortest_path_length_target(self): answer = {0: 1, 1: 0, 2: 1} sp = dict(nx.shortest_path_length(nx.path_graph(3), target=1)) assert sp == answer # with weights sp = nx.shortest_path_length(nx.path_graph(3), target=1, weight='weight') assert sp == answer # weights and method specified sp = nx.shortest_path_length(nx.path_graph(3), target=1, weight='weight', method='dijkstra') assert sp == answer sp = nx.shortest_path_length(nx.path_graph(3), target=1, weight='weight', method='bellman-ford') assert sp == answer def test_single_source_shortest_path(self): p = nx.shortest_path(self.cycle, 0) assert p[3] == [0, 1, 2, 3] assert 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 p[3] == [0, 1, 2, 3] assert 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 p[3] == [0, 1, 2, 3] assert p == nx.single_source_shortest_path(self.cycle, 0) p = nx.shortest_path(self.cycle, 0, method='bellman-ford', weight='weight') assert p[3] == [0, 1, 2, 3] assert p == nx.single_source_shortest_path(self.cycle, 0) def test_single_source_shortest_path_length(self): ans = dict(nx.shortest_path_length(self.cycle, 0)) assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert (ans == dict(nx.single_source_shortest_path_length(self.cycle, 0))) ans = dict(nx.shortest_path_length(self.grid, 1)) assert ans[16] == 6 # now with weights ans = dict(nx.shortest_path_length(self.cycle, 0, weight='weight')) assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict(nx.single_source_dijkstra_path_length( self.cycle, 0)) ans = dict(nx.shortest_path_length(self.grid, 1, weight='weight')) assert ans[16] == 6 # weights and method specified ans = dict(nx.shortest_path_length(self.cycle, 0, weight='weight', method='dijkstra')) assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict(nx.single_source_dijkstra_path_length( self.cycle, 0)) ans = dict(nx.shortest_path_length(self.cycle, 0, weight='weight', method='bellman-ford')) assert ans == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict(nx.single_source_bellman_ford_path_length( self.cycle, 0)) def test_all_pairs_shortest_path(self): p = nx.shortest_path(self.cycle) assert p[0][3] == [0, 1, 2, 3] assert p == dict(nx.all_pairs_shortest_path(self.cycle)) p = nx.shortest_path(self.grid) validate_grid_path(4, 4, 1, 12, p[1][12]) # now with weights p = nx.shortest_path(self.cycle, weight='weight') assert p[0][3] == [0, 1, 2, 3] assert p == dict(nx.all_pairs_dijkstra_path(self.cycle)) p = nx.shortest_path(self.grid, weight='weight') validate_grid_path(4, 4, 1, 12, p[1][12]) # weights and method specified p = nx.shortest_path(self.cycle, weight='weight', method='dijkstra') assert p[0][3] == [0, 1, 2, 3] assert p == dict(nx.all_pairs_dijkstra_path(self.cycle)) p = nx.shortest_path(self.cycle, weight='weight', method='bellman-ford') assert p[0][3] == [0, 1, 2, 3] assert p == dict(nx.all_pairs_bellman_ford_path(self.cycle)) def test_all_pairs_shortest_path_length(self): ans = dict(nx.shortest_path_length(self.cycle)) assert ans[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict(nx.all_pairs_shortest_path_length(self.cycle)) ans = dict(nx.shortest_path_length(self.grid)) assert ans[1][16] == 6 # now with weights ans = dict(nx.shortest_path_length(self.cycle, weight='weight')) assert ans[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict(nx.all_pairs_dijkstra_path_length(self.cycle)) ans = dict(nx.shortest_path_length(self.grid, weight='weight')) assert ans[1][16] == 6 # weights and method specified ans = dict(nx.shortest_path_length(self.cycle, weight='weight', method='dijkstra')) assert ans[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert ans == dict(nx.all_pairs_dijkstra_path_length(self.cycle)) ans = dict(nx.shortest_path_length(self.cycle, weight='weight', method='bellman-ford')) assert ans[0] == {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1} assert (ans == dict(nx.all_pairs_bellman_ford_path_length(self.cycle))) def test_has_path(self): G = nx.Graph() nx.add_path(G, range(3)) nx.add_path(G, range(3, 5)) assert nx.has_path(G, 0, 2) assert not nx.has_path(G, 0, 4) def test_all_shortest_paths(self): G = nx.Graph() nx.add_path(G, [0, 1, 2, 3]) nx.add_path(G, [0, 10, 20, 3]) assert ([[0, 1, 2, 3], [0, 10, 20, 3]] == sorted(nx.all_shortest_paths(G, 0, 3))) # with weights G = nx.Graph() nx.add_path(G, [0, 1, 2, 3]) nx.add_path(G, [0, 10, 20, 3]) assert ([[0, 1, 2, 3], [0, 10, 20, 3]] == sorted(nx.all_shortest_paths(G, 0, 3, weight='weight'))) # weights and method specified G = nx.Graph() nx.add_path(G, [0, 1, 2, 3]) nx.add_path(G, [0, 10, 20, 3]) assert ([[0, 1, 2, 3], [0, 10, 20, 3]] == sorted(nx.all_shortest_paths(G, 0, 3, weight='weight', method='dijkstra'))) G = nx.Graph() nx.add_path(G, [0, 1, 2, 3]) nx.add_path(G, [0, 10, 20, 3]) assert ([[0, 1, 2, 3], [0, 10, 20, 3]] == sorted(nx.all_shortest_paths(G, 0, 3, weight='weight', method='bellman-ford'))) def test_all_shortest_paths_raise(self): with pytest.raises(nx.NetworkXNoPath): G = nx.path_graph(4) G.add_node(4) list(nx.all_shortest_paths(G, 0, 4)) def test_bad_method(self): with pytest.raises(ValueError): G = nx.path_graph(2) list(nx.all_shortest_paths(G, 0, 1, weight='weight', method='SPAM')) class TestAverageShortestPathLength(object): def test_cycle_graph(self): ans = nx.average_shortest_path_length(nx.cycle_graph(7)) assert almost_equal(ans, 2) def test_path_graph(self): ans = nx.average_shortest_path_length(nx.path_graph(5)) assert almost_equal(ans, 2) def test_weighted(self): G = nx.Graph() nx.add_cycle(G, range(7), weight=2) ans = nx.average_shortest_path_length(G, weight='weight') assert almost_equal(ans, 4) G = nx.Graph() nx.add_path(G, range(5), weight=2) ans = nx.average_shortest_path_length(G, weight='weight') assert almost_equal(ans, 4) def test_specified_methods(self): G = nx.Graph() nx.add_cycle(G, range(7), weight=2) ans = nx.average_shortest_path_length(G, weight='weight', method='dijkstra') assert almost_equal(ans, 4) ans = nx.average_shortest_path_length(G, weight='weight', method='bellman-ford') assert almost_equal(ans, 4) ans = nx.average_shortest_path_length(G, weight='weight', method='floyd-warshall') assert almost_equal(ans, 4) G = nx.Graph() nx.add_path(G, range(5), weight=2) ans = nx.average_shortest_path_length(G, weight='weight', method='dijkstra') assert almost_equal(ans, 4) ans = nx.average_shortest_path_length(G, weight='weight', method='bellman-ford') assert almost_equal(ans, 4) ans = nx.average_shortest_path_length(G, weight='weight', method='floyd-warshall') assert almost_equal(ans, 4) def test_disconnected(self): g = nx.Graph() g.add_nodes_from(range(3)) g.add_edge(0, 1) pytest.raises(nx.NetworkXError, nx.average_shortest_path_length, g) g = g.to_directed() pytest.raises(nx.NetworkXError, nx.average_shortest_path_length, g) def test_trivial_graph(self): """Tests that the trivial graph has average path length zero, since there is exactly one path of length zero in the trivial graph. For more information, see issue #1960. """ G = nx.trivial_graph() assert nx.average_shortest_path_length(G) == 0 def test_null_graph(self): with pytest.raises(nx.NetworkXPointlessConcept): nx.average_shortest_path_length(nx.null_graph()) def test_bad_method(self): with pytest.raises(ValueError): G = nx.path_graph(2) nx.average_shortest_path_length(G, weight='weight', method='SPAM') class TestAverageShortestPathLengthNumpy(object): @classmethod def setup_class(cls): global numpy global npt import pytest numpy = pytest.importorskip('numpy') npt = pytest.importorskip('numpy.testing') def test_specified_methods_numpy(self): G = nx.Graph() nx.add_cycle(G, range(7), weight=2) ans = nx.average_shortest_path_length(G, weight='weight', method='floyd-warshall-numpy') npt.assert_almost_equal(ans, 4) G = nx.Graph() nx.add_path(G, range(5), weight=2) ans = nx.average_shortest_path_length(G, weight='weight', method='floyd-warshall-numpy') npt.assert_almost_equal(ans, 4)