def test_subgraph_invalid_entry(self):
graph = retworkx.PyGraph()
graph.add_node('a')
graph.add_node('b')
graph.add_node('c')
graph.add_node('d')
graph.add_edges_from([(0, 1, 1), (0, 2, 2), (0, 3, 3), (1, 3, 4)])
subgraph = graph.subgraph([42])
self.assertEqual([], subgraph.weighted_edge_list())
self.assertEqual(0, len(subgraph))
def test_subgraph_empty_list(self):
graph = retworkx.PyGraph()
graph.add_node("a")
graph.add_node("b")
graph.add_node("c")
graph.add_node("d")
graph.add_edges_from([(0, 1, 1), (0, 2, 2), (0, 3, 3), (1, 3, 4)])
subgraph = graph.subgraph([])
self.assertEqual([], subgraph.weighted_edge_list())
self.assertEqual(0, len(subgraph))
def test_subgraph(self):
graph = retworkx.PyGraph()
graph.add_node('a')
graph.add_node('b')
graph.add_node('c')
graph.add_node('d')
graph.add_edges_from([(0, 1, 1), (0, 2, 2), (0, 3, 3), (1, 3, 4)])
subgraph = graph.subgraph([1, 3])
self.assertEqual([(0, 1, 4)], subgraph.weighted_edge_list())
self.assertEqual(['b', 'd'], subgraph.nodes())
def test_k_graph_shortest_path_with_goal(self):
graph = retworkx.PyGraph()
graph.add_nodes_from(list(range(7)))
graph.add_edges_from_no_data(
[(0, 1), (0, 6), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
)
res = retworkx.graph_k_shortest_path_lengths(
graph, 0, 2, lambda _: 1, 3
)
self.assertEqual({3: 4}, res)
def test_subgraph(self):
graph = retworkx.PyGraph()
graph.add_node("a")
graph.add_node("b")
graph.add_node("c")
graph.add_node("d")
graph.add_edges_from([(0, 1, 1), (0, 2, 2), (0, 3, 3), (1, 3, 4)])
subgraph = graph.subgraph([1, 3])
self.assertEqual([(0, 1, 4)], subgraph.weighted_edge_list())
self.assertEqual(["b", "d"], subgraph.nodes())
def test_unique_neighbors_on_graphs(self):
dag = retworkx.PyGraph()
node_a = dag.add_node('a')
node_b = dag.add_node('b')
node_c = dag.add_node('c')
dag.add_edge(node_a, node_b, ['edge a->b'])
dag.add_edge(node_a, node_b, ['edge a->b bis'])
dag.add_edge(node_a, node_c, ['edge a->c'])
res = dag.neighbors(node_a)
self.assertCountEqual([node_c, node_b], res)
def test_floyd_warshall_numpy_three_edges(self):
graph = retworkx.PyGraph()
graph.add_nodes_from(list(range(6)))
weights = [2, 12, 1, 5, 1]
graph.add_edges_from([(i, i + 1, weights[i]) for i in range(5)])
graph.add_edge(5, 0, 10)
dist = retworkx.graph_floyd_warshall_numpy(
graph, lambda x: x, parallel_threshold=self.parallel_threshold)
self.assertEqual(dist[0, 3], 15)
self.assertEqual(dist[3, 0], 15)
def test_floyd_warshall_numpy_graph_cycle_with_removals(self):
graph = retworkx.PyGraph()
graph.add_nodes_from(list(range(8)))
graph.remove_node(0)
graph.add_edges_from_no_data([(1, 2), (1, 7), (2, 3), (3, 4), (4, 5),
(5, 6), (6, 7)])
dist = retworkx.graph_floyd_warshall_numpy(
graph, lambda x: 1, parallel_threshold=self.parallel_threshold)
self.assertEqual(dist[0, 3], 3)
self.assertEqual(dist[0, 4], 3)
def test_extend_from_edge_list(self):
graph = retworkx.PyGraph()
edge_list = [(0, 1), (1, 2), (0, 2), (2, 3), (0, 3)]
graph.extend_from_edge_list(edge_list)
self.assertEqual(len(graph), 4)
self.assertEqual([None] * 5, graph.edges())
self.assertEqual(3, graph.degree(0))
self.assertEqual(2, graph.degree(1))
self.assertEqual(3, graph.degree(2))
self.assertEqual(2, graph.degree(3))
def test_multigraph_sum_cast_weight_func(self):
graph = retworkx.PyGraph()
node_a = graph.add_node('a')
node_b = graph.add_node('b')
graph.add_edge(node_a, node_b, 7.0)
graph.add_edge(node_a, node_b, 0.5)
res = retworkx.graph_adjacency_matrix(graph, lambda x: float(x))
self.assertIsInstance(res, np.ndarray)
self.assertTrue(np.array_equal(np.array([[0.0, 7.5], [7.5, 0.0]]),
res))
def group_subops(cls,
list_op: ListOp,
fast: Optional[bool] = None,
use_nx: Optional[bool] = None) -> ListOp:
"""Given a ListOp, attempt to group into Abelian ListOps of the same type.
Args:
list_op: The Operator to group into Abelian groups
fast: Ignored - parameter will be removed in future release
use_nx: Ignored - parameter will be removed in future release
Returns:
The grouped Operator.
Raises:
AquaError: If any of list_op's sub-ops is not ``PauliOp``.
"""
if fast is not None or use_nx is not None:
warnings.warn(
'Options `fast` and `use_nx` of `AbelianGrouper.group_subops` are '
'no longer used and are now deprecated and will be removed no '
'sooner than 3 months following the 0.8.0 release.')
# TODO: implement direct way
if isinstance(list_op, PauliSumOp):
list_op = list_op.to_pauli_op()
for op in list_op.oplist:
if not isinstance(op, PauliOp):
raise AquaError(
'Cannot determine Abelian groups if any Operator in list_op is not '
'`PauliOp`. E.g., {} ({})'.format(op, type(op)))
edges = cls._commutation_graph(list_op)
nodes = range(len(list_op))
graph = rx.PyGraph()
graph.add_nodes_from(nodes)
graph.add_edges_from_no_data(edges)
# Keys in coloring_dict are nodes, values are colors
coloring_dict = rx.graph_greedy_color(graph)
groups = {} # type: Dict
# sort items so that the output is consistent with all options (fast and use_nx)
for idx, color in sorted(coloring_dict.items()):
groups.setdefault(color, []).append(list_op[idx])
group_ops = [
list_op.__class__(group, abelian=True)
for group in groups.values()
]
if len(group_ops) == 1:
return group_ops[0] * list_op.coeff # type: ignore
return list_op.__class__(group_ops,
coeff=list_op.coeff) # type: ignore
def test_remove_nodes_from_with_invalid_index(self):
graph = retworkx.PyGraph()
node_a = graph.add_node('a')
node_b = graph.add_node('b')
graph.add_edge(node_a, node_b, "Edgy")
node_c = graph.add_node('c')
graph.add_edge(node_b, node_c, "Edgy_mk2")
graph.remove_nodes_from([node_b, node_c, 76])
res = graph.nodes()
self.assertEqual(['a'], res)
self.assertEqual([0], graph.node_indexes())
def test_extend_from_weighted_edge_list(self):
graph = retworkx.PyGraph()
edge_list = [(0, 1, 'a'), (1, 2, 'b'), (0, 2, 'c'), (2, 3, 'd'),
(0, 3, 'e')]
graph.extend_from_weighted_edge_list(edge_list)
self.assertEqual(len(graph), 4)
self.assertEqual(['a', 'b', 'c', 'd', 'e'], graph.edges())
self.assertEqual(3, graph.degree(0))
self.assertEqual(2, graph.degree(1))
self.assertEqual(3, graph.degree(2))
self.assertEqual(2, graph.degree(3))
def test_deepcopy_with_holes_returns_graph(self):
dag_a = retworkx.PyGraph()
node_a = dag_a.add_node("a_1")
node_b = dag_a.add_node("a_2")
dag_a.add_edge(node_a, node_b, "edge_1")
node_c = dag_a.add_node("a_3")
dag_a.add_edge(node_b, node_c, "edge_2")
dag_a.remove_node(node_b)
dag_b = copy.deepcopy(dag_a)
self.assertIsInstance(dag_b, retworkx.PyGraph)
self.assertEqual([node_a, node_c], dag_b.node_indexes())
def test_remove_node_delitem(self):
graph = retworkx.PyGraph()
node_a = graph.add_node('a')
node_b = graph.add_node('b')
graph.add_edge(node_a, node_b, "Edgy")
node_c = graph.add_node('c')
graph.add_edge(node_b, node_c, "Edgy_mk2")
del graph[node_b]
res = graph.nodes()
self.assertEqual(['a', 'c'], res)
self.assertEqual([0, 2], graph.node_indexes())
def test_num_shortest_path_unweighted(self):
graph = retworkx.PyGraph()
node_a = graph.add_node(0)
node_b = graph.add_node("end")
for i in range(3):
node = graph.add_node(i)
graph.add_edge(node_a, node, None)
graph.add_edge(node, node_b, None)
res = retworkx.graph_num_shortest_paths_unweighted(graph, node_a)
expected = {2: 1, 4: 1, 3: 1, 1: 3}
self.assertEqual(expected, res)
def test_non_induced_grid_subgraph_isomorphic(self):
g_a = retworkx.generators.grid_graph(2, 2)
g_b = retworkx.PyGraph()
g_b.add_nodes_from([0, 1, 2, 3])
g_b.add_edges_from_no_data([(0, 1), (2, 3)])
self.assertFalse(
retworkx.is_subgraph_isomorphic(g_a, g_b, induced=True))
self.assertTrue(
retworkx.is_subgraph_isomorphic(g_a, g_b, induced=False))
def test_extend_from_edge_list_nodes_exist(self):
graph = retworkx.PyGraph(False)
graph.add_nodes_from(list(range(4)))
edge_list = [(0, 1), (1, 2), (0, 2), (2, 3), (0, 3)]
graph.extend_from_edge_list(edge_list)
self.assertEqual(len(graph), 4)
self.assertEqual([None] * 5, graph.edges())
self.assertEqual(3, graph.degree(0))
self.assertEqual(2, graph.degree(1))
self.assertEqual(3, graph.degree(2))
self.assertEqual(2, graph.degree(3))
def test_isomorphic_compare_edges_identical(self):
g_a = retworkx.PyGraph()
g_b = retworkx.PyGraph()
nodes = g_a.add_nodes_from(["a_1", "a_2", "a_3"])
g_a.add_edges_from([(nodes[0], nodes[1], "a_1"),
(nodes[1], nodes[2], "a_2")])
nodes = g_b.add_nodes_from(["a_1", "a_2", "a_3"])
g_b.add_edges_from([(nodes[0], nodes[1], "a_1"),
(nodes[1], nodes[2], "a_2")])
for id_order in [False, True]:
with self.subTest(id_order=id_order):
self.assertTrue(
retworkx.is_isomorphic(
g_a,
g_b,
edge_matcher=lambda x, y: x == y,
id_order=id_order,
))
def test_remove_nodes_from(self):
graph = retworkx.PyGraph()
node_a = graph.add_node("a")
node_b = graph.add_node("b")
graph.add_edge(node_a, node_b, "Edgy")
node_c = graph.add_node("c")
graph.add_edge(node_b, node_c, "Edgy_mk2")
graph.remove_nodes_from([node_b, node_c])
res = graph.nodes()
self.assertEqual(["a"], res)
self.assertEqual([0], graph.node_indexes())
def test_extend_from_weighted_edge_list(self):
graph = retworkx.PyGraph()
edge_list = [
(0, 1, "a"),
(1, 2, "b"),
(0, 2, "c"),
(2, 3, "d"),
(0, 3, "e"),
]
graph.extend_from_weighted_edge_list(edge_list)
self.assertEqual(len(graph), 4)
def test_all_simple_paths(self):
graph = retworkx.PyGraph()
for i in range(6):
graph.add_node(i)
graph.add_edges_from_no_data(self.edges)
paths = retworkx.graph_all_simple_paths(graph, 0, 5)
expected = [
[0, 3, 4, 5],
[0, 3, 4, 2, 5],
[0, 3, 4, 2, 5],
[0, 3, 2, 4, 5],
[0, 3, 2, 5],
[0, 3, 2, 4, 5],
[0, 3, 5],
[0, 3, 2, 4, 5],
[0, 3, 2, 5],
[0, 3, 2, 4, 5],
[0, 3, 1, 2, 4, 5],
[0, 3, 1, 2, 5],
[0, 3, 1, 2, 4, 5],
[0, 2, 4, 5],
[0, 2, 4, 3, 5],
[0, 2, 3, 4, 5],
[0, 2, 3, 5],
[0, 2, 5],
[0, 2, 4, 5],
[0, 2, 4, 3, 5],
[0, 2, 3, 4, 5],
[0, 2, 3, 5],
[0, 2, 1, 3, 4, 5],
[0, 2, 1, 3, 5],
[0, 1, 3, 4, 5],
[0, 1, 3, 4, 2, 5],
[0, 1, 3, 4, 2, 5],
[0, 1, 3, 2, 4, 5],
[0, 1, 3, 2, 5],
[0, 1, 3, 2, 4, 5],
[0, 1, 3, 5],
[0, 1, 3, 2, 4, 5],
[0, 1, 3, 2, 5],
[0, 1, 3, 2, 4, 5],
[0, 1, 2, 4, 5],
[0, 1, 2, 4, 3, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 5],
[0, 1, 2, 5],
[0, 1, 2, 4, 5],
[0, 1, 2, 4, 3, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 5],
]
self.assertEqual(len(expected), len(paths))
for i in expected:
self.assertIn(i, paths)
def test_floyd_warshall_numpy_cycle(self):
graph = retworkx.PyGraph()
graph.add_nodes_from(list(range(7)))
graph.add_edges_from_no_data(
[(0, 1), (0, 6), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
)
dist = retworkx.graph_floyd_warshall_numpy(
graph, lambda x: 1, parallel_threshold=self.parallel_threshold
)
self.assertEqual(dist[0, 3], 3)
self.assertEqual(dist[0, 4], 3)
def test_copy_with_holes_returns_graph(self):
graph_a = retworkx.PyGraph()
node_a = graph_a.add_node("a_1")
node_b = graph_a.add_node("a_2")
graph_a.add_edge(node_a, node_b, "edge_1")
node_c = graph_a.add_node("a_3")
graph_a.add_edge(node_b, node_c, "edge_2")
graph_a.remove_node(node_b)
graph_b = graph_a.copy()
self.assertIsInstance(graph_b, retworkx.PyGraph)
self.assertEqual([node_a, node_c], graph_b.node_indexes())
def test_subgraph_isomorphic_identical(self):
g_a = retworkx.PyGraph()
nodes = g_a.add_nodes_from(["a_1", "a_2", "a_3"])
g_a.add_edges_from([(nodes[0], nodes[1], "a_1"),
(nodes[1], nodes[2], "a_2")])
for id_order in [False, True]:
with self.subTest(id_order=id_order):
self.assertTrue(
retworkx.is_subgraph_isomorphic(g_a,
g_a,
id_order=id_order))
def test_update_edge_parallel_edges(self):
graph = retworkx.PyGraph()
node_a = graph.add_node("a")
node_b = graph.add_node("b")
graph.add_edge(node_a, node_b, "not edgy")
edge_index = graph.add_edge(node_a, node_b, "not edgy")
graph.update_edge_by_index(edge_index, "Edgy")
self.assertEqual(
[(0, 1, "not edgy"), (0, 1, "Edgy")],
list(graph.weighted_edge_list()),
)
def test_subgraph_isomorphic_mismatch_node_data(self):
g_a = retworkx.PyGraph()
g_b = retworkx.PyGraph()
nodes = g_a.add_nodes_from(["a_1", "a_2", "a_3", "a_4"])
g_a.add_edges_from([
(nodes[0], nodes[1], "a_1"),
(nodes[1], nodes[2], "a_2"),
(nodes[0], nodes[3], "a_3"),
])
nodes = g_b.add_nodes_from(["b_1", "b_2", "b_3"])
g_b.add_edges_from([(nodes[0], nodes[1], "b_1"),
(nodes[1], nodes[2], "b_2")])
for id_order in [False, True]:
with self.subTest(id_order=id_order):
self.assertTrue(
retworkx.is_subgraph_isomorphic(g_a,
g_b,
id_order=id_order))
def test_small_graph(self):
graph = retworkx.PyGraph()
graph.extend_from_weighted_edge_list([(1, 2, 10), (2, 3, 11)])
self.compare_match_sets(
retworkx.max_weight_matching(graph,
weight_fn=lambda x: x,
verify_optimum=True),
{
(2, 3),
},
)
def test_graph_with_index_holes(self):
graph = retworkx.PyGraph()
node_a = graph.add_node("a")
node_b = graph.add_node("b")
graph.add_edge(node_a, node_b, 1)
node_c = graph.add_node("c")
graph.add_edge(node_a, node_c, 1)
graph.remove_node(node_b)
res = retworkx.graph_adjacency_matrix(graph, lambda x: 1)
self.assertIsInstance(res, np.ndarray)
self.assertTrue(np.array_equal(np.array([[0, 1], [1, 0]]), res))
def setup(self, num_nodes, num_edges):
self.graph = retworkx.PyGraph()
nodes = self.graph.add_nodes_from(list(range(num_nodes)))
self.list_empty = []
self.list_obj = []
node_ids = itertools.cycle(nodes)
for i in range(num_edges):
node_a = next(node_ids)
node_b = next(node_ids)
self.list_empty.append((node_a, node_b))
self.list_obj.append((node_a, node_b, i))
