def test_digraphs(self):
for dest, source in [(to_dict_of_dicts, from_dict_of_dicts),
(to_dict_of_lists, from_dict_of_lists)]:
G = cycle_graph(10)
# Dict of [dicts, lists]
dod = dest(G)
GG = source(dod)
assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_equal(sorted(G.edges()), sorted(GG.edges()))
GW = from_whatever(dod)
assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_equal(sorted(G.edges()), sorted(GW.edges()))
GI = Graph(dod)
assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_equal(sorted(G.edges()), sorted(GI.edges()))
G = cycle_graph(10, create_using=DiGraph())
dod = dest(G)
GG = source(dod, create_using=DiGraph())
assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_equal(sorted(G.edges()), sorted(GG.edges()))
GW = from_whatever(dod, create_using=DiGraph())
assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_equal(sorted(G.edges()), sorted(GW.edges()))
GI = DiGraph(dod)
assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_equal(sorted(G.edges()), sorted(GI.edges()))
def test_digraphs(self):
for dest, source in [(to_dict_of_dicts, from_dict_of_dicts),
(to_dict_of_lists, from_dict_of_lists)]:
G = cycle_graph(10)
# Dict of [dicts, lists]
dod = dest(G)
GG = source(dod)
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dod)
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
GI = nx.Graph(dod)
assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GI.edges()))
G = cycle_graph(10, create_using=nx.DiGraph)
dod = dest(G)
GG = source(dod, create_using=nx.DiGraph)
assert sorted(G.nodes()) == sorted(GG.nodes())
assert sorted(G.edges()) == sorted(GG.edges())
GW = to_networkx_graph(dod, create_using=nx.DiGraph)
assert sorted(G.nodes()) == sorted(GW.nodes())
assert sorted(G.edges()) == sorted(GW.edges())
GI = nx.DiGraph(dod)
assert sorted(G.nodes()) == sorted(GI.nodes())
assert sorted(G.edges()) == sorted(GI.edges())
def test_digraphs(self):
for dest, source in [(to_dict_of_dicts, from_dict_of_dicts),
(to_dict_of_lists, from_dict_of_lists)]:
G = cycle_graph(10)
# Dict of [dicts, lists]
dod = dest(G)
GG = source(dod)
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dod)
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
GI = nx.Graph(dod)
assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GI.edges()))
G = cycle_graph(10, create_using=nx.DiGraph())
dod = dest(G)
GG = source(dod, create_using=nx.DiGraph())
assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_equal(sorted(G.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dod, create_using=nx.DiGraph())
assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_equal(sorted(G.edges()), sorted(GW.edges()))
GI = nx.DiGraph(dod)
assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_equal(sorted(G.edges()), sorted(GI.edges()))
def test_graph_edit_distance_node_match(self):
G1 = cycle_graph(5)
G2 = cycle_graph(5)
for n, attr in G1.nodes.items():
attr['color'] = 'red' if n % 2 == 0 else 'blue'
for n, attr in G2.nodes.items():
attr['color'] = 'red' if n % 2 == 1 else 'blue'
assert graph_edit_distance(G1, G2) == 0
assert graph_edit_distance(G1, G2, node_match=lambda n1, n2: n1['color'] == n2['color']) == 1
def test_graph_edit_distance_node_match(self):
G1 = cycle_graph(5)
G2 = cycle_graph(5)
for n, attr in G1.nodes.items():
attr["color"] = "red" if n % 2 == 0 else "blue"
for n, attr in G2.nodes.items():
attr["color"] = "red" if n % 2 == 1 else "blue"
assert graph_edit_distance(G1, G2) == 0
assert (graph_edit_distance(
G1, G2, node_match=lambda n1, n2: n1["color"] == n2["color"]) == 1)
def test_graph(self):
G=cycle_graph(10)
e=G.edges()
source=[u for u,v in e]
dest=[v for u,v in e]
ex=zip(source,dest,source)
G=Graph()
G.add_weighted_edges_from(ex)
# Dict of dicts
dod=to_dict_of_dicts(G)
GG=from_dict_of_dicts(dod,create_using=Graph())
assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_equal(sorted(G.edges()), sorted(GG.edges()))
GW=to_networkx_graph(dod,create_using=Graph())
assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_equal(sorted(G.edges()), sorted(GW.edges()))
GI=Graph(dod)
assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_equal(sorted(G.edges()), sorted(GI.edges()))
# Dict of lists
dol=to_dict_of_lists(G)
GG=from_dict_of_lists(dol,create_using=Graph())
# dict of lists throws away edge data so set it to none
enone=[(u,v,{}) for (u,v,d) in G.edges(data=True)]
assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_equal(enone, sorted(GG.edges(data=True)))
GW=to_networkx_graph(dol,create_using=Graph())
assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_equal(enone, sorted(GW.edges(data=True)))
GI=Graph(dol)
assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_equal(enone, sorted(GI.edges(data=True)))
def test_optimal_edit_paths(self):
G1 = path_graph(3)
G2 = cycle_graph(3)
paths, cost = optimal_edit_paths(G1, G2)
assert cost == 1
assert len(paths) == 6
def canonical(vertex_path, edge_path):
return tuple(sorted(vertex_path)), tuple(
sorted(edge_path, key=lambda x: (None in x, x)))
expected_paths = [([(0, 0), (1, 1), (2, 2)], [((0, 1), (0, 1)),
((1, 2), (1, 2)),
(None, (0, 2))]),
([(0, 0), (1, 2), (2, 1)], [((0, 1), (0, 2)),
((1, 2), (1, 2)),
(None, (0, 1))]),
([(0, 1), (1, 0), (2, 2)], [((0, 1), (0, 1)),
((1, 2), (0, 2)),
(None, (1, 2))]),
([(0, 1), (1, 2), (2, 0)], [((0, 1), (1, 2)),
((1, 2), (0, 2)),
(None, (0, 1))]),
([(0, 2), (1, 0), (2, 1)], [((0, 1), (0, 2)),
((1, 2), (0, 1)),
(None, (1, 2))]),
([(0, 2), (1, 1), (2, 0)], [((0, 1), (1, 2)),
((1, 2), (0, 1)),
(None, (0, 2))])]
assert ({canonical(*p)
for p in paths} == {canonical(*p)
for p in expected_paths})
def test_graph_edit_distance(self):
G0 = nx.Graph()
G1 = path_graph(6)
G2 = cycle_graph(6)
G3 = wheel_graph(7)
assert graph_edit_distance(G0, G0) == 0
assert graph_edit_distance(G0, G1) == 11
assert graph_edit_distance(G1, G0) == 11
assert graph_edit_distance(G0, G2) == 12
assert graph_edit_distance(G2, G0) == 12
assert graph_edit_distance(G0, G3) == 19
assert graph_edit_distance(G3, G0) == 19
assert graph_edit_distance(G1, G1) == 0
assert graph_edit_distance(G1, G2) == 1
assert graph_edit_distance(G2, G1) == 1
assert graph_edit_distance(G1, G3) == 8
assert graph_edit_distance(G3, G1) == 8
assert graph_edit_distance(G2, G2) == 0
assert graph_edit_distance(G2, G3) == 7
assert graph_edit_distance(G3, G2) == 7
assert graph_edit_distance(G3, G3) == 0
def test_graph(self):
G=cycle_graph(10)
e=G.edges()
source=[u for u,v in e]
dest=[v for u,v in e]
ex=zip(source,dest,source)
G=Graph()
G.add_weighted_edges_from(ex)
# Dict of dicts
dod=to_dict_of_dicts(G)
GG=from_dict_of_dicts(dod,create_using=Graph())
assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_equal(sorted(G.edges()), sorted(GG.edges()))
GW=to_networkx_graph(dod,create_using=Graph())
assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_equal(sorted(G.edges()), sorted(GW.edges()))
GI=Graph(dod)
assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_equal(sorted(G.edges()), sorted(GI.edges()))
# Dict of lists
dol=to_dict_of_lists(G)
GG=from_dict_of_lists(dol,create_using=Graph())
# dict of lists throws away edge data so set it to none
enone=[(u,v,{}) for (u,v,d) in G.edges(data=True)]
assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_equal(enone, sorted(GG.edges(data=True)))
GW=to_networkx_graph(dol,create_using=Graph())
assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_equal(enone, sorted(GW.edges(data=True)))
GI=Graph(dol)
assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_equal(enone, sorted(GI.edges(data=True)))
def test_correctness():
# note: in the future can restrict all graphs to have the same number of nodes, for analysis
graphs = [lambda: basic_graph(), lambda: complete_graph(10), lambda: balanced_tree(3, 5), lambda: barbell_graph(6, 7),
lambda: binomial_tree(10), lambda: cycle_graph(50),
lambda: path_graph(200), lambda: star_graph(200)]
names = ["basic_graph", "complete_graph", "balanced_tree", "barbell_graph", "binomial_tree", "cycle_graph",
"path_graph", "star_graph"]
for graph, name in zip(graphs, names):
print(f"Testing graph {name}...")
# Initialize both graphs
G_dinitz = graph()
G_gr = graph()
# Set random capacities of graph edges
for u, v in G_dinitz.edges:
cap = randint(1, 20)
G_dinitz.edges[u, v]["capacity"] = cap
G_gr.edges[u, v]["capacity"] = cap
# Pick random start and end node
start_node = randint(0, len(G_dinitz.nodes)-1)
end_node = randint(0, len(G_dinitz.nodes)-1)
while start_node == end_node: end_node = randint(0, len(G_dinitz.nodes)-1)
# Run max-flow
R_dinitz = dinitz(G_dinitz, start_node, end_node)
R_gr = goldberg_rao(G_gr, start_node, end_node)
# Check correctness
d_mf = R_dinitz.graph["flow_value"]
gr_mf = R_gr.graph["flow_value"]
assert d_mf == gr_mf, f"Computed max flow in {name} graph is {d_mf}, but goldberg_rao function computed {gr_mf}"
def frucht_graph(create_using=None):
"""Returns the Frucht Graph.
The Frucht Graph is the smallest cubical graph whose
automorphism group consists only of the identity element.
"""
G = cycle_graph(7, create_using)
G.add_edges_from(
[
[0, 7],
[1, 7],
[2, 8],
[3, 9],
[4, 9],
[5, 10],
[6, 10],
[7, 11],
[8, 11],
[8, 9],
[10, 11],
]
)
G.name = "Frucht Graph"
return G
def get_graph(max_size):
graph_type = np.random.randint(1, 5)
num_nodes = np.random.randint(5, max(max_size, 5) + 1)
if graph_type == 1:
return path_graph(num_nodes), graph_type
elif graph_type == 2:
g = random_tree(num_nodes)
max_degree = 0
for n in g.degree:
max_degree = max(max_degree, n[1])
if max_degree <= 2:
graph_type = 1
return g, graph_type
elif graph_type == 3:
part1 = np.random.randint(2, max(max_size / 2, 2) + 1)
part2 = np.random.randint(3, max(max_size / 2, 3) + 1)
return complete_bipartite_graph(part1, part2), graph_type
elif graph_type == 4:
return cycle_graph(num_nodes), graph_type
else:
sys.exit('Something unexpected happened!')
def LCF_graph(n, shift_list, repeats, create_using=None):
"""
Return the cubic graph specified in LCF notation.
LCF notation (LCF=Lederberg-Coxeter-Fruchte) is a compressed
notation used in the generation of various cubic Hamiltonian
graphs of high symmetry. See, for example, dodecahedral_graph,
desargues_graph, heawood_graph and pappus_graph below.
n (number of nodes)
The starting graph is the n-cycle with nodes 0,...,n-1.
(The null graph is returned if n < 0.)
shift_list = [s1,s2,..,sk], a list of integer shifts mod n,
repeats
integer specifying the number of times that shifts in shift_list
are successively applied to each v_current in the n-cycle
to generate an edge between v_current and v_current+shift mod n.
For v1 cycling through the n-cycle a total of k*repeats
with shift cycling through shiftlist repeats times connect
v1 with v1+shift mod n
The utility graph K_{3,3}
>>> G=nx.LCF_graph(6,[3,-3],3)
The Heawood graph
>>> G=nx.LCF_graph(14,[5,-5],7)
See http://mathworld.wolfram.com/LCFNotation.html for a description
and references.
"""
if create_using is not None and create_using.is_directed():
raise NetworkXError("Directed Graph not supported")
if n <= 0:
return empty_graph(0, create_using)
# start with the n-cycle
G = cycle_graph(n, create_using)
G.name = "LCF_graph"
nodes = G.nodes()
n_extra_edges = repeats * len(shift_list)
# edges are added n_extra_edges times
# (not all of these need be new)
if n_extra_edges < 1:
return G
for i in range(n_extra_edges):
shift = shift_list[i % len(shift_list)] # cycle through shift_list
v1 = nodes[i % n] # cycle repeatedly through nodes
v2 = nodes[(i + shift) % n]
G.add_edge(v1, v2)
return G
def LCF_graph(n, shift_list, repeats, create_using=None):
"""
Return the cubic graph specified in LCF notation.
LCF notation (LCF=Lederberg-Coxeter-Fruchte) is a compressed
notation used in the generation of various cubic Hamiltonian
graphs of high symmetry. See, for example, dodecahedral_graph,
desargues_graph, heawood_graph and pappus_graph below.
n (number of nodes)
The starting graph is the n-cycle with nodes 0,...,n-1.
(The null graph is returned if n < 0.)
shift_list = [s1,s2,..,sk], a list of integer shifts mod n,
repeats
integer specifying the number of times that shifts in shift_list
are successively applied to each v_current in the n-cycle
to generate an edge between v_current and v_current+shift mod n.
For v1 cycling through the n-cycle a total of k*repeats
with shift cycling through shiftlist repeats times connect
v1 with v1+shift mod n
The utility graph K_{3,3}
>>> G=nx.LCF_graph(6,[3,-3],3)
The Heawood graph
>>> G=nx.LCF_graph(14,[5,-5],7)
See http://mathworld.wolfram.com/LCFNotation.html for a description
and references.
"""
if create_using is not None and create_using.is_directed():
raise NetworkXError("Directed Graph not supported")
if n <= 0:
return empty_graph(0, create_using)
# start with the n-cycle
G = cycle_graph(n, create_using)
G.name = "LCF_graph"
nodes = G.nodes()
n_extra_edges = repeats * len(shift_list)
# edges are added n_extra_edges times
# (not all of these need be new)
if n_extra_edges < 1:
return G
for i in range(n_extra_edges):
shift = shift_list[i % len(shift_list)] #cycle through shift_list
v1 = nodes[i % n] # cycle repeatedly through nodes
v2 = nodes[(i + shift) % n]
G.add_edge(v1, v2)
return G
def create_weighted(self, G):
g = cycle_graph(4)
e = list(g.edges())
source = [u for u,v in e]
dest = [v for u,v in e]
weight = [s+10 for s in source]
ex = zip(source, dest, weight)
G.add_weighted_edges_from(ex)
return G
def create_weighted(self, G):
g = cycle_graph(4)
e = list(g.edges())
source = [u for u, v in e]
dest = [v for u, v in e]
weight = [s + 10 for s in source]
ex = zip(source, dest, weight)
G.add_weighted_edges_from(ex)
return G
def frucht_graph(create_using=None):
"""Return the Frucht Graph.
The Frucht Graph is the smallest cubical graph whose
automorphism group consists only of the identity element.
"""
G = cycle_graph(7, create_using)
G.add_edges_from([[0, 7], [1, 7], [2, 8], [3, 9], [4, 9], [5, 10], [6, 10], [7, 11], [8, 11], [8, 9], [10, 11]])
G.name = "Frucht Graph"
return G
def run_analysis_n_nodes(n, unit_cap, n_runs=3):
print(f"Running analysis for {n} nodes...")
graphs = [lambda: balanced_tree(2, int(round(np.log2(n)-1))),
lambda: binomial_tree(int(round(np.log2(n)))), lambda: cycle_graph(n),
lambda: path_graph(n), lambda: star_graph(n-1), lambda: random_regular_graph(3, n), lambda: random_regular_graph(5, n)]
results_gr = {}
results_dinitz = {}
for graph, name in zip(graphs, names):
# Initialize both graphs
G_dinitz = graph()
G_gr = G_dinitz.copy()
total_time_gr = 0
total_time_dinitz = 0
for _ in range(n_runs):
# Set random capacities of graph edges
for u, v in G_dinitz.edges:
cap = randint(1, 100) if not unit_cap else 1
G_dinitz.edges[u, v]["capacity"] = cap
G_gr.edges[u, v]["capacity"] = cap
# Pick random start and end node
start_node = randint(0, len(G_dinitz.nodes)-1)
end_node = randint(0, len(G_dinitz.nodes)-1)
while start_node == end_node: end_node = randint(0, len(G_dinitz.nodes)-1)
# Run max-flow
init_time = time.time()
R_dinitz = dinitz(G_dinitz, start_node, end_node)
total_time_dinitz += time.time() - init_time
init_time = time.time()
R_gr = goldberg_rao(G_gr, start_node, end_node)
total_time_gr += time.time() - init_time
# Check correctness
d_mf = R_dinitz.graph["flow_value"]
gr_mf = R_gr.graph["flow_value"]
if d_mf != gr_mf:
vprint(f"\t\t\tComputed max flow in {name} graph is {d_mf}, but goldberg_rao function computed {gr_mf}".upper())
vprint(f"{name} with {len(G_gr.nodes)} nodes took {total_time_gr / n_runs} seconds with goldberg_rao")
vprint(f"{name} with {len(G_dinitz.nodes)} nodes took {total_time_dinitz / n_runs} seconds with dinitz")
results_gr[name] = total_time_gr / n_runs
results_dinitz[name] = total_time_dinitz / n_runs
return results_gr, results_dinitz
def frucht_graph(create_using=None):
"""
Returns the Frucht Graph.
The Frucht Graph is the smallest cubical graph whose
automorphism group consists only of the identity element [1]_.
It has 12 nodes and 18 edges and no nontrivial symmetries.
It is planar and Hamiltonian [2]_.
Parameters
----------
create_using : NetworkX graph constructor, optional (default=nx.Graph)
Graph type to create. If graph instance, then cleared before populated.
Returns
-------
G : networkx Graph
Frucht Graph with 12 nodes and 18 edges
References
----------
.. [1] https://en.wikipedia.org/wiki/Frucht_graph
.. [2] https://mathworld.wolfram.com/FruchtGraph.html
"""
G = cycle_graph(7, create_using)
G.add_edges_from([
[0, 7],
[1, 7],
[2, 8],
[3, 9],
[4, 9],
[5, 10],
[6, 10],
[7, 11],
[8, 11],
[8, 9],
[10, 11],
])
G.name = "Frucht Graph"
return G
def run_analysis_n_nodes(n, unit_cap, n_runs=3):
print(f"Running analysis for {n} nodes...")
graphs = [
lambda: balanced_tree(2, int(round(np.log2(n) - 1))),
lambda: binomial_tree(int(round(np.log2(n)))), lambda: cycle_graph(n),
lambda: path_graph(n), lambda: star_graph(n - 1),
lambda: random_regular_graph(3, n), lambda: random_regular_graph(5, n)
]
results_dinitz = {}
for graph, name in zip(graphs, names):
# Initialize both graphs
G_dinitz = graph()
total_time_dinitz = 0
for _ in range(n_runs):
# Set random capacities of graph edges
for u, v in G_dinitz.edges:
cap = randint(1, 100) if not unit_cap else 1
G_dinitz.edges[u, v]["capacity"] = cap
# Pick random start and end node
start_node = randint(0, len(G_dinitz.nodes) - 1)
end_node = randint(0, len(G_dinitz.nodes) - 1)
while start_node == end_node:
end_node = randint(0, len(G_dinitz.nodes) - 1)
# Run max-flow
init_time = time.time()
R_dinitz = dinitz(G_dinitz, start_node, end_node)
total_time_dinitz += time.time() - init_time
vprint(
f"{name} with {len(G_dinitz.nodes)} nodes took {total_time_dinitz / n_runs} seconds with dinitz"
)
results_dinitz[name] = total_time_dinitz / n_runs
return results_dinitz
def setup_method(self):
self.G1 = barbell_graph(10, 3)
self.G2 = cycle_graph(10, create_using=nx.DiGraph)
self.G3 = self.create_weighted(nx.Graph())
self.G4 = self.create_weighted(nx.DiGraph())
def __init__(self):
self.G1 = barbell_graph(10, 3)
self.G2 = cycle_graph(10, create_using=nx.DiGraph())
self.G3 = self.create_weighted(nx.Graph())
self.G4 = self.create_weighted(nx.DiGraph())
def __init__(self):
self.G1 = barbell_graph(10, 3)
self.G2 = cycle_graph(10, create_using=nx.DiGraph())
self.G3 = self.create_weighted(nx.Graph())
self.G4 = self.create_weighted(nx.DiGraph())
def test_with_multiedges_self_loops(self):
G = cycle_graph(10)
XG = nx.Graph()
XG.add_nodes_from(G)
XG.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGM = nx.MultiGraph()
XGM.add_nodes_from(G)
XGM.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGM.add_edge(0, 1, weight=2) # multiedge
XGS = nx.Graph()
XGS.add_nodes_from(G)
XGS.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGS.add_edge(0, 0, weight=100) # self loop
# Dict of dicts
# with self loops, OK
dod = to_dict_of_dicts(XGS)
GG = from_dict_of_dicts(dod, create_using=nx.Graph)
assert_nodes_equal(XGS.nodes(), GG.nodes())
assert_edges_equal(XGS.edges(), GG.edges())
GW = to_networkx_graph(dod, create_using=nx.Graph)
assert_nodes_equal(XGS.nodes(), GW.nodes())
assert_edges_equal(XGS.edges(), GW.edges())
GI = nx.Graph(dod)
assert_nodes_equal(XGS.nodes(), GI.nodes())
assert_edges_equal(XGS.edges(), GI.edges())
# Dict of lists
# with self loops, OK
dol = to_dict_of_lists(XGS)
GG = from_dict_of_lists(dol, create_using=nx.Graph)
# dict of lists throws away edge data so set it to none
enone = [(u, v, {}) for (u, v, d) in XGS.edges(data=True)]
assert_nodes_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
assert_edges_equal(enone, sorted(GG.edges(data=True)))
GW = to_networkx_graph(dol, create_using=nx.Graph)
assert_nodes_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
assert_edges_equal(enone, sorted(GW.edges(data=True)))
GI = nx.Graph(dol)
assert_nodes_equal(sorted(XGS.nodes()), sorted(GI.nodes()))
assert_edges_equal(enone, sorted(GI.edges(data=True)))
# Dict of dicts
# with multiedges, OK
dod = to_dict_of_dicts(XGM)
GG = from_dict_of_dicts(dod,
create_using=nx.MultiGraph,
multigraph_input=True)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dod,
create_using=nx.MultiGraph,
multigraph_input=True)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GW.edges()))
GI = nx.MultiGraph(
dod) # convert can't tell whether to duplicate edges!
assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
# assert_not_equal(sorted(XGM.edges()), sorted(GI.edges()))
assert not sorted(XGM.edges()) == sorted(GI.edges())
GE = from_dict_of_dicts(dod,
create_using=nx.MultiGraph,
multigraph_input=False)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GE.nodes()))
assert sorted(XGM.edges()) != sorted(GE.edges())
GI = nx.MultiGraph(XGM)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GI.edges()))
GM = nx.MultiGraph(G)
assert_nodes_equal(sorted(GM.nodes()), sorted(G.nodes()))
assert_edges_equal(sorted(GM.edges()), sorted(G.edges()))
# Dict of lists
# with multiedges, OK, but better write as DiGraph else you'll
# get double edges
dol = to_dict_of_lists(G)
GG = from_dict_of_lists(dol, create_using=nx.MultiGraph)
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dol, create_using=nx.MultiGraph)
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
GI = nx.MultiGraph(dol)
assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GI.edges()))
def create_weighted(self, G):
g = cycle_graph(4)
G.add_nodes_from(g)
G.add_weighted_edges_from((u, v, 10 + u) for u, v in g.edges())
return G
def create_weighted(self, G):
g = cycle_graph(4)
G.add_nodes_from(g)
G.add_weighted_edges_from( (u,v,10+u) for u,v in g.edges())
return G
def test_with_multiedges_self_loops(self):
G = cycle_graph(10)
e = G.edges()
source, dest = list(zip(*e))
ex = list(zip(source, dest, source))
XG = Graph()
XG.add_weighted_edges_from(ex)
XGM = MultiGraph()
XGM.add_weighted_edges_from(ex)
XGM.add_edge(0, 1, weight=2) # multiedge
XGS = Graph()
XGS.add_weighted_edges_from(ex)
XGS.add_edge(0, 0, weight=100) # self loop
# Dict of dicts
# with self loops, OK
dod = to_dict_of_dicts(XGS)
GG = from_dict_of_dicts(dod, create_using=Graph())
assert_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
assert_equal(sorted(XGS.edges()), sorted(GG.edges()))
GW = from_whatever(dod, create_using=Graph())
assert_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
assert_equal(sorted(XGS.edges()), sorted(GW.edges()))
GI = Graph(dod)
assert_equal(sorted(XGS.nodes()), sorted(GI.nodes()))
assert_equal(sorted(XGS.edges()), sorted(GI.edges()))
# Dict of lists
# with self loops, OK
dol = to_dict_of_lists(XGS)
GG = from_dict_of_lists(dol, create_using=Graph())
# dict of lists throws away edge data so set it to none
enone = [(u, v, {}) for (u, v, d) in XGS.edges(data=True)]
assert_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
assert_equal(enone, sorted(GG.edges(data=True)))
GW = from_whatever(dol, create_using=Graph())
assert_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
assert_equal(enone, sorted(GW.edges(data=True)))
GI = Graph(dol)
assert_equal(sorted(XGS.nodes()), sorted(GI.nodes()))
assert_equal(enone, sorted(GI.edges(data=True)))
# Dict of dicts
# with multiedges, OK
dod = to_dict_of_dicts(XGM)
GG = from_dict_of_dicts(dod,
create_using=MultiGraph(),
multigraph_input=True)
assert_equal(sorted(XGM.nodes()), sorted(GG.nodes()))
assert_equal(sorted(XGM.edges()), sorted(GG.edges()))
GW = from_whatever(dod,
create_using=MultiGraph(),
multigraph_input=True)
assert_equal(sorted(XGM.nodes()), sorted(GW.nodes()))
assert_equal(sorted(XGM.edges()), sorted(GW.edges()))
GI = MultiGraph(dod) # convert can't tell whether to duplicate edges!
assert_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
#assert_not_equal(sorted(XGM.edges()), sorted(GI.edges()))
assert_false(sorted(XGM.edges()) == sorted(GI.edges()))
GE = from_dict_of_dicts(dod,
create_using=MultiGraph(),
multigraph_input=False)
assert_equal(sorted(XGM.nodes()), sorted(GE.nodes()))
assert_not_equal(sorted(XGM.edges()), sorted(GE.edges()))
GI = MultiGraph(XGM)
assert_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
assert_equal(sorted(XGM.edges()), sorted(GI.edges()))
GM = MultiGraph(G)
assert_equal(sorted(GM.nodes()), sorted(G.nodes()))
assert_equal(sorted(GM.edges()), sorted(G.edges()))
# Dict of lists
# with multiedges, OK, but better write as DiGraph else you'll
# get double edges
dol = to_dict_of_lists(G)
GG = from_dict_of_lists(dol, create_using=MultiGraph())
assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_equal(sorted(G.edges()), sorted(GG.edges()))
GW = from_whatever(dol, create_using=MultiGraph())
assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_equal(sorted(G.edges()), sorted(GW.edges()))
GI = MultiGraph(dol)
assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_equal(sorted(G.edges()), sorted(GI.edges()))
def test_with_multiedges_self_loops(self):
G = cycle_graph(10)
XG = nx.Graph()
XG.add_nodes_from(G)
XG.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGM = nx.MultiGraph()
XGM.add_nodes_from(G)
XGM.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGM.add_edge(0, 1, weight=2) # multiedge
XGS = nx.Graph()
XGS.add_nodes_from(G)
XGS.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGS.add_edge(0, 0, weight=100) # self loop
# Dict of dicts
# with self loops, OK
dod = to_dict_of_dicts(XGS)
GG = from_dict_of_dicts(dod, create_using=nx.Graph())
assert_nodes_equal(XGS.nodes(), GG.nodes())
assert_edges_equal(XGS.edges(), GG.edges())
GW = to_networkx_graph(dod, create_using=nx.Graph())
assert_nodes_equal(XGS.nodes(), GW.nodes())
assert_edges_equal(XGS.edges(), GW.edges())
GI = nx.Graph(dod)
assert_nodes_equal(XGS.nodes(), GI.nodes())
assert_edges_equal(XGS.edges(), GI.edges())
# Dict of lists
# with self loops, OK
dol = to_dict_of_lists(XGS)
GG = from_dict_of_lists(dol, create_using=nx.Graph())
# dict of lists throws away edge data so set it to none
enone = [(u, v, {}) for (u, v, d) in XGS.edges(data=True)]
assert_nodes_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
assert_edges_equal(enone, sorted(GG.edges(data=True)))
GW = to_networkx_graph(dol, create_using=nx.Graph())
assert_nodes_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
assert_edges_equal(enone, sorted(GW.edges(data=True)))
GI = nx.Graph(dol)
assert_nodes_equal(sorted(XGS.nodes()), sorted(GI.nodes()))
assert_edges_equal(enone, sorted(GI.edges(data=True)))
# Dict of dicts
# with multiedges, OK
dod = to_dict_of_dicts(XGM)
GG = from_dict_of_dicts(dod, create_using=nx.MultiGraph(),
multigraph_input=True)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dod, create_using=nx.MultiGraph(), multigraph_input=True)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GW.edges()))
GI = nx.MultiGraph(dod) # convert can't tell whether to duplicate edges!
assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
#assert_not_equal(sorted(XGM.edges()), sorted(GI.edges()))
assert_false(sorted(XGM.edges()) == sorted(GI.edges()))
GE = from_dict_of_dicts(dod, create_using=nx.MultiGraph(),
multigraph_input=False)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GE.nodes()))
assert_not_equal(sorted(XGM.edges()), sorted(GE.edges()))
GI = nx.MultiGraph(XGM)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GI.edges()))
GM = nx.MultiGraph(G)
assert_nodes_equal(sorted(GM.nodes()), sorted(G.nodes()))
assert_edges_equal(sorted(GM.edges()), sorted(G.edges()))
# Dict of lists
# with multiedges, OK, but better write as DiGraph else you'll
# get double edges
dol = to_dict_of_lists(G)
GG = from_dict_of_lists(dol, create_using=nx.MultiGraph())
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dol, create_using=nx.MultiGraph())
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
GI = nx.MultiGraph(dol)
assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GI.edges()))
