def test_numpy_no_edges(self):
graph = retworkx.PyGraph()
graph.add_nodes_from(list(range(4)))
dist = retworkx.graph_floyd_warshall_numpy(graph, lambda x: x)
expected = numpy.full((4, 4), numpy.inf)
numpy.fill_diagonal(expected, 0)
self.assertTrue(numpy.array_equal(dist, expected))
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)
self.assertEqual(dist[0, 3], 3)
self.assertEqual(dist[0, 4], 3)
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)
self.assertEqual(dist[0, 3], 3)
self.assertEqual(dist[0, 4], 3)
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)
self.assertEqual(dist[0, 3], 15)
self.assertEqual(dist[3, 0], 15)
def test_floyd_warshall_numpy(self):
res = retworkx.floyd_warshall_numpy(self.graph)
self.assertIsInstance(res, numpy.ndarray)
if self.class_type == "PyGraph":
expected_res = retworkx.graph_floyd_warshall_numpy(self.graph)
else:
expected_res = retworkx.digraph_floyd_warshall_numpy(self.graph)
self.assertTrue(numpy.array_equal(expected_res, res))
def make_error_graph(self, string, subgraphs=None):
"""
Args:
string (str): A string describing the output from the code.
subgraphs (list): Used when multiple, semi-independent graphs need
need to created.
Returns:
E: The subgraph(s) of S which corresponds to the non-trivial
syndrome elements in the given string.
"""
if subgraphs is None:
subgraphs = []
for syndrome_type in string.split(" "):
subgraphs.append(["0"])
set_subgraphs = [subgraph for subs4type in subgraphs for subgraph in subs4type]
E = {}
node_sets = {}
for subgraph in set_subgraphs:
E[subgraph] = rx.PyGraph(multigraph=False)
node_sets[subgraph] = set()
E = {subgraph: rx.PyGraph(multigraph=False) for subgraph in set_subgraphs}
separated_string = self._separate_string(string)
for syndrome_type, _ in enumerate(separated_string):
for syndrome_round in range(len(separated_string[syndrome_type])):
elements = separated_string[syndrome_type][syndrome_round]
for elem_num, element in enumerate(elements):
if element == "1" or syndrome_type == 0:
for subgraph in subgraphs[syndrome_type]:
node_data = (syndrome_type, syndrome_round, elem_num)
if node_data not in node_sets[subgraph]:
E[subgraph].add_node(node_data)
node_sets[subgraph].add(node_data)
# for each pair of nodes in error create an edge and weight with the
# distance
distance_matrix = rx.graph_floyd_warshall_numpy(self.S, weight_fn=float)
s_node_map = {self.S[index]: index for index in self.S.node_indexes()}
for subgraph in set_subgraphs:
for source_index in E[subgraph].node_indexes():
for target_index in E[subgraph].node_indexes():
source = E[subgraph][source_index]
target = E[subgraph][target_index]
if target != source:
distance = int(
distance_matrix[s_node_map[source]][s_node_map[target]]
)
E[subgraph].add_edge(source_index, target_index, -distance)
return E
def test_floyd_warshall_numpy_graph_cycle_default_weight(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, default_weight=2, parallel_threshold=self.parallel_threshold
)
self.assertEqual(dist[0, 3], 6)
self.assertEqual(dist[0, 4], 6)
def test_weighted_numpy_negative_cycle(self):
graph = retworkx.PyGraph()
graph.add_nodes_from(list(range(4)))
graph.add_edges_from([
(0, 1, 1),
(1, 2, -1),
(2, 3, -1),
(3, 0, -1),
])
dist = retworkx.graph_floyd_warshall_numpy(
graph, lambda x: x, parallel_threshold=self.parallel_threshold)
self.assertTrue(numpy.all(numpy.diag(dist) < 0))
def test_weighted_numpy_negative_cycle(self):
graph = retworkx.PyGraph()
graph.add_nodes_from(list(range(4)))
graph.add_edges_from([
(0, 1, 1),
(1, 2, -1),
(2, 3, -1),
(3, 0, -1),
])
dist = retworkx.graph_floyd_warshall_numpy(graph, lambda x: x)
expected = numpy.array([[-6, -7, -8, -13], [-7, -8, -9, -14],
[-8, -9, -10, -15], [-13, -14, -15, -20]],
dtype=numpy.float64)
self.assertTrue(numpy.array_equal(dist, expected))
def __init__(self,
graph: rx.PyGraph,
seed: Union[int, np.random.Generator, None] = None) -> None:
"""Construct an ApproximateTokenSwapping object.
Args:
graph (nx.Graph): Undirected graph represented a coupling map.
seed (Union[int, np.random.default_rng]): Seed to use for random trials.
"""
self.graph = graph
self.shortest_paths = rx.graph_floyd_warshall_numpy(graph)
if isinstance(seed, np.random.Generator):
self.seed = seed
else:
self.seed = np.random.default_rng(seed)
def test_weighted_numpy_two_edges(self):
graph = retworkx.PyGraph()
graph.add_nodes_from(list(range(8)))
graph.add_edges_from([
(0, 1, 2),
(1, 2, 2),
(2, 3, 1),
(3, 4, 1),
(4, 5, 1),
(5, 6, 1),
(6, 7, 1),
(7, 0, 1),
])
dist = retworkx.graph_floyd_warshall_numpy(graph, lambda x: x)
self.assertEqual(dist[0, 2], 4)
self.assertEqual(dist[2, 0], 4)
