From 74d6784fd7c69082e0d3079acc9482c410dcf9e1 Mon Sep 17 00:00:00 2001 From: Takashi Imamichi Date: Wed, 26 May 2021 16:20:45 +0900 Subject: [PATCH 1/7] (wip) replace networkx with retworkx --- qiskit_optimization/applications/__init__.py | 24 +++++++++---------- qiskit_optimization/applications/clique.py | 17 ++++++------- .../graph_optimization_application.py | 15 ++++++------ .../applications/graph_partition.py | 2 +- qiskit_optimization/applications/max_cut.py | 2 +- .../applications/stable_set.py | 2 +- qiskit_optimization/applications/tsp.py | 2 +- .../applications/vehicle_routing.py | 2 +- .../applications/vertex_cover.py | 2 +- test/applications/test_clique.py | 5 ++-- 10 files changed, 38 insertions(+), 35 deletions(-) diff --git a/qiskit_optimization/applications/__init__.py b/qiskit_optimization/applications/__init__.py index cf9ff3e90..eddf935b4 100644 --- a/qiskit_optimization/applications/__init__.py +++ b/qiskit_optimization/applications/__init__.py @@ -48,18 +48,18 @@ """ from .clique import Clique -from .exact_cover import ExactCover -from .graph_optimization_application import GraphOptimizationApplication -from .graph_partition import GraphPartition -from .knapsack import Knapsack -from .max_cut import Maxcut -from .number_partition import NumberPartition -from .optimization_application import OptimizationApplication -from .set_packing import SetPacking -from .stable_set import StableSet -from .tsp import Tsp -from .vehicle_routing import VehicleRouting -from .vertex_cover import VertexCover +#from .exact_cover import ExactCover +#from .graph_optimization_application import GraphOptimizationApplication +#from .graph_partition import GraphPartition +#from .knapsack import Knapsack +#from .max_cut import Maxcut +#from .number_partition import NumberPartition +#from .optimization_application import OptimizationApplication +#from .set_packing import SetPacking +#from .stable_set import StableSet +#from .tsp import Tsp +#from .vehicle_routing import VehicleRouting +#from .vertex_cover import VertexCover _all__ = [ "Clique", diff --git a/qiskit_optimization/applications/clique.py b/qiskit_optimization/applications/clique.py index da7f730c6..6ad585e0b 100644 --- a/qiskit_optimization/applications/clique.py +++ b/qiskit_optimization/applications/clique.py @@ -13,7 +13,8 @@ """An application class for the clique.""" from typing import Optional, Union, List, Dict -import networkx as nx +import retworkx as rx +from retworkx.visualization import mpl_draw import numpy as np from docplex.mp.model import Model @@ -31,7 +32,7 @@ class Clique(GraphOptimizationApplication): """ def __init__( - self, graph: Union[nx.Graph, np.ndarray, List], size: Optional[int] = None + self, graph: rx.PyGraph, size: Optional[int] = None ) -> None: """ Args: @@ -53,12 +54,12 @@ def to_quadratic_program(self) -> QuadraticProgram: The :class:`~qiskit_optimization.problems.QuadraticProgram` created from the clique problem instance. """ - complement_g = nx.complement(self._graph) - + complement_g = rx.complement(self._graph) + print('XXX', self._graph.edge_list()) mdl = Model(name="Clique") - n = self._graph.number_of_nodes() + n = len(self._graph.nodes()) x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(n)} - for w, v in complement_g.edges: + for w, v in complement_g.edge_list(): mdl.add_constraint(x[w] + x[v] <= 1) if self.size is None: mdl.maximize(mdl.sum(x[i] for i in x)) @@ -96,13 +97,13 @@ def _draw_result( pos: The positions of nodes """ x = self._result_to_x(result) - nx.draw(self._graph, node_color=self._node_colors(x), pos=pos, with_labels=True) + mpl_draw(self._graph, node_color=self._node_colors(x), pos=pos, with_labels=True) def _node_colors(self, x: np.ndarray) -> List[str]: # Return a list of strings for draw. # Color a node with red when the corresponding variable is 1. # Otherwise color it with dark gray. - return ["r" if x[node] else "darkgrey" for node in self._graph.nodes] + return ["r" if x[node] else "darkgrey" for node in self._graph.nodes()] @property def size(self) -> int: diff --git a/qiskit_optimization/applications/graph_optimization_application.py b/qiskit_optimization/applications/graph_optimization_application.py index 00838d7fa..fcec90f2d 100644 --- a/qiskit_optimization/applications/graph_optimization_application.py +++ b/qiskit_optimization/applications/graph_optimization_application.py @@ -15,7 +15,8 @@ from abc import abstractmethod from typing import Union, Optional, Dict, List -import networkx as nx +import retworkx as rx +from retworkx.visualization import mpl_draw import numpy as np from qiskit.exceptions import MissingOptionalLibraryError @@ -35,14 +36,14 @@ class GraphOptimizationApplication(OptimizationApplication): An abstract class for graph optimization applications. """ - def __init__(self, graph: Union[nx.Graph, np.ndarray, List]) -> None: + def __init__(self, graph: rx.PyGraph) -> None: """ Args: graph: A graph representing a problem. It can be specified directly as a NetworkX Graph, or as an array or list if format suitable to build out a NetworkX graph. """ # The view of the graph is stored which means the graph can not be changed. - self._graph = nx.Graph(graph).copy(as_view=True) + self._graph = graph #.copy(as_view=True) def draw( self, @@ -66,7 +67,7 @@ def draw( ) if result is None: - nx.draw(self._graph, pos=pos, with_labels=True) + mpl_draw(self._graph, pos=pos, with_labels=True) else: self._draw_result(result, pos) @@ -85,7 +86,7 @@ def _draw_result( pass @property - def graph(self) -> nx.Graph: + def graph(self) -> rx.PyGraph: """Getter of the graph Returns: @@ -94,7 +95,7 @@ def graph(self) -> nx.Graph: return self._graph @staticmethod - def random_graph(num_nodes: int, num_edges: int, seed: Optional[int] = None) -> nx.Graph: + def random_graph(num_nodes: int, num_edges: int, seed: Optional[int] = None) -> rx.PyGraph: """ Args: @@ -105,5 +106,5 @@ def random_graph(num_nodes: int, num_edges: int, seed: Optional[int] = None) -> Returns: A random graph of NetworkX """ - graph = nx.gnm_random_graph(num_nodes, num_edges, seed) + graph = rx.undirected_gnm_random_graph(num_nodes, num_edges, seed) return graph diff --git a/qiskit_optimization/applications/graph_partition.py b/qiskit_optimization/applications/graph_partition.py index 9d3370e90..fb45cb78b 100644 --- a/qiskit_optimization/applications/graph_partition.py +++ b/qiskit_optimization/applications/graph_partition.py @@ -14,7 +14,7 @@ from typing import Dict, List, Optional, Union -import networkx as nx +import retworkx as nx import numpy as np from docplex.mp.model import Model diff --git a/qiskit_optimization/applications/max_cut.py b/qiskit_optimization/applications/max_cut.py index 3510773cc..77e97d389 100644 --- a/qiskit_optimization/applications/max_cut.py +++ b/qiskit_optimization/applications/max_cut.py @@ -14,7 +14,7 @@ """An application class for the Max-cut.""" from typing import List, Dict, Optional, Union -import networkx as nx +import retworkx as nx import numpy as np from docplex.mp.model import Model diff --git a/qiskit_optimization/applications/stable_set.py b/qiskit_optimization/applications/stable_set.py index ae2fb8e07..e354e3203 100644 --- a/qiskit_optimization/applications/stable_set.py +++ b/qiskit_optimization/applications/stable_set.py @@ -14,7 +14,7 @@ from typing import Dict, List, Optional, Union -import networkx as nx +import retworkx as nx import numpy as np from docplex.mp.model import Model diff --git a/qiskit_optimization/applications/tsp.py b/qiskit_optimization/applications/tsp.py index 822f8a601..5e3c63d7c 100644 --- a/qiskit_optimization/applications/tsp.py +++ b/qiskit_optimization/applications/tsp.py @@ -13,7 +13,7 @@ """An application class for Traveling salesman problem (TSP).""" from typing import Dict, List, Optional, Union -import networkx as nx +import retworkx as nx import numpy as np from docplex.mp.model import Model diff --git a/qiskit_optimization/applications/vehicle_routing.py b/qiskit_optimization/applications/vehicle_routing.py index 5be280d1d..d0423df46 100644 --- a/qiskit_optimization/applications/vehicle_routing.py +++ b/qiskit_optimization/applications/vehicle_routing.py @@ -16,7 +16,7 @@ import random from typing import List, Dict, Union, Optional -import networkx as nx +import retworkx as nx import numpy as np from docplex.mp.model import Model diff --git a/qiskit_optimization/applications/vertex_cover.py b/qiskit_optimization/applications/vertex_cover.py index a645cd95b..8afa28aee 100644 --- a/qiskit_optimization/applications/vertex_cover.py +++ b/qiskit_optimization/applications/vertex_cover.py @@ -14,7 +14,7 @@ from typing import Dict, List, Optional, Union -import networkx as nx +import retworkx as nx import numpy as np from docplex.mp.model import Model diff --git a/test/applications/test_clique.py b/test/applications/test_clique.py index c219bfcb7..642aabc3b 100644 --- a/test/applications/test_clique.py +++ b/test/applications/test_clique.py @@ -13,7 +13,7 @@ """ Test Clique class""" from test.optimization_test_case import QiskitOptimizationTestCase -import networkx as nx +import retworkx as rx from qiskit_optimization import QuadraticProgram from qiskit_optimization.algorithms import OptimizationResult, OptimizationResultStatus @@ -27,7 +27,8 @@ class TestClique(QiskitOptimizationTestCase): def setUp(self): """Set up for the tests""" super().setUp() - self.graph = nx.gnm_random_graph(5, 8, 123) + self.graph = rx.undirected_gnm_random_graph(5, 8, 123) + print('XXX', self.graph.edge_list()) op = QuadraticProgram() for _ in range(5): op.binary_var() From 1778ebe388915a88787f1586bfb9ef245a659fd7 Mon Sep 17 00:00:00 2001 From: Takashi Imamichi Date: Fri, 28 May 2021 12:25:46 +0900 Subject: [PATCH 2/7] (wip) replacement of networkx with retworkx --- qiskit_optimization/applications/__init__.py | 25 +++++++++--------- qiskit_optimization/applications/clique.py | 15 +++++------ .../graph_optimization_application.py | 26 +++++++++++++++---- .../applications/graph_partition.py | 17 ++++++------ qiskit_optimization/applications/max_cut.py | 16 ++++++------ qiskit_optimization/applications/tsp.py | 9 ++++--- .../applications/vehicle_routing.py | 20 +++++++------- .../applications/vertex_cover.py | 11 ++++---- requirements.txt | 1 + test/applications/test_clique.py | 2 +- test/applications/test_graph_partition.py | 1 + 11 files changed, 83 insertions(+), 60 deletions(-) diff --git a/qiskit_optimization/applications/__init__.py b/qiskit_optimization/applications/__init__.py index eddf935b4..403510116 100644 --- a/qiskit_optimization/applications/__init__.py +++ b/qiskit_optimization/applications/__init__.py @@ -48,18 +48,19 @@ """ from .clique import Clique -#from .exact_cover import ExactCover -#from .graph_optimization_application import GraphOptimizationApplication -#from .graph_partition import GraphPartition -#from .knapsack import Knapsack -#from .max_cut import Maxcut -#from .number_partition import NumberPartition -#from .optimization_application import OptimizationApplication -#from .set_packing import SetPacking -#from .stable_set import StableSet -#from .tsp import Tsp -#from .vehicle_routing import VehicleRouting -#from .vertex_cover import VertexCover + +# from .exact_cover import ExactCover +from .graph_optimization_application import GraphOptimizationApplication +from .graph_partition import GraphPartition +from .knapsack import Knapsack +from .max_cut import Maxcut +from .number_partition import NumberPartition +from .optimization_application import OptimizationApplication +from .set_packing import SetPacking +from .stable_set import StableSet +from .tsp import Tsp +from .vehicle_routing import VehicleRouting +from .vertex_cover import VertexCover _all__ = [ "Clique", diff --git a/qiskit_optimization/applications/clique.py b/qiskit_optimization/applications/clique.py index 6ad585e0b..6d35204e8 100644 --- a/qiskit_optimization/applications/clique.py +++ b/qiskit_optimization/applications/clique.py @@ -11,15 +11,17 @@ # that they have been altered from the originals. """An application class for the clique.""" -from typing import Optional, Union, List, Dict +from typing import Dict, List, Optional, Union -import retworkx as rx -from retworkx.visualization import mpl_draw +import networkx as nx import numpy as np +import retworkx as rx from docplex.mp.model import Model +from retworkx.visualization import mpl_draw from qiskit_optimization.algorithms import OptimizationResult from qiskit_optimization.problems.quadratic_program import QuadraticProgram + from .graph_optimization_application import GraphOptimizationApplication @@ -31,9 +33,7 @@ class Clique(GraphOptimizationApplication): https://en.wikipedia.org/wiki/Clique_(graph_theory) """ - def __init__( - self, graph: rx.PyGraph, size: Optional[int] = None - ) -> None: + def __init__(self, graph: Union[rx.PyGraph, nx.Graph], size: Optional[int] = None) -> None: """ Args: graph: A graph representing a clique problem. It can be specified directly as a @@ -55,9 +55,8 @@ def to_quadratic_program(self) -> QuadraticProgram: from the clique problem instance. """ complement_g = rx.complement(self._graph) - print('XXX', self._graph.edge_list()) mdl = Model(name="Clique") - n = len(self._graph.nodes()) + n = self._graph.num_nodes() x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(n)} for w, v in complement_g.edge_list(): mdl.add_constraint(x[w] + x[v] <= 1) diff --git a/qiskit_optimization/applications/graph_optimization_application.py b/qiskit_optimization/applications/graph_optimization_application.py index fcec90f2d..71b7c5e03 100644 --- a/qiskit_optimization/applications/graph_optimization_application.py +++ b/qiskit_optimization/applications/graph_optimization_application.py @@ -13,14 +13,16 @@ """An abstract class for graph optimization application classes.""" from abc import abstractmethod -from typing import Union, Optional, Dict, List +from typing import Dict, Optional, Union +import networkx as nx +import numpy as np import retworkx as rx from retworkx.visualization import mpl_draw -import numpy as np -from qiskit.exceptions import MissingOptionalLibraryError +from qiskit.exceptions import MissingOptionalLibraryError from qiskit_optimization.algorithms import OptimizationResult + from .optimization_application import OptimizationApplication try: @@ -36,14 +38,19 @@ class GraphOptimizationApplication(OptimizationApplication): An abstract class for graph optimization applications. """ - def __init__(self, graph: rx.PyGraph) -> None: + def __init__(self, graph: Union[rx.PyGraph, nx.Graph]) -> None: """ Args: graph: A graph representing a problem. It can be specified directly as a NetworkX Graph, or as an array or list if format suitable to build out a NetworkX graph. """ # The view of the graph is stored which means the graph can not be changed. - self._graph = graph #.copy(as_view=True) + if isinstance(graph, rx.PyGraph): + self._graph = graph.copy() + elif isinstance(graph, nx.Graph): + self._graph = rx.networkx_converter(graph) + else: + raise TypeError("graph should be rx.PyGraph or nx.Graph") def draw( self, @@ -108,3 +115,12 @@ def random_graph(num_nodes: int, num_edges: int, seed: Optional[int] = None) -> """ graph = rx.undirected_gnm_random_graph(num_nodes, num_edges, seed) return graph + + @staticmethod + def random_geometric_graph(num_nodes: int, radius: float, + seed: Optional[int] = None) -> rx.PyGraph: + """ + + """ + graph = rx.PyGraph() + graph.add_nodes_from(range(num_nodes)) diff --git a/qiskit_optimization/applications/graph_partition.py b/qiskit_optimization/applications/graph_partition.py index fb45cb78b..56c264ebc 100644 --- a/qiskit_optimization/applications/graph_partition.py +++ b/qiskit_optimization/applications/graph_partition.py @@ -14,7 +14,8 @@ from typing import Dict, List, Optional, Union -import retworkx as nx +import retworkx as rx +from retworkx.visualization import mpl_draw import numpy as np from docplex.mp.model import Model @@ -39,13 +40,13 @@ def to_quadratic_program(self) -> QuadraticProgram: from the graph partition instance. """ mdl = Model(name="Graph partition") - n = self._graph.number_of_nodes() + n = self._graph.num_nodes() x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(n)} - for w, v in self._graph.edges: - self._graph.edges[w, v].setdefault("weight", 1) + for i, j in self._graph.edge_list(): + self._graph.get_edge_data(i, j).setdefault("weight", 1) objective = mdl.sum( - self._graph.edges[i, j]["weight"] * (x[i] + x[j] - 2 * x[i] * x[j]) - for i, j in self._graph.edges + self._graph.get_edge_data(i, j)["weight"] * (x[i] + x[j] - 2 * x[i] * x[j]) + for i, j in self._graph.edge_list() ) mdl.minimize(objective) mdl.add_constraint(mdl.sum([x[i] for i in x]) == n // 2) @@ -83,10 +84,10 @@ def _draw_result( pos: The positions of nodes """ x = self._result_to_x(result) - nx.draw(self._graph, node_color=self._node_colors(x), pos=pos, with_labels=True) + mpl_draw(self._graph, node_color=self._node_colors(x), pos=pos, with_labels=True) def _node_colors(self, x: np.ndarray) -> List[str]: # Return a list of strings for draw. # Color a node with red when the corresponding variable is 1. # Otherwise color it with blue. - return ["r" if x[node] else "b" for node in self._graph.nodes] + return ["r" if x[node] else "b" for node in self._graph.nodes()] diff --git a/qiskit_optimization/applications/max_cut.py b/qiskit_optimization/applications/max_cut.py index 77e97d389..99ea2b7c3 100644 --- a/qiskit_optimization/applications/max_cut.py +++ b/qiskit_optimization/applications/max_cut.py @@ -14,7 +14,7 @@ """An application class for the Max-cut.""" from typing import List, Dict, Optional, Union -import retworkx as nx +from retworkx.visualization import mpl_draw import numpy as np from docplex.mp.model import Model @@ -41,14 +41,14 @@ def to_quadratic_program(self) -> QuadraticProgram: """ mdl = Model(name="Max-cut") x = { - i: mdl.binary_var(name="x_{0}".format(i)) for i in range(self._graph.number_of_nodes()) + i: mdl.binary_var(name="x_{0}".format(i)) for i in range(self._graph.num_nodes()) } - for w, v in self._graph.edges: - self._graph.edges[w, v].setdefault("weight", 1) + for i, j in self._graph.edge_list(): + self._graph.get_edge_data(i, j).setdefault("weight", 1) objective = mdl.sum( - self._graph.edges[i, j]["weight"] * x[i] * (1 - x[j]) - + self._graph.edges[i, j]["weight"] * x[j] * (1 - x[i]) - for i, j in self._graph.edges + self._graph.get_edge_data(i, j)["weight"] * x[i] * (1 - x[j]) + + self._graph.get_edge_data(i, j)["weight"] * x[j] * (1 - x[i]) + for i, j in self._graph.edge_list() ) mdl.maximize(objective) op = QuadraticProgram() @@ -67,7 +67,7 @@ def _draw_result( pos: The positions of nodes """ x = self._result_to_x(result) - nx.draw(self._graph, node_color=self._node_color(x), pos=pos, with_labels=True) + mpl_draw(self._graph, node_color=self._node_color(x), pos=pos, with_labels=True) def interpret(self, result: Union[OptimizationResult, np.ndarray]) -> List[List[int]]: """Interpret a result as two lists of node indices diff --git a/qiskit_optimization/applications/tsp.py b/qiskit_optimization/applications/tsp.py index 5e3c63d7c..e5b393cfa 100644 --- a/qiskit_optimization/applications/tsp.py +++ b/qiskit_optimization/applications/tsp.py @@ -13,7 +13,8 @@ """An application class for Traveling salesman problem (TSP).""" from typing import Dict, List, Optional, Union -import retworkx as nx +import retworkx as rx +from retworkx.visualization import mpl_draw import numpy as np from docplex.mp.model import Model @@ -42,14 +43,14 @@ def to_quadratic_program(self) -> QuadraticProgram: from the traveling salesman problem instance. """ mdl = Model(name="TSP") - n = self._graph.number_of_nodes() + n = self._graph.num_nodes() x = { (i, k): mdl.binary_var(name="x_{0}_{1}".format(i, k)) for i in range(n) for k in range(n) } tsp_func = mdl.sum( - self._graph.edges[i, j]["weight"] * x[(i, k)] * x[(j, (k + 1) % n)] + self._graph.get_edge_data(i, j)["weight"] * x[(i, k)] * x[(j, (k + 1) % n)] for i in range(n) for j in range(n) for k in range(n) @@ -101,7 +102,7 @@ def _draw_result( pos: The positions of nodes """ x = self._result_to_x(result) - nx.draw(self._graph, with_labels=True, pos=pos) + mpl_draw(self._graph, with_labels=True, pos=pos) nx.draw_networkx_edges( self._graph, pos, diff --git a/qiskit_optimization/applications/vehicle_routing.py b/qiskit_optimization/applications/vehicle_routing.py index d0423df46..3ac8d7aee 100644 --- a/qiskit_optimization/applications/vehicle_routing.py +++ b/qiskit_optimization/applications/vehicle_routing.py @@ -16,7 +16,9 @@ import random from typing import List, Dict, Union, Optional -import retworkx as nx +import networkx as nx +import retworkx as rx +from retworkx.visualization import mpl_draw import numpy as np from docplex.mp.model import Model @@ -34,7 +36,7 @@ class VehicleRouting(GraphOptimizationApplication): def __init__( self, - graph: Union[nx.Graph, np.ndarray, List], + graph: Union[rx.PyGraph, nx.Graph], num_vehicles: int = 2, depot: int = 0, ) -> None: @@ -59,7 +61,7 @@ def to_quadratic_program(self) -> QuadraticProgram: from the vehicle routing problem instance. """ mdl = Model(name="Vehicle routing") - n = self._graph.number_of_nodes() + n = self._graph.num_nodes() x = {} for i in range(n): for j in range(n): @@ -67,7 +69,7 @@ def to_quadratic_program(self) -> QuadraticProgram: x[(i, j)] = mdl.binary_var(name="x_{0}_{1}".format(i, j)) mdl.minimize( mdl.sum( - self._graph.edges[i, j]["weight"] * x[(i, j)] + self._graph.get_edge_data(i, j)["weight"] * x[(i, j)] for i in range(n) for j in range(n) if i != j @@ -113,7 +115,7 @@ def interpret(self, result: Union[OptimizationResult, np.ndarray]) -> List[List[ A list of the routes for each vehicle """ x = self._result_to_x(result) - n = self._graph.number_of_nodes() + n = self._graph.num_nodes() idx = 0 edge_list = [] for i in range(n): @@ -158,8 +160,8 @@ def _draw_result( import matplotlib.pyplot as plt route_list = self.interpret(result) - nx.draw(self._graph, with_labels=True, pos=pos) - nx.draw_networkx_edges( + mpl_draw(self._graph, with_labels=True, pos=pos) + mpl_draw( self._graph, pos, edgelist=self._edgelist(route_list), @@ -240,8 +242,8 @@ def create_random_instance( """ random.seed(seed) pos = {i: (random.randint(low, high), random.randint(low, high)) for i in range(n)} - graph = nx.random_geometric_graph(n, np.hypot(high - low, high - low) + 1, pos=pos) + graph = rx.random_geometric_graph(n, np.hypot(high - low, high - low) + 1, pos=pos) for w, v in graph.edges: delta = [graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)] - graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1])) + graph.get_edge_data(w, v)["weight"] = np.rint(np.hypot(delta[0], delta[1])) return VehicleRouting(graph, num_vehicle, depot) diff --git a/qiskit_optimization/applications/vertex_cover.py b/qiskit_optimization/applications/vertex_cover.py index 8afa28aee..896509591 100644 --- a/qiskit_optimization/applications/vertex_cover.py +++ b/qiskit_optimization/applications/vertex_cover.py @@ -14,7 +14,8 @@ from typing import Dict, List, Optional, Union -import retworkx as nx +import retworkx as rx +from retworkx.visualization import mpl_draw import numpy as np from docplex.mp.model import Model @@ -39,10 +40,10 @@ def to_quadratic_program(self) -> QuadraticProgram: from the vertex cover instance. """ mdl = Model(name="Vertex cover") - n = self._graph.number_of_nodes() + n = self._graph.num_nodes() x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(n)} objective = mdl.sum(x[i] for i in x) - for w, v in self._graph.edges: + for w, v in self._graph.edge_list(): mdl.add_constraint(x[w] + x[v] >= 1) mdl.minimize(objective) op = QuadraticProgram() @@ -77,10 +78,10 @@ def _draw_result( pos: The positions of nodes """ x = self._result_to_x(result) - nx.draw(self._graph, node_color=self._node_colors(x), pos=pos, with_labels=True) + mpl_draw(self._graph, node_color=self._node_colors(x), pos=pos, with_labels=True) def _node_colors(self, x: np.ndarray) -> List[str]: # Return a list of strings for draw. # Color a node with red when the corresponding variable is 1. # Otherwise color it with dark gray. - return ["r" if x[node] else "darkgrey" for node in self._graph.nodes] + return ["r" if x[node] else "darkgrey" for node in self._graph.nodes()] diff --git a/requirements.txt b/requirements.txt index 3c7f538c9..826211319 100644 --- a/requirements.txt +++ b/requirements.txt @@ -5,4 +5,5 @@ docplex; sys_platform != 'darwin' docplex==2.15.194; sys_platform == 'darwin' setuptools>=40.1.0 networkx>=2.2 +retworkx>=0.9.0 dataclasses; python_version < '3.7' diff --git a/test/applications/test_clique.py b/test/applications/test_clique.py index 642aabc3b..c76f03432 100644 --- a/test/applications/test_clique.py +++ b/test/applications/test_clique.py @@ -13,6 +13,7 @@ """ Test Clique class""" from test.optimization_test_case import QiskitOptimizationTestCase + import retworkx as rx from qiskit_optimization import QuadraticProgram @@ -28,7 +29,6 @@ def setUp(self): """Set up for the tests""" super().setUp() self.graph = rx.undirected_gnm_random_graph(5, 8, 123) - print('XXX', self.graph.edge_list()) op = QuadraticProgram() for _ in range(5): op.binary_var() diff --git a/test/applications/test_graph_partition.py b/test/applications/test_graph_partition.py index fb0ef1e60..0fd6efa7d 100644 --- a/test/applications/test_graph_partition.py +++ b/test/applications/test_graph_partition.py @@ -12,6 +12,7 @@ """ Test GraphPartinioning class""" from test.optimization_test_case import QiskitOptimizationTestCase + import networkx as nx from qiskit_optimization import QuadraticProgram From f1491c21862f0ca7b416f8bb07de127b9460e30d Mon Sep 17 00:00:00 2001 From: Takashi Imamichi Date: Fri, 28 May 2021 14:47:16 +0900 Subject: [PATCH 3/7] update --- .../graph_optimization_application.py | 10 ++++---- qiskit_optimization/applications/max_cut.py | 4 +-- qiskit_optimization/applications/tsp.py | 25 +++++++++++++------ test/applications/test_tsp.py | 2 +- 4 files changed, 24 insertions(+), 17 deletions(-) diff --git a/qiskit_optimization/applications/graph_optimization_application.py b/qiskit_optimization/applications/graph_optimization_application.py index 71b7c5e03..c94f86037 100644 --- a/qiskit_optimization/applications/graph_optimization_application.py +++ b/qiskit_optimization/applications/graph_optimization_application.py @@ -117,10 +117,10 @@ def random_graph(num_nodes: int, num_edges: int, seed: Optional[int] = None) -> return graph @staticmethod - def random_geometric_graph(num_nodes: int, radius: float, - seed: Optional[int] = None) -> rx.PyGraph: - """ - - """ + def random_geometric_graph( + num_nodes: int, radius: float, seed: Optional[int] = None + ) -> rx.PyGraph: + """ """ graph = rx.PyGraph() graph.add_nodes_from(range(num_nodes)) + return graph diff --git a/qiskit_optimization/applications/max_cut.py b/qiskit_optimization/applications/max_cut.py index 99ea2b7c3..c51d78a3e 100644 --- a/qiskit_optimization/applications/max_cut.py +++ b/qiskit_optimization/applications/max_cut.py @@ -40,9 +40,7 @@ def to_quadratic_program(self) -> QuadraticProgram: from the Max-cut problem instance. """ mdl = Model(name="Max-cut") - x = { - i: mdl.binary_var(name="x_{0}".format(i)) for i in range(self._graph.num_nodes()) - } + x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(self._graph.num_nodes())} for i, j in self._graph.edge_list(): self._graph.get_edge_data(i, j).setdefault("weight", 1) objective = mdl.sum( diff --git a/qiskit_optimization/applications/tsp.py b/qiskit_optimization/applications/tsp.py index e5b393cfa..f4098798a 100644 --- a/qiskit_optimization/applications/tsp.py +++ b/qiskit_optimization/applications/tsp.py @@ -13,12 +13,13 @@ """An application class for Traveling salesman problem (TSP).""" from typing import Dict, List, Optional, Union -import retworkx as rx -from retworkx.visualization import mpl_draw import numpy as np +import retworkx as rx from docplex.mp.model import Model +from retworkx.visualization import mpl_draw from qiskit.utils import algorithm_globals + from ..algorithms import OptimizationResult from ..exceptions import QiskitOptimizationError from ..problems.quadratic_program import QuadraticProgram @@ -103,7 +104,7 @@ def _draw_result( """ x = self._result_to_x(result) mpl_draw(self._graph, with_labels=True, pos=pos) - nx.draw_networkx_edges( + mpl_draw( self._graph, pos, edgelist=self._edgelist(x), @@ -133,12 +134,20 @@ def create_random_instance(n: int, low: int = 0, high: int = 100, seed: int = No """ if seed: algorithm_globals.random_seed = seed - coord = algorithm_globals.random.uniform(low, high, (n, 2)) + dim = 2 + coord = algorithm_globals.random.uniform(low, high, (n, dim)) pos = {i: (coord_[0], coord_[1]) for i, coord_ in enumerate(coord)} - graph = nx.random_geometric_graph(n, np.hypot(high - low, high - low) + 1, pos=pos) - for w, v in graph.edges: - delta = [graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)] - graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1])) + graph = rx.PyGraph() + graph.add_nodes_from([{"pos": pos[i]} for i in range(n)]) + #for i, coord in pos.items(): + # graph.get_node_data(i)["pos"] = coord + for i in range(n): + for j in range(i + 1, n): + delta = [ + graph.get_node_data(i)["pos"][d] - graph.get_node_data(j)["pos"][d] + for d in range(dim) + ] + graph.add_edge(i, j, {"weight": np.rint(np.hypot(*delta))}) return Tsp(graph) @staticmethod diff --git a/test/applications/test_tsp.py b/test/applications/test_tsp.py index b8552a321..b6f2ca9d7 100644 --- a/test/applications/test_tsp.py +++ b/test/applications/test_tsp.py @@ -97,6 +97,6 @@ def test_create_random_instance(self): """Test create_random_instance""" tsp = Tsp.create_random_instance(n=3, seed=123) graph = tsp.graph - edge_weight = [graph.edges[edge]["weight"] for edge in graph.edges] + edge_weight = [graph.get_edge_data(*edge)["weight"] for edge in graph.edge_list()] expected_weight = [48, 91, 63] self.assertEqual(edge_weight, expected_weight) From 8018c4cb9275d40fe1f6f29b5f0c3b2c424904e0 Mon Sep 17 00:00:00 2001 From: Takashi Imamichi Date: Fri, 28 May 2021 19:24:02 +0900 Subject: [PATCH 4/7] update --- qiskit_optimization/applications/__init__.py | 3 +-- qiskit_optimization/applications/clique.py | 4 +++- .../graph_optimization_application.py | 15 ++++-------- .../applications/stable_set.py | 14 +++++------ qiskit_optimization/applications/tsp.py | 23 ++++++++----------- .../applications/vehicle_routing.py | 21 ++++++++++------- test/applications/test_vehicle_routing.py | 19 ++------------- 7 files changed, 39 insertions(+), 60 deletions(-) diff --git a/qiskit_optimization/applications/__init__.py b/qiskit_optimization/applications/__init__.py index 403510116..cf9ff3e90 100644 --- a/qiskit_optimization/applications/__init__.py +++ b/qiskit_optimization/applications/__init__.py @@ -48,8 +48,7 @@ """ from .clique import Clique - -# from .exact_cover import ExactCover +from .exact_cover import ExactCover from .graph_optimization_application import GraphOptimizationApplication from .graph_partition import GraphPartition from .knapsack import Knapsack diff --git a/qiskit_optimization/applications/clique.py b/qiskit_optimization/applications/clique.py index 6d35204e8..d32137709 100644 --- a/qiskit_optimization/applications/clique.py +++ b/qiskit_optimization/applications/clique.py @@ -33,7 +33,9 @@ class Clique(GraphOptimizationApplication): https://en.wikipedia.org/wiki/Clique_(graph_theory) """ - def __init__(self, graph: Union[rx.PyGraph, nx.Graph], size: Optional[int] = None) -> None: + def __init__( + self, graph: Union[rx.PyGraph, nx.Graph, np.ndarray, List], size: Optional[int] = None + ) -> None: """ Args: graph: A graph representing a clique problem. It can be specified directly as a diff --git a/qiskit_optimization/applications/graph_optimization_application.py b/qiskit_optimization/applications/graph_optimization_application.py index c94f86037..8e5a65109 100644 --- a/qiskit_optimization/applications/graph_optimization_application.py +++ b/qiskit_optimization/applications/graph_optimization_application.py @@ -13,7 +13,7 @@ """An abstract class for graph optimization application classes.""" from abc import abstractmethod -from typing import Dict, Optional, Union +from typing import Dict, Optional, Union, List import networkx as nx import numpy as np @@ -38,7 +38,7 @@ class GraphOptimizationApplication(OptimizationApplication): An abstract class for graph optimization applications. """ - def __init__(self, graph: Union[rx.PyGraph, nx.Graph]) -> None: + def __init__(self, graph: Union[rx.PyGraph, nx.Graph, np.ndarray, List]) -> None: """ Args: graph: A graph representing a problem. It can be specified directly as a @@ -49,6 +49,8 @@ def __init__(self, graph: Union[rx.PyGraph, nx.Graph]) -> None: self._graph = graph.copy() elif isinstance(graph, nx.Graph): self._graph = rx.networkx_converter(graph) + elif isinstance(graph, (np.ndarray, List)): + self._graph = rx.PyGraph.from_adjacency_matrix(graph) else: raise TypeError("graph should be rx.PyGraph or nx.Graph") @@ -115,12 +117,3 @@ def random_graph(num_nodes: int, num_edges: int, seed: Optional[int] = None) -> """ graph = rx.undirected_gnm_random_graph(num_nodes, num_edges, seed) return graph - - @staticmethod - def random_geometric_graph( - num_nodes: int, radius: float, seed: Optional[int] = None - ) -> rx.PyGraph: - """ """ - graph = rx.PyGraph() - graph.add_nodes_from(range(num_nodes)) - return graph diff --git a/qiskit_optimization/applications/stable_set.py b/qiskit_optimization/applications/stable_set.py index e354e3203..30fac6917 100644 --- a/qiskit_optimization/applications/stable_set.py +++ b/qiskit_optimization/applications/stable_set.py @@ -14,7 +14,7 @@ from typing import Dict, List, Optional, Union -import retworkx as nx +from retworkx.visualization import mpl_draw import numpy as np from docplex.mp.model import Model @@ -40,12 +40,12 @@ def to_quadratic_program(self) -> QuadraticProgram: from the stable set instance. """ mdl = Model(name="Stable set") - n = self._graph.number_of_nodes() + n = self._graph.num_nodes() x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(n)} - for w, v in self._graph.edges: - self._graph.edges[w, v].setdefault("weight", 1) + for w, v in self._graph.edge_list(): + self._graph.get_edge_data(w, v).setdefault("weight", 1) objective = mdl.sum(x[i] for i in x) - for w, v in self._graph.edges: + for w, v in self._graph.edge_list(): mdl.add_constraint(x[w] + x[v] <= 1) mdl.maximize(objective) op = QuadraticProgram() @@ -80,10 +80,10 @@ def _draw_result( pos: The positions of nodes """ x = self._result_to_x(result) - nx.draw(self._graph, node_color=self._node_colors(x), pos=pos, with_labels=True) + mpl_draw(self._graph, node_color=self._node_colors(x), pos=pos, with_labels=True) def _node_colors(self, x: np.ndarray): # Return a list of strings for draw. # Color a node with red when the corresponding variable is 1. # Otherwise color it with dark gray. - return ["r" if x[node] == 1 else "darkgrey" for node in self._graph.nodes] + return ["r" if x[node] == 1 else "darkgrey" for node in self._graph.nodes()] diff --git a/qiskit_optimization/applications/tsp.py b/qiskit_optimization/applications/tsp.py index f4098798a..b91619ba7 100644 --- a/qiskit_optimization/applications/tsp.py +++ b/qiskit_optimization/applications/tsp.py @@ -107,7 +107,7 @@ def _draw_result( mpl_draw( self._graph, pos, - edgelist=self._edgelist(x), + edge_list=self._edgelist(x), width=8, alpha=0.5, edge_color="tab:red", @@ -135,19 +135,14 @@ def create_random_instance(n: int, low: int = 0, high: int = 100, seed: int = No if seed: algorithm_globals.random_seed = seed dim = 2 - coord = algorithm_globals.random.uniform(low, high, (n, dim)) - pos = {i: (coord_[0], coord_[1]) for i, coord_ in enumerate(coord)} - graph = rx.PyGraph() - graph.add_nodes_from([{"pos": pos[i]} for i in range(n)]) - #for i, coord in pos.items(): - # graph.get_node_data(i)["pos"] = coord - for i in range(n): - for j in range(i + 1, n): - delta = [ - graph.get_node_data(i)["pos"][d] - graph.get_node_data(j)["pos"][d] - for d in range(dim) - ] - graph.add_edge(i, j, {"weight": np.rint(np.hypot(*delta))}) + pos = algorithm_globals.random.uniform(low, high, (n, dim)) + graph = rx.random_geometric_graph(n, np.hypot(high - low, high - low) + 1, pos=pos) + for i, j in graph.edge_list(): + delta = [ + graph.get_node_data(i)["pos"][d] - graph.get_node_data(j)["pos"][d] + for d in range(dim) + ] + graph.update_edge(i, j, {"weight": np.rint(np.hypot(delta[0], delta[1]))}) return Tsp(graph) @staticmethod diff --git a/qiskit_optimization/applications/vehicle_routing.py b/qiskit_optimization/applications/vehicle_routing.py index 3ac8d7aee..b4ff997d1 100644 --- a/qiskit_optimization/applications/vehicle_routing.py +++ b/qiskit_optimization/applications/vehicle_routing.py @@ -13,7 +13,6 @@ """An application class for the vehicle routing problem.""" import itertools -import random from typing import List, Dict, Union, Optional import networkx as nx @@ -22,6 +21,7 @@ import numpy as np from docplex.mp.model import Model +from qiskit.utils import algorithm_globals from qiskit_optimization.algorithms import OptimizationResult from qiskit_optimization.problems.quadratic_program import QuadraticProgram from .graph_optimization_application import GraphOptimizationApplication @@ -36,7 +36,7 @@ class VehicleRouting(GraphOptimizationApplication): def __init__( self, - graph: Union[rx.PyGraph, nx.Graph], + graph: Union[rx.PyGraph, nx.Graph, np.ndarray, List], num_vehicles: int = 2, depot: int = 0, ) -> None: @@ -164,7 +164,7 @@ def _draw_result( mpl_draw( self._graph, pos, - edgelist=self._edgelist(route_list), + edge_list=self._edgelist(route_list), width=8, alpha=0.5, edge_color=self._edge_color(route_list), @@ -240,10 +240,15 @@ def create_random_instance( Returns: A VehicleRouting instance created from the input information """ - random.seed(seed) - pos = {i: (random.randint(low, high), random.randint(low, high)) for i in range(n)} + if seed: + algorithm_globals.random_seed = seed + dim = 2 + pos = algorithm_globals.random.uniform(low, high, (n, dim)) graph = rx.random_geometric_graph(n, np.hypot(high - low, high - low) + 1, pos=pos) - for w, v in graph.edges: - delta = [graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)] - graph.get_edge_data(w, v)["weight"] = np.rint(np.hypot(delta[0], delta[1])) + for i, j in graph.edge_list(): + delta = [ + graph.get_node_data(i)["pos"][d] - graph.get_node_data(j)["pos"][d] + for d in range(dim) + ] + graph.update_edge(i, j, {"weight": np.rint(np.hypot(delta[0], delta[1]))}) return VehicleRouting(graph, num_vehicle, depot) diff --git a/test/applications/test_vehicle_routing.py b/test/applications/test_vehicle_routing.py index bbdb2006e..47190fe38 100644 --- a/test/applications/test_vehicle_routing.py +++ b/test/applications/test_vehicle_routing.py @@ -28,16 +28,10 @@ class TestVehicleRouting(QiskitOptimizationTestCase): def setUp(self): super().setUp() - random.seed(600) + seed = 600 low = 0 high = 100 - pos = {i: (random.randint(low, high), random.randint(low, high)) for i in range(4)} - self.graph = nx.random_geometric_graph(4, np.hypot(high - low, high - low) + 1, pos=pos) - for w, v in self.graph.edges: - delta = [ - self.graph.nodes[w]["pos"][i] - self.graph.nodes[v]["pos"][i] for i in range(2) - ] - self.graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1])) + self.graph = VehicleRouting.create_random_instance(4, low, high, seed).graph op = QuadraticProgram() for i in range(12): op.binary_var() @@ -344,15 +338,6 @@ def test_edge_color_nv3(self): [0.0, 0.0, 1 / 3, 1 / 3, 2 / 3, 2 / 3], ) - def test_create_random_instance(self): - """Test create_random_instance""" - vehicle_routing = VehicleRouting.create_random_instance(n=4, seed=600) - graph = vehicle_routing.graph - for node in graph.nodes: - self.assertEqual(graph.nodes[node]["pos"], self.graph.nodes[node]["pos"]) - for edge in graph.edges: - self.assertEqual(graph.edges[edge]["weight"], self.graph.edges[edge]["weight"]) - def test_num_vehicles(self): """Test num_vehicles""" vehicle_routing = VehicleRouting(self.graph, num_vehicles=2) From 7a3f55ab2b3b5fdcc29a84c03d03a821753a3c41 Mon Sep 17 00:00:00 2001 From: Takashi Imamichi Date: Fri, 28 May 2021 19:39:31 +0900 Subject: [PATCH 5/7] update --- .../06_examples_max_cut_and_tsp.ipynb | 4313 +---------------- qiskit_optimization/applications/max_cut.py | 6 +- 2 files changed, 73 insertions(+), 4246 deletions(-) diff --git a/docs/tutorials/06_examples_max_cut_and_tsp.ipynb b/docs/tutorials/06_examples_max_cut_and_tsp.ipynb index c049119e6..abf7a1156 100644 --- a/docs/tutorials/06_examples_max_cut_and_tsp.ipynb +++ b/docs/tutorials/06_examples_max_cut_and_tsp.ipynb @@ -105,6 +105,16 @@ "execution_count": 1, "metadata": {}, "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], "source": [ "# useful additional packages \n", "import matplotlib.pyplot as plt\n", @@ -112,6 +122,7 @@ "%matplotlib inline\n", "import numpy as np\n", "import networkx as nx\n", + "import retworkx as rx\n", "\n", "from qiskit import Aer\n", "from qiskit.tools.visualization import plot_histogram\n", @@ -133,393 +144,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:19.271591\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "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\n", "text/plain": [ "
" ] @@ -552,7 +182,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "tags": [] }, @@ -590,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "tags": [] }, @@ -621,388 +251,7 @@ }, { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:19.603352\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "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\n", "text/plain": [ "
" ] @@ -1045,7 +294,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": { "tags": [] }, @@ -1054,6 +303,7 @@ "name": "stdout", "output_type": "stream", "text": [ + "[1.0, 1.0, 1.0, 1.0, 1.0]\n", "// This file has been generated by DOcplex\n", "// model name is: Max-cut\n", "// single vars section\n", @@ -1080,7 +330,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -1106,7 +356,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": { "tags": [] }, @@ -1144,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": { "tags": [] }, @@ -1161,388 +411,7 @@ }, { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:20.151559\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "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\n", "text/plain": [ "
" ] @@ -1576,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -1588,7 +457,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": { "scrolled": true, "tags": [ @@ -1600,397 +469,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "energy: -1.4999796718931908\n", - "time: 3.5326640605926514\n", - "max-cut objective: -3.9999796718931906\n", + "energy: -1.4997993934173715\n", + "time: 1.476668119430542\n", + "max-cut objective: -3.9997993934173715\n", "solution: [0. 1. 0. 1.]\n", "solution objective: 4.0\n" ] }, { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:25.030601\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "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\n", "text/plain": [ "
" ] @@ -2023,7 +511,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": { "tags": [] }, @@ -2039,388 +527,7 @@ }, { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:28.843186\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "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\n", "text/plain": [ "
" ] @@ -2477,7 +584,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 24, "metadata": { "tags": [] }, @@ -2487,453 +594,14 @@ "output_type": "stream", "text": [ "distance\n", - " [[ 0. 48. 91.]\n", - " [48. 0. 63.]\n", - " [91. 63. 0.]]\n" + " [[0. 1. 1.]\n", + " [1. 0. 1.]\n", + " [1. 1. 0.]]\n" ] }, { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:29.081040\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAqCElEQVR4nO3dd3xUVd7H8c+dZDJJSIaQXjYkARcpKqCAvTyorLD21RRaEBAFQl8CIk0ITSArCFKkGUrK6rLPoyJYwAURFpGmILAIAYSEFpKQnszM88cskZIKydw7md/79coLzMzc+eWF+ebk3HN+R7FYLAghhLANndoFCCGEI5HQFUIIG5LQFUIIG5LQFUIIG5LQFUIIG3Ku6kFfX19LeHj4zQ+YzXDyJOTng6KArhbZbTZbP7y9ITjY+nohhGhAfvzxx4sWi8WvoseqDN3w8HB27959/Sfz8qB7d8jJgfDwWwtNs9n6+gcegPnzwcmp9tcQQgiNUhTlZGWP1W56wWKBkSPh4EHw8rr1UapOB40bwxdfwLx5t3YNIYSwQ7UL3Q0b4Jtvbi9wy99ZB0YjLFpkDXEhhHAANQ/d4mJ4+21wc6u7eVhnZ+u1xo6tm+sJIYTG1Tx0v/zSeuPM1bVuK/D0hMOH4dChur2uEEJoUM1Dd8WKalcplJjNTDl7lmePHeOxI0fofvw43+flVX1dRQGTCdaurXEpQghhr6pcvVCutBR++sk6B1sFExCo17O0aVMC9Xq25+Ux9swZUiIiCHZxqfyF7u6wfXstyhZCCPtUs5Hur79al3VVM9J10+kY4OdHsIsLOkXhUU9PgvV6DhcVVX19gwFOn4bCwprWLYQQdqlmoXvuXO02QABmi4WssjJOlZTQzGCo+smKYg31ixdr9R5CCGFvaja9YDJZ1+jWkMVi4edffmEO0M3Li/DqQhd+n9sVQogGrGbD10aNanVRC/CByYRep+PlK1fIyc2l2sg2m61zu0II0YDVbKR7xx3Wm2kWS7VrdC0WC1MzMrii0zE/OBh3vZ6zGRnk5OQQFBiIXq+/+UVlZdZ5Xb8KtyoLIUSDUbORro+PdRdaaWm1T52RmcmJkhKmentDaSlubm5ERETg5ubG8RMnuJydffOot7AQ7r5bmt8IIRq8mt8de+EF6+aIKmSUlvKP7GyOFhXRIyuLbmfP8uiRI2zKzcXP15fwsDCys7M5efIkxSUlv7/QbIaXXrrVr0EIIeyGUtXBlB06dLCUdxk7fhy6dLGu1a3BSoaCwkLOnTtHxA2tIS1AVlYWFy9exMfHBx+jEaW0FHbvljldIUSDoCjKjxaLpUNFj9V8pNusGTz9NOTm1ujpBhcXiouLb5pKUAAfb28iIiLIz8vj/PHjnH/5ZQlcIYRDqN3i24QE60qGGmxicHJyQqcolJWVVfi4i15PUy8vlGbN6P399yxevJiSa6cchBCiAapd6Pr4WJuOFxdbP6phMBgorux5eXkoBgP+f/87SSkpHD16lJ49e/LTTz/VqiQhhLAntT8j7fHHfw/eK1eqfGqFoWuxQHY26PXWJjctWuDv78/cuXPp378/o0aNIjExkULZEiyEaIBu7WDKbt0gJcW6rvbyZahkWsDFYKDk2tAtKrIGbps28Omn0LZt+UOKotClSxfS0tLIzs4mKiqKXbt23VJ5QgihVTVfvVCRwkLryQ8rV1oD1Wy29ts1GEBRyM/LI+f8eYKbNLE2LPfygrg46NGj2nPRtm/fzvTp07n//vsZMWIEnp6et/glCiGEbdXN6oWKuLlZz0zbvRveew9eeQUCA62HV16+jKvZzCmdDkuvXrBsGezYAb171+ggyocffpi0tDRcXFyIjIzk22+/va1ShRBCC25vpFsNi8XCk08+yccff4y3t/ctX2fPnj0kJCTQokUL4uPjb+taQghR3+pvpFv9G9OsWTNOnDhxW9e59957SU5OJjg4mOjoaDZs2EBVPyyEEEKr6jV0AZo1a8bx48dv+zoGg4GhQ4fy3nvvsXr1aoYNG0ZmZmYdVCiEELZT76EbHh5+2yPda7Vu3ZrVq1fTrl07evToQVpaGmazuc6uL4QQ9ckmI926DF0AZ2dn+vbty7Jly9i4cSMDBgzg5MmTdfoeQghRH+xmeqEiERERLFu2jKeeeoq+ffuyatUqTHL6hBBCw+o9dP38/CgsLCS3ho1yakun0xEdHc3q1avZtWsXsbGxHD16tF7eSwghble9h25drWCoTnBwMAsXLiQyMpLBgwfzwQcfSAMdIYTm1HvognUaoL5DF6wB//zzz5OcnMyJEyfo3r07+/fvr/f3FUKImrJZ6NbXvG5FfH19mT17NoMGDWLMmDHMnj2bgoICm72/EEJUxiaha4vphYp07tyZtLQ08vPziYqKYufOnTavQQghrlWz04BvU32uYKiO0Whk8uTJ7Nixg2nTptGhQwdGjBiB0WhUpR4hhGOzyUg3MDCQnJwcVX/Ff/DBB0lNTcXNzY3IyEg2b96sWi1CCMdlk9DV6XSEhYWRnp5ui7erlLu7O/Hx8cycOZOFCxcSHx/PpUuXVK1JCOFYbBK6oO4Uw43atWtHcnIyYWFhREdH8+mnn0oDHSGETdgsdG29gqE6Li4uDB48mAULFpCcnExcXBxnz55VuywhRANn05GuGisYqnPnnXeSlJREhw4d6NWrF6mpqdJARwhRbxxyeuFGzs7OvPbaayxfvpwvv/yS/v37a/IHhBDC/tksdENCQrhw4ULlR7JrQHh4OB9++CHPPPMM/fv3Z8WKFZSVlaldlhCiAbFZ6Do5OREaGqr5Fow6nY7IyEjWrFnD3r176d27N4cPH1a7LCFEA2Gz0AVtTzHcKCgoiPnz59OjRw+GDBnC+++/r+lRuhDCPtg0dLW2gqE6iqLw5z//mdTUVH777TdiYmLYu3ev2mUJIeyYzUPXHm9QeXt7M2vWLOLi4hg3bhyzZs2SBjpCiFti8+kFewzdqzp37kxqairFxcVERkby/fffq12SEMLO2KThzVWhoaGcPXuW0tJS9Hq9Ld+6zhiNRiZOnMi///1vpk2bRrt27Rg1ahSNGzdWuzQhhB2w6UjXxcWFoKAgTp8+bcu3rRf3338/KSkpNG7cmMjISL7++mvZSiyEqJZNQxfsawVDddzd3Rk1ahSzZ89myZIljB49mgsXLqhdlhBCw2weuva2gqEm7rnnHtauXUvz5s2JiYnhf//3f2XUK4SokCqhq3aLx/rg4uLCwIED+eCDD/j4448ZPHgwZ86cUbssIYTGyPRCHWvRogWrVq3igQceoHfv3qxbt04a6Aghytk8dMPCwjh16hQmk8nWb20zTk5O9O7dm5UrV7Jlyxb69evXoH/QCCFqzuah6+rqip+fn0P86t20aVOWLFnCn//8ZwYMGMCyZcsoLS1VuywhhIpsHrrQMG+mVUan0/HKK6+wdu1aDhw4QK9evTh06JDaZQkhVKJK6Nr7zrRbERAQwLx584iNjWX48OHMnz+foqIitcsSQtiYaiNdRwtdsDbQ6dq1KykpKWRmZhITE8OePXvULksIYUOqjXQdZXqhIt7e3kyfPp3hw4czfvx4ZsyYQX5+vtplCSFsQLWRbnp6usMvpXr88cdJTU3FZDIRGRnJd999p3ZJQoh6pkrouru7YzQayczMVOPtNcXT05Px48czadIkZs+ezfjx47l8+bLaZQkh6okqoQuOeTOtKp06dSIlJQUfHx+ioqL48ssvZSuxEA2QqqHryPO6FXFzc2PEiBEkJiaybNkyRo0axfnz59UuSwhRh1QLXUddwVATd911F2vWrKFly5Z0796d9evXy6hXiAZCRroa5eLiwoABA1i8eDHr169n4MCB/Pbbb2qXJYS4TaqPdGUEV7U77riDlStX8sgjjxAbG8uaNWscftWHEPZMtdA1Go0YDAZp+l0DTk5O9OzZk1WrVrFt2zb69OnDr7/+qnZZQohboFrogqxgqK3Q0FAWLVrEiy++yBtvvMHSpUulgY4Qdkb10JV53drR6XS8/PLLrFu3jl9++YUePXpw8OBBtcsSQtSQqqErKxhunb+/P4mJifTr148RI0bwt7/9TRroCGEHVA9dGeneOkVR+NOf/kRqaiqXLl0iKiqK3bt3q12WEKIKzmq++dXpBYvFgqIoapZi15o0aUJCQgJbt25l4sSJPPzwwwwdOhRPT0+1SxNC3EDVkW6TJk0ApNdAHXnsscdIS0tDURSioqLYunWr2iUJIW6gaugqiiIrGOqYh4cH48aNY+rUqSQmJjJu3DiysrLULksI8V+qhi7IvG59ue+++0hJSSEgIIDo6Gi++OIL2YgihAZoInRlpFs/XF1dGTZsGO+99x4fffQRI0aM4Ny5c2qXJYRDUz10ZXqh/rVu3ZrVq1fTpk0bevTowSeffCJbiYVQiSZCV6YX6p9er+f1119n6dKlfPrpp7z55pucOnVK7bKEcDiqh66fnx+FhYXk5uaqXYpDaNasGStWrOCJJ57gtddeIykpCZPJpHZZQjgM1UNXURSZ17UxnU5H9+7dSUpKYufOnfTp04ejR4+qXZYQDkH10AXo2LGjbGFVQUhICAsXLuSVV15h0KBBLFq0iJKSErXLEqJB00TovvHGG7Rr107tMhySoii88MILJCcnc+zYMXr06MGBAwfULkuIBksToavX6zEYDGqX4dD8/PyYM2cOAwYMYPTo0cydO5fCwkK1yxKiwdFE6AptUBSFp59+mrS0NHJycoiKimLXrl1qlyVEg6JUtUupQ4cOFula5bi+//57pk+fTqdOnRg+fDhGo1HtkoSwC4qi/GixWDpU9JjmR7plZWXSO0AlDz30EKmpqRgMBqKiotiyZYvaJQlh9zQTupWtXti3bx/dunWjuLjYxhUJgEaNGjFmzBimTZvG+++/z9ixY+WHoBC3QTOh++yzz5KdnQ2A2WwmJyeHw4cPk5eXx4EDB2QdqcruvfdekpOTCQkJITo6ms8//1wa6AhxC1RtYn6toqIihg0bhtFo5JdffuHSpUuYzWZ8fX2JioqS+UQNMBgMDBkyhKeeeoqpU6eyadMmxo0bR2BgoNqlCWE3NBO6rVu3ZsuWLYwfP55nn32Wu+++m+DgYLXLEhVo1aoVSUlJJCUl0aNHD9544w1eeeUVdDrN/OIkhGZpZvXC8uXLuXjxImPGjLnu82azufw4H/mm1p4TJ04wdepUdDodEyZMICwsTO2ShFCdXaxeeO6552jTpg3AdQ1YdDodTk5OErgaFRERwbJly3j66afp27cvq1atoqysTO2yhNAszSSZ0Wjk2LFjgHWR/o0jcLlpo106nY6oqChWr17NDz/8QGxsLEeOHFG7LCE0STOh6+rqyp133glYv4mvng6ck5NDbm6unBZsB4KDg1mwYAHR0dHExcXxwQcfSAMdIW6gmTndq8rKyvjkk0/YvHkzGRkZuLu7Ex4eTvv27Xn66afx9va2aT3i1ly8eJFZs2Zx/PhxJk6cSNu2bdUuSQibqWpOVzOrFwCuXLnCokWLOHbsGA899BBhYWF4eHiwd+9e1q1bR0ZGBsOHD1e7TFEDvr6+zJ49m82bNzNmzBg6d+5MXFwc7u7uapcmhKo0M70A8K9//YvNmzczcuRIXn75ZZ544gk6duzIgAEDiI2N5YsvvlC7RFFLnTt3Ji0tjYKCAqKiotixY4faJQmhKk2NdF1dXcnOzqZly5blnysoKGD//v18++23vPLKKypWJ26V0Whk8uTJ7Nixg+nTp3PfffcxcuRI2fAiHJKm5nRzc3MZNWoUOTk5XLlyBWdnZ/Lz88nPz+exxx5j2rRpuLi42KweUfcKCgpYsGABmzdvJj4+ns6dO6tdkhB1rqo5XU2FLkBhYSHr16/HYDDQuHFjAgICaNOmjazTbWD27dvH1KlTad68OfHx8fj6+qpdkhB1xq5CtzImk+m6pWTC/pWUlLBs2TLWr1/P0KFDefbZZ+XfVzQIdrEj7VoV/SBwcnKSb8gGxsXFhUGDBrFw4UJSUlKIi4vj7NmzlT7fZDJx8uRJG1YoRN3TXOhaLBYKCwtlB5oDadGiBR999BEdO3akd+/eZGVlVfjvv3nzZrp160Z8fLwKVQpRNzQXuoqisHTpUs6dO6d2KcKGnJ2d6dOnD6mpqbi7u1f4W82jjz7K5MmTWb58eZUjYiG0THOhC5Cens7hw4fVLkOowMfHB1dX1wofM5vNJCcnM3r0aIKDgzGbzTauTojbp8nQbdasGcePH1e7DKExS5YsITc3l7FjxwKUj4ZlKkrYE02GbkREBOnp6WqXITRk7969rFy5kpkzZwLWm2pXQ/fqn4cOHZKz9ITmaTJ0ZaQrwDqCvbr1OzExkeeee44OHTpgsVhwcnIqH+H+8MMPTJkyhSFDhtC+fXs+/vhjNcsWokqaDN3w8HDS09Nlzs7B5eXlMX/+fEJCQti7dy/Tpk0DrHO7ZrMZRVFIT09nzpw5uLq6kpyczIIFC/j0009VrlyIymkydBs1aoTRaCQzM1PtUoSKPD09+eKLLxg7diwnTpxg48aNANedJPLuu+/SsmVLevXqhb+/P3feeScHDx6UY+KFZmkydEGmGMTvhgwZwtGjRzGbzaxbt658udiWLVu4cuUKr776KkFBQQAkJCTwwAMP4O3tLTfYhCZpOnRPnDihdhlCI0JCQujWrRstWrRg3759gLV5jre3N/7+/gB89dVXnD59mri4OADZwSg0SVOtHa8VERHBTz/9pHYZQmM6dPh9O/vFixfJy8vD39+f/Px8Jk+eTL9+/QgPD1evQCGqodmRbkREhEwviCq1bduWXbt20bNnT3r37k2rVq3o27dvpZsrhNACTY90jx8/jsVikV8TRYXatWvHzp07WbVqFZ06daJjx47XPV5WVobJZMJgMKhUoRA30+xIt3Hjxri6unLhwgW1SxEa1qhRIwYPHlweuDfePOvTpw/r1q2T5YdCMzQbuiA300TtXftbkbOzM7NmzeLbb7+lb9++Ml0lNEHzoSvfKOJ2NG3alMWLF/Pcc8/x+uuv8+GHH1JaWqp2WcKBaTp0w8PDZaQrbptOp+Mvf/kL69at4+eff6ZXr14cOnRI7bKEg9J06MpIV9SlgIAA3nvvPWJjYxk+fDjz5s2jqKhI7bKEg7GL0JWdRaKuKIpC165dSUlJ4dy5c8TExPDjjz+qXZZwIJoO3SZNmgBw+fJllSsRDY23tzfTp09nxIgRTJgwgenTp5OXl6d2WcIBaDp0FUWRFQyiXj322GOkpqZisViIjIzku+++U7sk0cBpOnRBdqaJ+ufp6cnbb7/NO++8w+zZsxk/frz8diXqjV2Erox0hS107NiR1NRUfHx8iIqKYtOmTXI/QdQ5zYeurGAQtuTq6sqIESNITExk+fLljBw5kvPnz6tdlmhA7CJ0ZaQrbO2uu+5i7dq1tGrViu7du/OPf/xDthKLOqH50PXz86OwsJDc3Fy1SxEORq/XM2DAABYvXsw///lPBg4cyOnTp9UuS9g5zYeuoigyrytUdccdd7Bq1SoeffRR+vTpw5o1a2TUK26Z5kMXZF5XqE+n09GzZ09WrVrFtm3b6NOnD8eOHVO7LGGH7CJ0ZaQrtCI0NJTFixfz0ksv8eabb7JkyRJKSkrULkvYEbsIXbmZJrREURReeukl1q1bx5EjR+jZsyc///yz2mUJO2EXoSsbJIQW+fv7M3fuXPr378/IkSNJTEyksLBQ7bKExtlF6AYFBZGdnU1+fr7apQhxHUVR6NKlC2lpaWRlZREdHc0PP/ygdllCw+widHU6HeHh4aSnp6tdihAV8vLyIiEhgb/+9a9MmjSJhIQErly5onZZQoPsInRBVjAI+/Doo4+SlpaGk5MTUVFRbN26Ve2ShMbYTejKCgZhLzw8PHjrrbdISEjgb3/7G+PGjSMrK0vtsoRGSOgKUU/uvfdekpOTCQwMJDo6mg0bNkgDHWE/oSvTC8Ieubq6MnToUN577z2SkpIYPnw4586dU7ssoSK7Cd0//OEPXLhwQc60EnapdevWrF69mrvvvpvu3bvz8ccfy1ZiB2U3oevk5ERoaCgnT55UuxQhboler6d///58+OGHfPbZZ7z55pucOnVK7bKEjdlN6ILsTBMNQ7NmzVixYgVPPPEEr732GklJSZhMJrXLEjZiV6ErO9NEQ6HT6ejevTtJSUns3LmT2NhYjh49qnZZwgbsLnRlpCsakpCQEBYuXEhkZCSDBw9m0aJF0kCngbOr0JUVDKIhUhSF559/nnXr1nHs2DF69OjBgQMH1C5L1BO7Ct3Q0FAyMjIoLS1VuxQh6pyfnx9z5szhjTfeYPTo0cydO5eCggK1yxJ1zK5C18XFhaCgIDkyRTRYiqLw1FNPkZaWRk5ODtHR0fz73/9WuyxRh+wqdEFupgnH0LhxY6ZMmcLYsWOZOnUqU6ZMkXMCGwi7C12Z1xWO5KGHHiItLQ1XV1eioqLYsmWL2iWJ22R3oSsrGISjcXd3Jz4+nunTp/P+++8zZswYLl26pHZZ4hbZXejKBgnhqNq3b09ycjKhoaHExMTw+eefSwMdO2R3oRsWFsapU6dkB49wSAaDgbi4OObNm8fatWsZOnQoGRkZapclasHuQtfV1RVfX1/OnDmjdilCqKZVq1YkJSXRvn17evbsSVpamjTQsRN2F7ogN9OEAHB2dqZv374sX76cjRs38vrrr0tDKDsgoSuEnQsPD2fZsmV06dKFvn37snLlSsrKytQuS1TCLkM3IiJCDqkU4ho6nY6oqChWr17N7t27iY2N5ciRI2qXJSpgt6ErI10hbhYcHMyCBQuIjo4mLi6OhQsXSgMdjbHb0E1PT5cbB0JUQFEUnnvuOVJSUjh58iQxMTHs379f7bLEf9ll6DZq1Aij0UhmZqbapQihWT4+Prz77rsMHjyYMWPG8O6770oDHQ2wy9AFuZkmRE117tyZtLQ0CgsLiYqKYseOHWqX5NDsOnRlZ5oQNWM0Gpk0aRJvv/0206dPZ9KkSdJARyX2F7rFxfDVV3TZs4cOM2bAI4/Aww9D164wbhz84x+QlaV2lUJo0gMPPEBqaioeHh5ERkbyzTffqF2Sw1Gq2rvdoUMHy+7du21YThVyc2HpUkhKgqIiivPzuZSXR3DTptbHTSYoKgInJ+t/d+0Kw4ZB8+bq1SyEhu3fv58pU6bQvHlz4uPj8fX1VbukBkNRlB8tFkuHih6zj5Hu1q3QuTMsWmT9b6MRJ39/cs1mLAYDGAzg7g7e3tC4MXh4wGefQbdu1qCWheJC3KRt27YkJycTHh5OTEwM//d//ycNdGxA+6G7aBH07QsFBdCkCbi4AODs5IROUSreeePkZA1gV1eYNQtef906ChZCXMfFxYVBgwaxcOFCUlNTiYuL4+zZs2qX1aBpO3SXL4c5c6wjV3f3mx42GAwUFxdX/nq9Hry8rCPlgQNlxCtEJVq0aEFSUhKdOnWiV69epKSkyDr4eqLd0N23D2bMsAaus3OFT3GpLnQBFMUavP/6FyxbVudlCtFQODk5ERsby4oVK/j666/p37+/rBCqB9oM3eJi600wJyfraLUSBoOBkupCF6zB6+kJiYlw7FgdFipEwxMWFsbSpUvp2rUr/fv3Z8WKFdJApw5pM3Q3bIAzZ6xBWQWDwUBxTfeV6/XWFQ7z5tVBgUI0bDqdjldffZU1a9awb98+evXqxS+//KJ2WQ2C9kLXYoHFiyudUrjW/xUUMCw7mwcPH2ZyTSb/jUbYuBHkfCkhaiQoKIh58+bRq1cvhg0bxvz586uf0hNV0l7onj4Nx49Do0bVPtXfxYW/6PU8W82IuJyTkzXUN2++zSKFcByKotCtWzdSUlLIyMggJiaGPXv2qF2W3dJe6B46BDqddR62Gk8ajTzm7o57bdYWWiyglQ0fQtgRb29vZsyYwdChQ3n77beZOXMm+fn5apdld7QXugcPQi36fxoMhtpN8ru6wt69t1CYEALgiSeeIDU1ldLSUiIjI9m+fbvaJdmV6idObe3SJetIt4YMrq4U5uRQUFZGbm4uer0evV6Pk7MzFY6VnZwgJ6fOyhXCERmNRiZMmMCuXbtISEigXbt2jBw5Ei8vL7VL0zztjXRrEbgA3k2a4O7mhtlsJjc3l4zMTH49fpwjhw9z7NdfOXXqFBkZGVy8eJGc3FwKi4ooNZlk4bcQdaBTp06kpqbi5eVFVFQUX331lWwlrob2RrrBwdZ511pwd3PDQ6/nD8HB5Z8zmc2UlZZSWlpKyX//LLpyBaWwkFPZ2Yx8+GH8/f0JDg4mKCiIwMDA8r8HBQXh7++Pcw1WUAjh6Nzc3Bg5ciRPPfUUCQkJbNy4kbFjx+Ln56d2aZqkvVRp06a8v0J1TBYLJosFM2AGSsxmnBTF+qHT4WQwYDAYrn/RpUuE9OvHv+LjyczMJCMjg4yMDM6ePcuuXbs4e/YsGRkZZGVl4e3tXWkoBwYG4lLDOoVwBPfccw9r1qxhxYoVxMTEEBcXxwsvvIBSg5vijkR7rR0vXoQHH7RujKhmqmHphQssvXjxus8N8PVlQFU/YXNzrRskunat8tplZWWcP3/+ulDOzMwsD+Xz589jNBorDeWgoCDc3Nxq/GUL0ZD85z//YcqUKXh4eDB+/HhCQkLULsmmqmrtqL3QBYiNhe3brT0T6lJpqbXpze7dcJuBaDabuXjxYqWhnJmZiaura5Wh7FnT9cVC2CGTycTatWv56KOP6NevH9HR0ehqec/GXtlf6G7bZm3naDTWaL1ujWVlQf/+1hMm6pnFYuHy5cvlgXw1iK/+PSMjA0VRbgriaz+8vLzkVzNh906dOkVCQgIlJSVMnDiRZs2aqV1SvbO/0LVYoHdv2LGj7ka7BQXWZuebN1v78qrMYrFw5cqVKkO5pKSk0kAOCgrCx8fHYUYOwr6ZzWbWr1/PBx98QHR0NH369EFfRTMre2d/oQuQkQFPPw1mc4W9dGulrAyuXLGeIvHkk3VTnw0UFBRUGcp5eXkEBARUGsr+/v44XT2+SAgNOHfuHDNmzCAjI4NJkybRunVrtUuqF/YZumAd6fbpY93QcKvBezVw4+JgxIg6LU9txcXFN80jXxvKly9fxtfXt9JQDggIkBUYwuYsFgubNm0iMTGRbt268eabb+Lq6qp2WXXKfkMX4PvvYcAA63E7jRvXbo43L88ausOHw+DBdTs/bAdKS0s5f/58paF84cIFvLy8qpzCaGjfDEI7Ll++zOzZszl06BATJkzgvvvuU7ukOmPfoQvWqYbRo2Hnzt8bklc2l2mxWOdvS0shIMC6PKxDhV+7wzObzVy4cOG6IL72IzMzk0aNGl0XwsHBwQQGBpb/vVENusEJUZWtW7cyc+ZMHnnkEYYOHYqHh4faJd02+w9dsIbptm3WI3d27LBOORQX/96RzGSybqqwWOAPf4A33oDnn7/tpWGOzGw2c/ny5UpDOSMjA2dn5ypD2Wg0ygoMUa28vDzmzZvH9u3beeutt3j00UfVLum2NIzQvdb589ZuZD/9BGfPWgPXxwfuugtat4aICIebSlCDxWIhNze3ylAuKyurMpS9vb3rJZTHjh3Lli1beOCBB0hMTJQbinbihx9+ICEhgbvuuou//vWvNNHASqNb0fBCV9iNvLy8SgM5IyOD/Pz88hCuKJT9/PxuaVncp59+Snp6OvPnz+c///lPhc9JTExk+/bt3H333bz11ls3bxkXqigqKmLx4sVs2LCBUaNG0aVLF7v7bUlCV2hWYWHhdT0wbvzIzs7Gz8+v0lAOCAiotDHR1q1bmTRpElu2bMFsNpeHt8lk4pNPPmHlypUMGDCADRs28OCDD9K3b19bfumiGgcPHmTKlCkEBwfz1ltv4e/vr3ZJNVZV6Gqv4Y1wKG5ubkRERBAREVHh4yUlJZw7d+66IN69e3d5UD/00EOMGDGiwlUWR44cKf9GvXZw8euvv/L1118zcOBAnn/+eYxGI+PHj6dv377XhbNQV5s2bVizZg0rV66ke/fuDBo0iBdffNHu/30kdIWmubi4EBoaSmhoaIWPm83mSn/1PH369HWvuxqox44do6ysjA7/XdVSUFBAUFAQgN1/Qzc0er2eAQMG8OSTTzJlyhQ2bdrE+PHjK/3/wR7I/2HCrul0ukpD99SpU+XfnBaLpXy0e/r0aZo0aVK+3O3cuXOEhoZed96XyWQiMzOT3NxcacqtAc2bN2flypU89thj9OnTh9WrV2MymdQu65bISFc0WPn5+TzyyCMA1837ms1mjEYjRUVFNG7cmMOHD+Pv74/7NbseS0pKWLVqFV988QUWi6V8DrmijnFNmjSxuxs99kin09GjRw8ef/xxEhIS+Oqrr5g4cSJ33HGH2qXVitxIEw3OvHnz+PDDDzl06BD/8z//wzvvvIO/vz+NGjUiJCSEAwcOMGHCBFatWkWTJk14+OGHiY+P54UXXqjwelcbE93YxvPq34uKiq4L4htD2dfXV6Yt6pjFYuGf//wnCxcu5NVXX+W1117T1JZ2Wb0gHEpJSQnp6emcOnWKn3/+mbvuuouCggIuXrxITEwMbm5uDBkyhIMHD+Lh4UGzZs2YPHnyLR+qWFBQcNMpJNduuc7NzZWjoerJ+fPnmTlzJr/99hsTJkzg7rvvVrskQEJXiJvk5OSwZ88ezpw5wwsvvFCvDeVLSkqqDGU5Gur2WCwWvvrqK+bMmcMzzzzDwIEDa39qS1aWdcfrjz/Cvn3WJllOThASAvffD/feC5061fjgXAldITTs2qOhKmpOdOPRUBV9yNFQkJ2dzdy5c9m/fz/jx4+nU6dO1b/o6FFYsAA2brS2EDCZwNX193AtKbE2zXJ2Bm9veP116NnT2pu7ChK6Qtixa4+GqiiUbzwaqqIPRzoa6rvvvmPGjBk8+OCDDBs2rOKvvbQUliyB+fOtQWs0Wke2VSkstHY7bNrU2kjrnnsqfaqErhANmBwNdbP8/Hzmz5/Ptm3bGDNmDI8//vi1D0K/fvDDD+DhAbU9wSI31/rnu+/Ciy9W+BQJXSEcmCMfDbVnzx6mTp1Ky5YtGT16NN6NGlmPAtu923oU2K3+oCkpsYb3vHnw7LM3PSyhK4So0q0cDXVtHwwtHw1VXFzMkiVL+Oyzz5gfHMyd27ah3E7g/n5h63zvpk3WKYdrSOgKIW7LjUdD3fhR0dFQ14ayFo6G+nX9etx796bM1ZXA4OC6ORgzOxvatoW///26lQ3S8EYIcVsMBgNhYWGEhYVV+PiNR0NlZGSwZ8+eKo+GujaUbXE0VPO//x1zQACXyso4fuIEfn5+1t2Et3PRxo1h/37rsWL/3f1YHQldIcRt0+v1hISEEBISUuHjFR0NdejQIb755hvbHA2Vng67dqEzGvHT6TB6enL2vxtXgoKCMFwzCs81mZiSkcHOvDy8nJ2J8/PjmcaNK77u1SmKZcskdIUQ2qHT6QgICCAgIID27dvf9LjZbCYrK+u6KYvjx4+zffv2ujkaatMmMJvLpwAMBgPh4eFkZWWRnp6Oj48PPj4+KMDMzEz0isKXLVpwtKiIYadP08LVlWaVrc01GuG776wbKmqwNE9CVwihOp1Oh6+vL76+vhVu5bVYLOTk5NzUA+PHH3+s9mio4OBg7vj2WwzOztdNJSiAj7c3np6e5du1mwQEsPnKFdKaNcNdp6OduzuPe3ryeU4OQyproq7TWTdPHD4MHTtW+7VK6AohNE9RFLy8vPDy8qJVq1YVPqeio6F+/vlnMjMzGf/55yhlZSgGA3q9Hr1ej8t//9Tr9QQHBZGXn8/OU6cwl5byh2tusv3RYGBPQUHVBZaWwpEjErpCCMfh4eHBH//4R/74xz/e/OCdd2J2c6PUZKK0tLT840peHmWlpZSUlmIymSgGnMvKOHLkCC1btkQBPHQ68s3mqt/cZIKcnBrVKaErhGj4FAWdomAwGCo9gNRssVCWl4f59GmCAgPLpyLyzWYaVbcxpBaN7u1vi4kQQtSWt7d1I0MVdIrCHY0agU5H7jUN7Y8WF1d+E+0qFxfw86tRKRK6QoiGr21ba7OaarjpdHT29GTxhQsUms3sLyjgX1eu8OfKloxd5eQELVvWqBQJXSFEw/fQQ9YlYzUwNjCQYrOZp48eZdyZM7wVGFj1SNdksl67RYsaXV/mdIUQDd8zz8CUKdaArKZHhNHJibm1OW04N9fabayGO+pkpCuEaPj8/OBPf/q9LWNdMZutu9JiY2v8EgldIYRjiI+39s4tKam7a+bmQteuVTY0v5GErhDCMTRtCm+/be2DW8P53Srl51u3/b7zTq1eJqErhHAcPXrAyy9bWzLeTvDm51unFVassC5HqwUJXSGE49DpYNYsiImx7iArLKzd6y0WuHzZOk2xZg1U0LynOlU2MVcU5QJwstZXFUIIxxZmsVgq3C1RZegKIYSoWzK9IIQQNiShK4QQNiShK4QQNiShK4QQNiShK4QQNvT/MBh+kzzXlbYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -2947,12 +615,13 @@ "n = 3\n", "num_qubits = n ** 2\n", "tsp = Tsp.create_random_instance(n, seed=123)\n", - "adj_matrix = nx.to_numpy_matrix(tsp.graph)\n", + "adj_matrix = rx.adjacency_matrix(tsp.graph)\n", + "graph = nx.from_numpy_array(adj_matrix)\n", "print('distance\\n', adj_matrix)\n", "\n", - "colors = ['r' for node in tsp.graph.nodes]\n", - "pos = [tsp.graph.nodes[node]['pos'] for node in tsp.graph.nodes]\n", - "draw_graph(tsp.graph, colors, pos)" + "colors = ['r' for node in graph.nodes]\n", + "pos = [node['pos'] for node in tsp.graph.nodes()]\n", + "draw_graph(graph, colors, pos)" ] }, { @@ -2964,7 +633,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 27, "metadata": { "tags": [] }, @@ -2973,471 +642,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "order = (0, 1, 2) Distance = 202.0\n", - "Best order from brute force = (0, 1, 2) with total distance = 202.0\n" + "order = (0, 1, 2) Distance = 3.0\n", + "Best order from brute force = (0, 1, 2) with total distance = 3.0\n" ] }, { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:29.331913\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "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\n", "text/plain": [ "
" ] @@ -3481,7 +692,7 @@ " edge_labels = nx.get_edge_attributes(G2, 'weight')\n", " nx.draw_networkx_edge_labels(G2, pos, font_color='b', edge_labels=edge_labels)\n", " \n", - "draw_tsp_solution(tsp.graph, best_order, colors, pos)" + "draw_tsp_solution(graph, best_order, colors, pos)" ] }, { @@ -3493,7 +704,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -3545,7 +756,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 29, "metadata": { "scrolled": true, "tags": [] @@ -3618,7 +829,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 31, "metadata": { "tags": [] }, @@ -3647,7 +858,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 33, "metadata": { "tags": [] }, @@ -3660,470 +871,12 @@ "tsp objective: 202.0\n", "feasible: True\n", "solution: [0, 1, 2]\n", - "solution objective: 202.0\n" + "solution objective: 3.0\n" ] }, { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:29.919539\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "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\n", "text/plain": [ "
" ] @@ -4144,7 +897,7 @@ "z = tsp.interpret(x)\n", "print('solution:', z)\n", "print('solution objective:', tsp.tsp_value(z, adj_matrix))\n", - "draw_tsp_solution(tsp.graph, z, colors, pos)" + "draw_tsp_solution(graph, z, colors, pos)" ] }, { @@ -4157,7 +910,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -4169,7 +922,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 37, "metadata": { "tags": [] }, @@ -4178,474 +931,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "energy: -7204.6830268662625\n", - "time: 8.034800052642822\n", + "energy: -7323.265478527832\n", + "time: 3.109360933303833\n", "feasible: True\n", - "solution: [1, 2, 0]\n", - "solution objective: 202.0\n" + "solution: [2, 0, 1]\n", + "solution objective: 3.0\n" ] }, { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:38.375832\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAh5UlEQVR4nO3dfXzO9f4H8Nf32v1mG2v3y7AkiaiGOJGjctLdOb/6pei4CT904+b8nCTk6EanIjWnJCRxJMqpwymicOiHw5SbCJWYbDO2jG22a9v1/f3xPtfZrF3X7q7v7fV6Ph57YOPyLrz22ef7/rw/iqqqICIifTiMLoCIyJ8wdImIdMTQJSLSEUOXiEhHDF0iIh0FevtgbGys2rp1a51KISKyhz179pxVVTWuto95Dd3WrVsjMzNTm6qIiGxKUZQTnj7G7QUiIh0xdImIdMTQJSLSEUOXiEhHXh+k6aKiAjh2DDh8GMjNBcrLgchIoG1boH17ICbG6AqJiHzGuNDNygKWL5e38nJAVQGnU74NCACCgyWQO3YERo8GbrlF3kdEZGH6h25ZGZCRASxcCLhcQESErGxro6rAt98C48YBKSnA3LnAtdfqWy8RkQ/pu6f7009A//7AW29J2LZo4X31qigSyNHRQHY2cO+9wLx5EsZERBak30r31CkJzZ9/lrBtqKgo2W545RXg4kVg4kTf10hEpDF9VrpOJzBkiARudHTjXycwUMJ33jxgzRrf1UdEpBN9QjcjAzh+vGmB6xYQAISFAVOnAnl5TX89IiIdaR+6J0/KQzNPD8saIzQUKCkBXn7Zd69JRKQD7UN3xQqgslK2BnwpKgpYu1a2LIiILELb0HW5gGXLpFPBC6fLhWezs3HX99+j95EjGHTsGLYXFXl/7YAACfNPP/VhwURE2tI2dI8fl77cOg41VAJIDArCgtRUbGnXDo/ExWHyqVPIdjq9v76iANu2+axcIiKtadsydviwBGMdwhwOjIqrmvfbKzISyUFBOFxaimRvgR0aCuzd64NCiYj0oe1K9/RpaRdroIKKCmQ5nUgLCfH+E4OCgDNnGlkcEZH+tA3dysoGnx6rUFVMy87GXdHRaF1X6CqK/B5ERBahbehGRMgDr3pyqSqmZ2cjEMCkxMS6f0FlJRAe3vj6iIh0pu2e7pVXyhZAPaiqiudycpBfUYG5LVsisB57wSgrk/GPREQWoW3otm8v8xJUtc4Han/OzcWPTifmpaYixFHPBXhpKdC9uw8KJSLSh7ah26wZ0K0bsHu31yPAOeXl+Nu5cwhWFPzmu+/+8/4piYno7+nXqaocuPjNb3xdNRGRZrSfMjZypISul9VuUlAQMq++umGvW1ICpKYCXbo0vUYiIp1ofwz45puBtDTg/HnfvabLhQsFThSMnFSvPmAiIrPQPnQDAmTKGCDX8vhCYSFyOvXDgEX98MEHctqYiMgK9Bnt2L49MG0aUFQkD9aaorAQSEpCu1UzsXCRgnXr5Aq1Eyd8UyoRkZb0u65n6FDgiSeACxfk5oeGcrlkolhiIrBqFRATgzZtgEWLgFtvBYYPB5Ys4VkJIjI3fe9IGzNG7kcLCpIArc+qV1VlhXz+PHD77cDf/w4kJ//nww4H8MADMsxs927J9qNHNfxvICJqAn1DF5Bl6aZNwKBBcrihsBA4d056bisrZUVbUSFBm58vYduqlYT1G28AMTG1vmxyMvD66xLAjz0mN/o0YuwDEZGmFNXLbIT09HQ1MzNTu9/9wgVgwwYZz/jVVzIgx+UCwsLgatcejh7dgdtuAzp1alCXQn4+8NJLwLFjwPTpvLWdiPSlKMoeVVXTa/2YoaHrwQ8/AF27Avv2AS1bNv51Nm2SG31uuUVWvxzTQER68Ba6+m8v1MO2bbK7MGpU05od+vaVZ27FxcCDDwI7d/quRiKixjBl6H78saxKDxyQfdqmiIoCZswAnnoKmDkTeOYZ357TICJqCNOFbkEB8M03csu6ywXMng18/XXTX7dHD2DlSnndAQNk64GISG+mC909e6q2FCIigPvuq/OKtXoLDwcmTQJefFEaISZNkoduRER6MV3o9ukDbN8OrF4tD8AyMoBrrvHt79Gli9wM37q17PWuXdvgCy6IiBrFdKEbFCQ9t23bSsuXVoKDgUcflRXv++8DY8cC2dna/X5ERIAJQ9ctLk7OS2j90KtdO+Ddd4H0dGDwYNn35QAdItKKaUNXUWQi5I8/av97BQYCw4YBixcDGzfKCGA9fl8i8j+mDV0AaNNG2y2Gmlq1AhYskBEPI0dKCDd1KBoRUXWmD129V5wOh7SU/fWv0qo2ZAhw+LC+NRCRfZk6dNPS9F3pVpeUBMydCzz0EDBunBzSKCszphYisg/Th66Re6uKAtx5p3Q3/PQTMHCgbw5qEJH/MnXoJibK5MfiYmPriImRAxVjxwJTpsgEs5ISY2siImsydeg6HPJw6/hxoysRv/61tJSVlcm+7/btRldERFZj6tAFjN3XrU1UlMzonT5dVr/Tp8tqnIioPkwfukZ0MNRHt26y1xsdLavezz/nUWIiqpvpQ9foh2nehIcDEycCs2bJbUJPPAGcPWt0VURkZpYIXTNtL9Tm2muB5ctlXsTAgcCaNVz1ElHtTB+6KSnAmTMyh8HMgoPlsuM33gA++ECuBzp1yuiqiMhsTB+6AQFyT9qJE0ZXUj/t2gFLlgA33iin2d57jwN0iKiK6UMXsMYWQ3UBARK477wDbNkCjBhhrfqJSDuWCF2zdjDUJTUVmD8fuOsuuWRz0SKgvNzoqojISJYIXTN3MNTF4ZArh5YvB/bvlxXwoUNGV0VERrFE6Oo94lELCQly9dCQIcCECTJMx+wPB4nI9ywRui1bAjk51v/SXFGA/v3lUEVurrSXffWV0VURkZ4sEbrBwTJq8eRJoyvxjZgY4IUXgD/8AZg2Dfjzn40f6kNE+rBE6ALW62Coj969q+5kGzAA+PJLoysiIq0FGl1AfdlhX7c2kZHA1KnA7t3A888Dn30mR4ubNze6MiLSgmVWulZtG6uvrl1lrzcmRla9GzbwKDGRHVkmdO24vVBTWJjs886ZIz29EycCeXlGV0VEvmSZ0G3VSh6kVVYaXYn2OnaUizHbtwcGDQI++oirXiK7sEzohoYCcXH+M0QmOFhOsc2fL6H7yCNyTxsRWZtlQhfwjy2Gmtq2lQE6N90EDB0qJ9s4QIfIuiwVunbtYKiLwwH8/vcSvlu3Ag8/DPzwg9FVEVFjWC50zXJJpRFatgTefBP47W+B0aOBBQusf0qPyN9YKnT9cXuhJocDuPdemdP77beyAj540OiqiKi+LBW67pUu9zSB+HhpLRsxQtrMXn2VA3SIrMBSoRseLleg5+YaXYk5KArQrx+wahWQnw888ACQmWl0VUTkjaVCF+AWQ22aN5cjxH/8IzB9OjBzJlBUZHRVRFQbS4aunY8DN0WvXrLqVRQ5Srx1q9EVEVFNlgtdu89gaKpmzYApU4DnnpM93ylTgIICo6siIjfLhS63F+rnhhtkgE5CAvDgg8C6dTxKTGQGlgtd90qXAVK30FBg/HjgtdeAd9+VLofTp42uisi/WS50o6KAkBDgzBmjK7GODh2AZctkkM5DDwGrV7PtjsgolgtdgA/TGiMoCBg5Uk6xrV0LjBkDZGUZXRWR/7Fs6HJft3HS0oDFi4E+fWSGw9Kl/jEuk8gsLBm67GBoGodD5vQuXQrs3AkMGwYcPWp0VUT+wbKhy5Vu06WkAG+8Afz3fwOPPirDdJxOo6sisjdLhq57e4EdDE2nKDK1bMUK4Pvv5UHb/v1GV0VkX5YM3RYtgJde4hN4X4qLA2bPltsqnngCeOUV4OJFo6sish9Lhq6iyO25AQFGV2IvigLcdpscJS4slAE6u3YZXRWRvQQaXQCZT3Q08OyzwPbt8m23bnKwIjLS6MqIrM+SK13SR8+ewMqVchhlwABgyxajKyKyPtuFbkUFB7z4UkQE8OSTMi5y7lxg8mT+/yVqCsuGrqdbEvbuBe64Aygr07Uc27v+eulwSEmRATqffMLuEaLGsGzo3nUXcO6cfN/lkgc/hw/L8O79+9nsr4WQEGDsWCAjQ66CHz+et3gQNZRlH6SVlso/+qgouaAxP1/CNzZWnrpHRRldoX1dfbWcZlu6VPp6R4+WAxYOy34KJ9KPZUO3Qwdg82Zg2jRZ9XbqBCQnG12V/wgMBIYPB379axmYvmED8PTTQKtWRldGZG6WDd3u3YErrgCGDr30/S6X7DUqCldeemjTBli0CPjgAwnhwYPlWvhAy/7NItKWZWPp7ruBa66R71efkuVwyKEJBq5+HA7Z0lm2DNi9Wz4RHjlidFVE5mTZaIqKklkBgKxqaz5J55N1/SUnA6+/Lt0Njz8OzJvHATpENVk2dENDgauuku87HBK8gHQxnD9f9WPSl6LIVyErVsj4zYEDgX37jK6KyDwsvfPWv78chli9Gti0CcjJAcLDgdatgeuukzkCMTFGV+mfYmOBWbPkz+XJJ4FbbgEee0z+fIj8mWVXugBw4YJcM/7FF0CPHjIfYOJEGf343nvS0kTG6ttXBugUF8u+786dRldEZCxLr3T/+U9ZSb32muwnRkZWTSCLjQXeeguYMMHoKikqCpgxA9ixQ44Tp6fLJ0j2UpM/svRKNzRUTqW1by//gBUFKCmRf9xbtkjDPplHjx4yQCcsTAbobNpkdEVE+rP0SrdbNzkUMWCAbDUEBsqXscXFQO/ev+zhJeOFhwOTJgH9+smhivXr5cexsUZXRqQPRfXSW5Wenq5mZmbqWE7DXbwIfPSRzAWIjgYSEqR/l3265ud0AgsXAh9/DIwbJycL2XVCdqAoyh5VVdNr/ZjVQ9eTyspLW8nIvI4cAZ55Rq5hmjrV83Huykrgp5941JjMz1vo2mI9WNvnjYAABq5VXHWVdJp07QoMGQL8/HPtf6abNsnYzkmT9K+RyFdsu9Ila8rPl8HpoaG//FhpKbB2LTBmDHDgAAcckXnZfqXrcsmDNLK+yy6rPXAB+XNesUJuK05O5m3QZE22CN3jx4GHHza6CtLaW2/JEe/Jk+XH7u0jztkgK7FF6F5+OZCdDZSXG10JaeXrr4F33gFefFF+XFlZFbrubw8d4jVNZH62CN3gYCApCTh50uhKyJdUFVi3Tr4/Z44M0klPl/cHBFStcHfvlqvix46VmRsffmhczUR1sUXoAjJv4dgxo6sgXyoqkhuIU1JkpTtzprzf5ZI3RZGtpdmzZR94xQoZLbl2raFlE3llm9Bt00ZGCZJ9REbKSnfyZPmzXb9e3l99SP3LL8sx8MGDgfh4aT87eJDXxJN5MXTJ9MaOldudXS6ZHpedLe/fvFm6Vu6/X7aXAOD554Ebb5SRnnzARmZkm9Dl9oK9paTIwYh27YC9e+V9JSUSrvHx8uONG2Vf//HH5cc8HENmZOmBN9W1agVkZclT7YAAo6shraRXazc/e1b2fePjZcjRjBnAiBEyxJ7IrGwTuqGhQFwccOoUkJpqdDWkh86d5SHa738vg4+uvlpuJCYyM9uELiBbDD/+yND1F126yE0US5bImM+uXS/9eEWFfOUTEmJEdUS1s82eLiAP07iv618iIuTuNXfg1nx4NmyYPHzjkWEyC9uFLjsY/Fv1h2eBgcBLL8ktIsOH8xMymYOtQpcdDFRTaiowf76cZhs1Cli0iMfFyVi2Ct02beSEEr+UpOocDuC++4Dly4H9++UgxaFDRldF/spWoRseLlf25OYaXQmZUUICkJEhd+dNmCBHjEtLja6K/I2tQhfgvi55pyhA//7A++/LJ+eBA4E9e4yuivyJ7UKX+7pUHzExwAsvAH/4A/D00/L9oiKjqyJ/YLvQ5UqXGqJ3b2DlSmk1GzAA+PJLoysiu7Nd6HKlSw0VGSm3ED/zDDBrFjBtmlyOSaQF24Wue6XLCVPUUF27yl7vZZcBDzwAbNjAv0fke7YL3agoOfZ55ozRlZAVhYXJPu+cOdLTO3EikJdndFVkJ7YLXaBqBgNRY3XsKH297dsDgwYBf/sb+7/JN2wbutzXpaYKCpJTbPPnAx9/DDzyCO/ho6azZeiyg4F8qW1bmWTWq5cM0PnrX7nqpcZj6BLVg8Mhc3uXLAG2bZPw/eEHo6siK7Jl6KalyT8IPnkmX2vZEnjzTeC//gsYPRpYsIADdKhhbBm6LVrIt+y1JC04HBK6770HHD4MPPSQ3EBMVB+2DF1FYQcDaS8+HnjlFWDkSGkze/VVuTaIyBtbhi7ADgbSh6IA/foBq1YB+fnAgw8Cu3cbXRWZma3uSKuudWuudEk/zZsDzz8vD9n+9CegZ09g/Hg5YkxUna1Xugxd0luvXrLqdTjkKPHWrUZXRGZj69Dl9gIZoVkzYMoU4LnnZJ93yhSgoMDoqsgsbBu6cXHyUOP8eaMrIX91ww3AihVAYqLs9a5bxzZGsnHosoOBzCA0FBg3DnjtNeDdd+WaoNOnja6KjGTb0AV4Mo3Mo0MHYNkyoFMnGaDz4Yc8SuyvbB+63NclswgKkp7ehQuBf/wDGDMGyMoyuirSm61Dl9sLZEZpacDixUCfPsDDDwNLlwKVlUZXRXqxfehypUtm5HDINsPSpcDOnTJA5+hRo6siPdg6dBMTgcJCoKTE6EqIapeSArzxBnD//cBjj8kwHafT6KpIS7YOXYcDaNUKOH7c6EqIPFMU4J57ZIDO99/LAJ39+42uirRi69AFuMVA1hEXB8yeLSMjn3hChunwqzT7sX3osoOBrERRgFtvlaPEhYVyqOJf/zK6KvIl24cuOxjIiqKjgWefBSZPluPEzz7L05V24Rehy5UuWVXPnrLqDQ2VATqbNxtdETWV7UM3JQU4cwYoKzO6EqLGCQ8HJk0CXngB+MtfZPXLATrWZfvQDQiQe61OnDC6EqKmue46GaBz+eWy1/vJJxygY0W2D12AWwxkHyEhwOOPAxkZwPLlMkwnJ8foqqgh/CJ02cFAdnP11XKa7brr5Gr4Vas4QMcq/CJ02cFAdhQYCAwfDrz9NrB+PTBqFLfRrMAvQpcjHsnOWrcGFi0CbrtNQnjJEqCiwuiqyBPbXkz5H3l5SP0mE7fs2gfXwG/gKLsoG2Pt28vXZunpQHKy0VUSNYn7TrZevYCZM4GNG4Hp04GrrjK6MqpJUb08/kxPT1czMzN1LMeH9u4F5s8HvvgCcDhQVuRESGSIHPlRVekhCwqS7/fsCTzyCHDjjUZXTdRkqirzeufOBX73O+B//gcIDja6Kv+iKMoeVVXTa/2Y7UK3pAR46SV5tAsAUVGyDPDE5ao66nPPPXJ/dnS09nUSaSw/X/4p/PCDrHo7dza6Iv/hP6GbmwsMHCjj+KOipEm3vtzhGxsrzZBt2mhXJ5GONm0CXn4Z6NtX2s3Cw42uyP68ha59HqSdOSNDSX/6CWjRomGBC8hquHlzOepz//3AyZOalEmkt759paXs4kXZ992xw+iK/Js9QtflAsaPB7Kzm741EBUFnDsnF1jxETDZRFSU7JxNnSrHiWfM4AAdo9gjdD/8UObfNW/um9eLjgYOH5Y+HCIbufFGYOVKICICGDBAth5IX9bf03U6gW7d5Ga/kBDfvW55ubz2rl1AZKTvXpfIJPbtk5GRV1whA3ViY42uyD7svaf7+efSsVBH4K4qKMDgH39Ej8OHMSM7u+7XDQqS4F2zxkeFEplL587yzLh1a3n+vGYNB+jowfqh+9579fppsYGBGBEbi3sasucbFFTVekZkQ8HBwKOPyuWYK1dKd0N91iTUeNYOXVWVQxBhYXX+1L5RUegTGYnohnQ1hIXJvdi8npVsrl07GaDTrRsweDDw/vscoKMVa4fu6dNAaamsSLXgcMhUEY4oIz8QEAAMHQosXiy7diNHcmaJFqwduufOSShqSVHk9/k3VZXrsXNztf1tiYzSqhWwYAHQv78E7+LF7J70JWuHrqLo9vscOyaDo3v2BG6/Hfj0U31+ayIjOBxyRmj5ctnBGzwY+PZbo6uyB2tPGWveXPtPwaqKSTOj8frnsosRFiZZn5cHHDkCJCVJR5le+U+kp8REWWysWyfnj+6+W+b2+rI7099YO3Tj4yUFy8vr3NetVFVUqipcAFwAnC4XAhQFAd7S0uUCKiowPiMNWU8BW7fKCsDpBL75Rvocs7NlyyEpSd6Sk+UvanJy1ftatGAok3UpCnDHHXKwYtYsaS+bNg24/nqjK7Mm6x+OGDIE2LlTzjl6seDMGSw4e/aS942KjcWouDjPv6i4WAbffPopVFVmlE6aJFu8u3ZJ5gPAhQtyT5X7LTtb9nzd3y8tvTSIa4ZybKz3QWhEZrJli0wv69NHWswiIoyuyHzsPWVs/Xq5na+O0G2UwkI5sjNw4H/eVVAgTeRDhtQ/KEtKqkK4tlA+f14C3FMox8dr/7yQqCHOn5dth3/9C3jqKeBXvzK6InOxd+i6jwFXVAChob57Xfcx4N27gWbNfPe6tXA6aw/l7Gz5cUEBEBPjOZQTEzmkmoyxaxfw/PNAly7A//6v78afWJ29QxeQgTdPPil/4r7YPFVV2UN48kl5amCwigp5cOcplPPyZKHvKZSTkup1foSoUS5eBN58E/jsM+CPfwRuvZXPMOwfuqoqX+9v3y5PrZrq55+BDh2Ajz9u+FxeA7hcwNmzVYGck3NpKOfmyhcBNYO4+htn+lBTHTgAPPcc0LIlMHky4O1xid3ZP3QBuZvk3nubPlO3sFCC+6OPgJQU39VnIFWVzyOeQjknR/anPQVyUpLvvogge3M65TDF6tXykO2ee/zz741/hC4gX2cPGiRnFxtzXU9hIZCQIAfPU1O1q9NkVLWqA8NTKDudvwxid3tcUhJw2WXswKAq330nz6CbNZP2MpusX+rNf0IXkA2mWbOAZcskSOsK3+oXU953n4zW16ITwuJKSryHclGRfL7yFMrx8frt1EyeDGzeLH2lc+ZYYofIlior5UTbu+8CI0YADz7oP5+Y/St03Q4ckAPk69dXnWgIDq66gt3plAMVLpc0HI4eDXTtanTVllVW9ssgrv7288/Sj+wplBMSfNeBsXYtcPy4XEH+3Xe1/5w5c4D/+z+gUydpeeIJK+1kZUmHg9MptxKnpRldkfb8M3Td8vOBPXtkSs0338hKODhYHpR17gzccIP8iydNlZfLULjaAjknR+4Vbd7ccygnJTWsI3DrVrkTbPNm+bzqXmFVVsp+4zvvSGPKp58CPXoAw4dr8p9N/+ZyyXPpefPkcsxhw7QbDmgG/h26ZAmVlRK8NcPY3R6Xmysnn6qH8h13yBzY2ixcKOMJV66U13ZvMRw9CsyeDdx1lzzk+eIL2XPcsePScCZt5OXJxZi5ubLq7dDB6Iq04S10ec6JTCEgQFa1iYnAddf98uMulxwSqR7I3k7pnTwprUvVf73DAXz/vfQ9p//7n0NJiQQ4wMDVQ3w88Oqr0tM7YQJw552ys+fLc01mx79mZAkOh+wJd+oE9Osnw7a97Q1mZVWFrqpW3f118qR0BLrnBZw+LT+vuFjb+qmKosh41JUr5f//wIGyA+gvuNIlWyouBm66Sb5ffUXsbmgpLZV27sOHZfUVHl71c0pLgbffllN81U/3xcVxNexLLVrIVsPWrcDTT8uf17hxmp+6NxxDl2wlI0P2cw8dku2IZ56RUI2IkF7RX/1K/oG7OyV27JDJcdUb+ENCJGSzs4Evv6yai3HunASv+yFfzSPXCQkcTNQYvXvLmMi5c4EBA6SbpFcvo6vSDh+kka04ndIulpUlzSodO8q+7dmz8mVsWBgwdixw8KCsqNLSgBkz6jeoxen8ZQdG9TkYZ8/KYCJPoZyYyNa0umRmSnvZNdfIHIcGn+ovKZFewH37ZFhVQYF8Ro2Lk8FYXbpIu4rGE6LYvUBUTWEh8NVXwKlTwG9/67u5E5WVlw4mqhnKeXkS9J5COSnp0m0Of1VaCsyfL+18EyfKHn5JiVwTP2GCh7zMy5O+/BUr5Emp0ymf4dxtK+73BQfLZ96hQ6VPsCkjA7xg6BKZgMslbeOeQjknp2prw1Mo+9PVUAcPylHi5GTJzmXLZA94xIhqP0lVgb//Xfr+Skrkf1BdDcBOp2z6N28up2RuvtnntTN0iSzAPVG0eiDXPHLtvhrK08Q4u10NVV4u+/Jz5kj3SkSEPHiLi4N8Fps6FVi1SlavDe07KymRo5Rjx8oFcD78H8c+XSILUBQJzRYtPB8aqH41lDuIDxyo+n7Nq6FqvlntaihVBbZtk0VpUZF8UpoyBVi4QJXV7cqV8sHG/EeFh8t2w1/+IkvpsWN9XH3tGLpEFhIZKW+eTuJVvxrKHcTffVf1/ZpXQ9V8S0gw14Cg0lLg2mslH3NyZB9++XJg2rVr0KopgesWGCj/QzMy5EFb9+4+q90Tbi8Q+ZHqV0PVtn2Rn//LwUTV34y+Gqq8HDh9IA8pQ2+Boqq+O8pWVCQB/sUXPrlpk9sLRARAAjM11fO46OpXQ7mDeP9+GdbnvhoqOtr7wHstr4YKCgIu/+xteRAWE+O7F27WTIZ/rF4tt9BoiCtdIqq3uq6GysmRrQBvodykFr2LF2UEa0BAnV0K5ysr8WxODnYWFaF5YCAej4vD7d5axC5elNXutm1N3vjmSpeIfMLhkD3h+HiZjFpTbVdDnTgB7Nzp/Wqo6mM8vV4NtWOH7DHUY1vhxdxcBCkKNrRrh6OlpRh/8iTahYYizdMJldBQWe0ePChDPjTC0CUin1EU+ao/JkZOldVU29VQOTnA3r31uxrqiu37EOF01lnHRZcLmy5cwKq0NIQ7HOgSHo6bIyPxSWEhxsbHey7e5QK+/ZahS0T2oCgycCgqCrjqqtp/Ts2roXJyZDBRTg4wbGMmbgoLRl3zz7OcTgQASK321O/KkBB8VVLi/ReqqhxXHDCgQf9dDcHQJSJTCQ8HrrhC3n6hfwGQVXdslbhciKixL9vM4UCxy+X9FwYEyKa1hizUJk1EVD/htQRscS1BXCuNT48wdInIOhIS5EFaHVKDg1EJ2WZwO1pW5vkhmltFhWwea4ihS0TW0a2bBGMdwhwO9I2MxPwzZ3DR5cK+khL888IF3FnXVLHAwNrvi/Ihhi4RWUfnzvW+RnhyYiLKXC7cdvQoppw6hacSE72vdN33OtXWduFDfJBGRNbRvbsc0y0rq3MifFRAAF6pfjtpXYqLZar9lVc2sUjvuNIlIusIDJSBunW1fjWUqsq2xejRms/GZOgSkbUMGQJcdplvr3A+fx5o2xa4+27fvaYHDF0ispbISOC116SLoR4P1erkdMrqNiOj3vvFTcHQJSLr6dlTbq48f75pwet0ylbFyy97PiLnY3yQRkTWNHq0HGSYNUu+bcj4MlWVwFYUYPZs4He/06zMmrjSJSJrUhRg1Ci5sicuTu7yKSmRQPVEVWVgeWGh7OH+4x+6Bi7AlS4RWd311wMbNwIffQS89VbVDZ6VldLtAMgWRGCgvL9tW2DMGOCOO3TZw62JoUtE1hcWBgwaBAwcCBw5Ahw6BHz9tczHdTjkaG+XLkDHjkCbNoZemczQJSL7UBSgfXt5u/deo6upFfd0iYh0xNAlItIRQ5eISEcMXSIiHTF0iYh0pKheGokVRTkD4IR+5RAR2UIrVVXjavuA19AlIiLf4vYCEZGOGLpERDpi6BIR6YihS0SkI4YuEZGO/h+J9BYuwN2nQAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -4668,12 +963,12 @@ "z = tsp.interpret(x)\n", "print('solution:', z)\n", "print('solution objective:', tsp.tsp_value(z, adj_matrix))\n", - "draw_tsp_solution(tsp.graph, z, colors, pos)" + "draw_tsp_solution(graph, z, colors, pos)" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -4685,7 +980,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 40, "metadata": { "tags": [] }, @@ -4695,473 +990,15 @@ "output_type": "stream", "text": [ "optimal function value: 202.0\n", - "optimal value: [0. 0. 1. 0. 1. 0. 1. 0. 0.]\n", + "optimal value: [1. 0. 0. 0. 0. 1. 0. 1. 0.]\n", "status: SUCCESS\n", - "solution: [1, 2, 0]\n", - "solution objective: 202.0\n" + "solution: [2, 0, 1]\n", + "solution objective: 3.0\n" ] }, { "data": { - "image/png": "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\n", - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " 2021-03-11T18:37:49.172126\n", - " image/svg+xml\n", - " \n", - " \n", - " Matplotlib v3.3.2, https://matplotlib.org/\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n" - ], + "image/png": "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\n", "text/plain": [ "
" ] @@ -5183,12 +1020,12 @@ "z = tsp.interpret(x)\n", "print('solution:', z)\n", "print('solution objective:', tsp.tsp_value(z, adj_matrix))\n", - "draw_tsp_solution(tsp.graph, z, colors, pos)" + "draw_tsp_solution(graph, z, colors, pos)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 41, "metadata": { "ExecuteTime": { "end_time": "2019-08-22T01:58:30.581695Z", @@ -5196,19 +1033,11 @@ } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/atsushi/github/aqua-public/qiskit/aqua/operators/operator_globals.py:49: DeprecationWarning: `from_label` is deprecated and will be removed no earlier than 3 months after the release date. Use Pauli(label) instead.\n", - " X = make_immutable(PauliOp(Pauli.from_label('X')))\n" - ] - }, { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
QiskitNone
Terra0.17.0.dev0+89d15f3
Aer0.6.1
Ignis0.4.0
Aqua0.9.0.dev0+84ce2d6
IBM Q Provider0.11.0
System information
Python3.8.6 (default, Mar 10 2021, 14:41:09) \n", - "[Clang 12.0.0 (clang-1200.0.32.29)]
OSDarwin
CPUs8
Memory (Gb)32.0
Thu Mar 11 18:37:49 2021 JST
" + "

Version Information

Qiskit SoftwareVersion
QiskitNone
Terra0.18.0.dev0+9229c5c
Aer0.8.2
Ignis0.6.0
Aqua0.10.0.dev0+fcc73ed
IBM Q Provider0.13.1
System information
Python3.8.10 (default, May 4 2021, 03:06:52) \n", + "[Clang 12.0.0 (clang-1200.0.32.29)]
OSDarwin
CPUs4
Memory (Gb)16.0
Fri May 28 19:39:13 2021 JST
" ], "text/plain": [ "" @@ -5262,7 +1091,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.10" }, "varInspector": { "cols": { diff --git a/qiskit_optimization/applications/max_cut.py b/qiskit_optimization/applications/max_cut.py index c51d78a3e..bc4ae0085 100644 --- a/qiskit_optimization/applications/max_cut.py +++ b/qiskit_optimization/applications/max_cut.py @@ -41,11 +41,9 @@ def to_quadratic_program(self) -> QuadraticProgram: """ mdl = Model(name="Max-cut") x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(self._graph.num_nodes())} - for i, j in self._graph.edge_list(): - self._graph.get_edge_data(i, j).setdefault("weight", 1) objective = mdl.sum( - self._graph.get_edge_data(i, j)["weight"] * x[i] * (1 - x[j]) - + self._graph.get_edge_data(i, j)["weight"] * x[j] * (1 - x[i]) + self._graph.get_edge_data(i, j) * x[i] * (1 - x[j]) + + self._graph.get_edge_data(i, j) * x[j] * (1 - x[i]) for i, j in self._graph.edge_list() ) mdl.maximize(objective) From 14f1ee7952f5064c4f3428c0ced0d7fe3f0dc33a Mon Sep 17 00:00:00 2001 From: Takashi Imamichi Date: Fri, 28 May 2021 19:59:57 +0900 Subject: [PATCH 6/7] update --- .../applications/graph_partition.py | 4 ++-- qiskit_optimization/applications/stable_set.py | 2 -- qiskit_optimization/applications/tsp.py | 9 +++++---- .../applications/vehicle_routing.py | 4 ++-- test/applications/test_graph_partition.py | 4 ++-- test/applications/test_tsp.py | 16 ++++------------ 6 files changed, 15 insertions(+), 24 deletions(-) diff --git a/qiskit_optimization/applications/graph_partition.py b/qiskit_optimization/applications/graph_partition.py index 56c264ebc..55d503df4 100644 --- a/qiskit_optimization/applications/graph_partition.py +++ b/qiskit_optimization/applications/graph_partition.py @@ -43,9 +43,9 @@ def to_quadratic_program(self) -> QuadraticProgram: n = self._graph.num_nodes() x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(n)} for i, j in self._graph.edge_list(): - self._graph.get_edge_data(i, j).setdefault("weight", 1) + self.graph.update_edge(i, j, 1) objective = mdl.sum( - self._graph.get_edge_data(i, j)["weight"] * (x[i] + x[j] - 2 * x[i] * x[j]) + self._graph.get_edge_data(i, j) * (x[i] + x[j] - 2 * x[i] * x[j]) for i, j in self._graph.edge_list() ) mdl.minimize(objective) diff --git a/qiskit_optimization/applications/stable_set.py b/qiskit_optimization/applications/stable_set.py index 30fac6917..9154a4367 100644 --- a/qiskit_optimization/applications/stable_set.py +++ b/qiskit_optimization/applications/stable_set.py @@ -42,8 +42,6 @@ def to_quadratic_program(self) -> QuadraticProgram: mdl = Model(name="Stable set") n = self._graph.num_nodes() x = {i: mdl.binary_var(name="x_{0}".format(i)) for i in range(n)} - for w, v in self._graph.edge_list(): - self._graph.get_edge_data(w, v).setdefault("weight", 1) objective = mdl.sum(x[i] for i in x) for w, v in self._graph.edge_list(): mdl.add_constraint(x[w] + x[v] <= 1) diff --git a/qiskit_optimization/applications/tsp.py b/qiskit_optimization/applications/tsp.py index b91619ba7..a911676bc 100644 --- a/qiskit_optimization/applications/tsp.py +++ b/qiskit_optimization/applications/tsp.py @@ -51,7 +51,7 @@ def to_quadratic_program(self) -> QuadraticProgram: for k in range(n) } tsp_func = mdl.sum( - self._graph.get_edge_data(i, j)["weight"] * x[(i, k)] * x[(j, (k + 1) % n)] + self._graph.get_edge_data(i, j) * x[(i, k)] * x[(j, (k + 1) % n)] for i in range(n) for j in range(n) for k in range(n) @@ -142,7 +142,7 @@ def create_random_instance(n: int, low: int = 0, high: int = 100, seed: int = No graph.get_node_data(i)["pos"][d] - graph.get_node_data(j)["pos"][d] for d in range(dim) ] - graph.update_edge(i, j, {"weight": np.rint(np.hypot(delta[0], delta[1]))}) + graph.update_edge(i, j, np.rint(np.hypot(delta[0], delta[1]))) return Tsp(graph) @staticmethod @@ -197,12 +197,13 @@ def parse_tsplib_format(filename: str) -> "Tsp": y_max = max(coord_[1] for coord_ in coord) y_min = min(coord_[1] for coord_ in coord) - graph = nx.random_geometric_graph( + # TODO: fix and add test + graph = rx.random_geometric_graph( len(coord), np.hypot(x_max - x_min, y_max - y_min) + 1, pos=coord ) for w, v in graph.edges: delta = [graph.nodes[w]["pos"][i] - graph.nodes[v]["pos"][i] for i in range(2)] - graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1])) + graph.update_edge(w, v, np.rint(np.hypot(delta[0], delta[1]))) return Tsp(graph) @staticmethod diff --git a/qiskit_optimization/applications/vehicle_routing.py b/qiskit_optimization/applications/vehicle_routing.py index b4ff997d1..40df656a2 100644 --- a/qiskit_optimization/applications/vehicle_routing.py +++ b/qiskit_optimization/applications/vehicle_routing.py @@ -69,7 +69,7 @@ def to_quadratic_program(self) -> QuadraticProgram: x[(i, j)] = mdl.binary_var(name="x_{0}_{1}".format(i, j)) mdl.minimize( mdl.sum( - self._graph.get_edge_data(i, j)["weight"] * x[(i, j)] + self._graph.get_edge_data(i, j) * x[(i, j)] for i in range(n) for j in range(n) if i != j @@ -250,5 +250,5 @@ def create_random_instance( graph.get_node_data(i)["pos"][d] - graph.get_node_data(j)["pos"][d] for d in range(dim) ] - graph.update_edge(i, j, {"weight": np.rint(np.hypot(delta[0], delta[1]))}) + graph.update_edge(i, j, np.rint(np.hypot(delta[0], delta[1]))) return VehicleRouting(graph, num_vehicle, depot) diff --git a/test/applications/test_graph_partition.py b/test/applications/test_graph_partition.py index 0fd6efa7d..6e823325c 100644 --- a/test/applications/test_graph_partition.py +++ b/test/applications/test_graph_partition.py @@ -13,7 +13,7 @@ """ Test GraphPartinioning class""" from test.optimization_test_case import QiskitOptimizationTestCase -import networkx as nx +import retworkx as rx from qiskit_optimization import QuadraticProgram from qiskit_optimization.algorithms import OptimizationResult, OptimizationResultStatus @@ -27,7 +27,7 @@ class TestGraphPartition(QiskitOptimizationTestCase): def setUp(self): """Set up for the tests""" super().setUp() - self.graph = nx.gnm_random_graph(4, 4, 123) + self.graph = rx.undirected_gnm_random_graph(4, 4, 123) op = QuadraticProgram() for _ in range(4): op.binary_var() diff --git a/test/applications/test_tsp.py b/test/applications/test_tsp.py index b6f2ca9d7..fcebd165b 100644 --- a/test/applications/test_tsp.py +++ b/test/applications/test_tsp.py @@ -29,16 +29,10 @@ class TestTsp(QiskitOptimizationTestCase): def setUp(self): super().setUp() - random.seed(123) + seed = 123 low = 0 high = 100 - pos = {i: (random.randint(low, high), random.randint(low, high)) for i in range(4)} - self.graph = nx.random_geometric_graph(4, np.hypot(high - low, high - low) + 1, pos=pos) - for w, v in self.graph.edges: - delta = [ - self.graph.nodes[w]["pos"][i] - self.graph.nodes[v]["pos"][i] for i in range(2) - ] - self.graph.edges[w, v]["weight"] = np.rint(np.hypot(delta[0], delta[1])) + self.graph = Tsp.create_random_instance(4, low, high, seed).graph op = QuadraticProgram() for i in range(16): @@ -66,7 +60,7 @@ def test_to_quadratic_program(self): self.assertEqual(obj.constant, 0) self.assertDictEqual(obj.linear.to_dict(), {}) for edge, val in obj.quadratic.to_dict().items(): - self.assertEqual(val, self.graph.edges[edge[0] // 4, edge[1] // 4]["weight"]) + self.assertEqual(val, self.graph.get_edge_data(edge[0] // 4, edge[1] // 4)) # Test constraint lin = op.linear_constraints @@ -96,7 +90,5 @@ def test_edgelist(self): def test_create_random_instance(self): """Test create_random_instance""" tsp = Tsp.create_random_instance(n=3, seed=123) - graph = tsp.graph - edge_weight = [graph.get_edge_data(*edge)["weight"] for edge in graph.edge_list()] expected_weight = [48, 91, 63] - self.assertEqual(edge_weight, expected_weight) + self.assertEqual(tsp.graph.edges(), expected_weight) From 91f67f614556bf9e2c7aa7145d5a81c4fff8acef Mon Sep 17 00:00:00 2001 From: Takashi Imamichi <31178928+t-imamichi@users.noreply.github.com> Date: Fri, 28 May 2021 22:06:17 +0900 Subject: [PATCH 7/7] Update qiskit_optimization/applications/graph_optimization_application.py Co-authored-by: Matthew Treinish --- .../applications/graph_optimization_application.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_optimization/applications/graph_optimization_application.py b/qiskit_optimization/applications/graph_optimization_application.py index 8e5a65109..389fbd626 100644 --- a/qiskit_optimization/applications/graph_optimization_application.py +++ b/qiskit_optimization/applications/graph_optimization_application.py @@ -50,7 +50,7 @@ def __init__(self, graph: Union[rx.PyGraph, nx.Graph, np.ndarray, List]) -> None elif isinstance(graph, nx.Graph): self._graph = rx.networkx_converter(graph) elif isinstance(graph, (np.ndarray, List)): - self._graph = rx.PyGraph.from_adjacency_matrix(graph) + self._graph = rx.PyGraph.from_adjacency_matrix(np.asarray(graph)) else: raise TypeError("graph should be rx.PyGraph or nx.Graph")