def test_valid_variable_type(self): """Validate the types of the variables for QuadraticProgram.to_ising.""" # Integer variable with self.assertRaises(QiskitOptimizationError): op = QuadraticProgram() op.integer_var(0, 10, "int_var") _ = op.to_ising() # Continuous variable with self.assertRaises(QiskitOptimizationError): op = QuadraticProgram() op.continuous_var(0, 10, "continuous_var") _ = op.to_ising()
def makeNPMatrix4(edges, cedges, n): #QUBO mdl = Model('MaxClique') x = mdl.binary_var_list('x{}'.format(i) for i in range(n)) objective = mdl.sum([(x[i]) for i in range(n)]) mdl.maximize(objective) mdl.prettyprint() qp = QuadraticProgram() qp.from_docplex(mdl) #to matrix H, offset = qp.to_ising() H_matrix = np.real(H.to_matrix()) return H
def test_constructor(self): """ test constructor """ quadratic_program = QuadraticProgram() self.assertEqual(quadratic_program.name, '') self.assertEqual(quadratic_program.status, QuadraticProgram.Status.VALID) self.assertEqual(quadratic_program.get_num_vars(), 0) self.assertEqual(quadratic_program.get_num_linear_constraints(), 0) self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 0) self.assertEqual(quadratic_program.objective.constant, 0) self.assertDictEqual(quadratic_program.objective.linear.to_dict(), {}) self.assertDictEqual(quadratic_program.objective.quadratic.to_dict(), {})
def solve(self): # self.write_model() # IBMQ.enable_account(os.getenv('IBM_TOKEN')) backend = BasicAer.get_backend('ibmq_qasm_simulator') # backend = Aer.get_backend('qasm_simulator') prog = QuadraticProgram("molecConform") prog.read_from_lp_file(str(self.LP_FILEPATH)) optimizer = GroverOptimizer(3, quantum_instance=backend) results = optimizer.solve(prog) print(results) import pdb pdb.set_trace()
def test_optimizationproblem_to_ising_deprecated(self): """ Test optimization problem to operators""" op = QuadraticProgram() for i in range(4): op.binary_var(name='x{}'.format(i)) linear = {} for x in op.variables: linear[x.name] = 1 op.maximize(0, linear, {}) linear = {} for i, x in enumerate(op.variables): linear[x.name] = i + 1 op.linear_constraint(linear, Constraint.Sense.EQ, 3, 'sum1') penalize = LinearEqualityToPenalty(penalty=1e5) try: warnings.filterwarnings(action="ignore", category=DeprecationWarning) op2 = penalize.encode(op) conv = QuadraticProgramToIsing() qubitop, offset = conv.encode(op2) finally: warnings.filterwarnings(action="always", category=DeprecationWarning) self.assertEqual(qubitop, QUBIT_OP_MAXIMIZE_SAMPLE) self.assertEqual(offset, OFFSET_MAXIMIZE_SAMPLE)
def makeNPMatrix1(edges, cedges, n): #QUBO mdl = Model('MaxClique') x = mdl.binary_var_list('x{}'.format(i) for i in range(n)) q = (n - 1) * n / 2 objective = mdl.sum([(x[i] * x[j]) for (i, j) in edges] + [-q * (x[i] * x[j]) for (i, j) in cedges]) mdl.maximize(objective) qp = QuadraticProgram() qp.from_docplex(mdl) #to matrix H, offset = qp.to_ising() H_matrix = np.real(H.to_matrix()) return H
def test_linear_equality_to_penalty_decode(self): """ Test decode func of LinearEqualityToPenalty""" qprog = QuadraticProgram() qprog.binary_var('x') qprog.binary_var('y') qprog.binary_var('z') qprog.maximize(linear={'x': 3, 'y': 1, 'z': 1}) qprog.linear_constraint(linear={ 'x': 1, 'y': 1, 'z': 1 }, sense='EQ', rhs=2, name='xyz_eq') lineq2penalty = LinearEqualityToPenalty() qubo = lineq2penalty.convert(qprog) exact_mes = NumPyMinimumEigensolver() exact = MinimumEigenOptimizer(exact_mes) result = exact.solve(qubo) decoded_result = lineq2penalty.interpret(result) self.assertEqual(decoded_result.fval, 4) np.testing.assert_array_almost_equal(decoded_result.x, [1, 1, 0]) self.assertEqual(decoded_result.status, OptimizationResultStatus.SUCCESS) self.assertListEqual(decoded_result.variable_names, ['x', 'y', 'z']) self.assertDictEqual(decoded_result.variables_dict, { 'x': 1.0, 'y': 1.0, 'z': 0.0 }) infeasible_result = OptimizationResult( x=[1, 1, 1], fval=0, variables=qprog.variables, status=OptimizationResultStatus.SUCCESS) decoded_infeasible_result = lineq2penalty.interpret(infeasible_result) self.assertEqual(decoded_infeasible_result.fval, 5) np.testing.assert_array_almost_equal(decoded_infeasible_result.x, [1, 1, 1]) self.assertEqual(decoded_infeasible_result.status, OptimizationResultStatus.INFEASIBLE) self.assertListEqual(infeasible_result.variable_names, ['x', 'y', 'z']) self.assertDictEqual(infeasible_result.variables_dict, { 'x': 1.0, 'y': 1.0, 'z': 1.0 })
def test_optimizationproblem_to_ising(self): """ Test optimization problem to operators""" op = QuadraticProgram() for i in range(4): op.binary_var(name='x{}'.format(i)) linear = {} for x in op.variables: linear[x.name] = 1 op.maximize(0, linear, {}) linear = {} for i, x in enumerate(op.variables): linear[x.name] = i + 1 op.linear_constraint(linear, Constraint.Sense.EQ, 3, 'sum1') penalize = LinearEqualityToPenalty() op2ope = QuadraticProgramToIsing() op2 = penalize.encode(op) qubitop, offset = op2ope.encode(op2) # the encoder uses a dictionary, in which the order of items in Python 3.5 is not # maintained, therefore don't do a list compare but dictionary compare qubit_op_as_dict = dict(qubitop.paulis) for coeff, paulis in QUBIT_OP_MAXIMIZE_SAMPLE.paulis: self.assertEqual(paulis, qubit_op_as_dict[coeff]) self.assertEqual(offset, OFFSET_MAXIMIZE_SAMPLE)
def test_inequality_mode_auto(self): """ Test auto mode of InequalityToEqualityConverter() """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {'x0': 1, 'x1': 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {'x1': 1, 'x2': -1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, 'x1x2') linear_constraint = {'x0': 1.1, 'x2': 2.2} op.linear_constraint(linear_constraint, Constraint.Sense.GE, 3.3, 'x0x2') conv = InequalityToEquality(mode='auto') op2 = conv.convert(op) lst = [op2.variables[3].vartype, op2.variables[4].vartype] self.assertListEqual(lst, [Variable.Type.INTEGER, Variable.Type.CONTINUOUS])
def test_binary_to_integer(self): """ Test binary to integer """ op = QuadraticProgram() for i in range(0, 2): op.binary_var(name='x{}'.format(i)) op.integer_var(name='x2', lowerbound=0, upperbound=5) linear = {'x0': 1, 'x1': 2, 'x2': 1} op.maximize(0, linear, {}) linear = {} for x in op.variables: linear[x.name] = 1 op.linear_constraint(linear, Constraint.Sense.EQ, 6, 'x0x1x2') conv = IntegerToBinary() _ = conv.convert(op) new_x = conv.interpret([0, 1, 1, 1, 1]) np.testing.assert_array_almost_equal(new_x, [0, 1, 5])
def test_ising_to_quadraticprogram_quadratic(self): """ Test optimization problem to operators with linear=False""" op = QUBIT_OP_MAXIMIZE_SAMPLE offset = OFFSET_MAXIMIZE_SAMPLE quadratic = QuadraticProgram() quadratic.from_ising(op, offset, linear=False) self.assertEqual(quadratic.get_num_vars(), 4) self.assertEqual(quadratic.get_num_linear_constraints(), 0) self.assertEqual(quadratic.get_num_quadratic_constraints(), 0) self.assertEqual(quadratic.objective.sense, quadratic.objective.Sense.MINIMIZE) self.assertAlmostEqual(quadratic.objective.constant, 900000) quadratic_matrix = np.zeros((4, 4)) quadratic_matrix[0, 0] = -500001 quadratic_matrix[0, 1] = 400000 quadratic_matrix[0, 2] = 600000 quadratic_matrix[0, 3] = 800000 quadratic_matrix[1, 1] = -800001 quadratic_matrix[1, 2] = 1200000 quadratic_matrix[1, 3] = 1600000 quadratic_matrix[2, 2] = -900001 quadratic_matrix[2, 3] = 2400000 quadratic_matrix[3, 3] = -800001 np.testing.assert_array_almost_equal( quadratic.objective.quadratic.coefficients.toarray(), quadratic_matrix)
def test_evaluate(self): """ test evaluate. """ quadratic_program = QuadraticProgram() x = [quadratic_program.continuous_var() for _ in range(5)] coefficients_list = list(range(5)) linear = LinearExpression(quadratic_program, coefficients_list) values_list = list(range(len(x))) values_array = np.array(values_list) values_dict_int = {i: i for i in range(len(x))} values_dict_str = {'x{}'.format(i): i for i in range(len(x))} for values in [ values_list, values_array, values_dict_int, values_dict_str ]: self.assertEqual(linear.evaluate(values), 30)
def test_get_item(self): """ test get_item. """ quadratic_program = QuadraticProgram() for _ in range(5): quadratic_program.continuous_var() coefficients = [[0 for _ in range(5)] for _ in range(5)] for i, v in enumerate(coefficients): for j, _ in enumerate(v): coefficients[min(i, j)][max(i, j)] += i * j quadratic = QuadraticExpression(quadratic_program, coefficients) for i, j_v in enumerate(coefficients): for j, _ in enumerate(j_v): if i == j: self.assertEqual(quadratic[i, j], coefficients[i][j]) else: self.assertEqual(quadratic[i, j], coefficients[i][j] + coefficients[j][i])
def test_auto_penalty_warning(self): """ Test warnings of auto penalty function""" op = QuadraticProgram() op.binary_var('x') op.binary_var('y') op.binary_var('z') op.minimize(linear={'x': 1, 'y': 2}) op.linear_constraint(linear={'x': 0.5, 'y': 0.5, 'z': 0.5}, sense='EQ', rhs=1, name='xyz') with self.assertLogs('qiskit.optimization', level='WARNING') as log: lineq2penalty = LinearEqualityToPenalty() _ = lineq2penalty.encode(op) warning = ( 'WARNING:qiskit.optimization.converters.linear_equality_to_penalty:' + 'Warning: Using 100000.000000 for the penalty coefficient because a float ' + 'coefficient exists in constraints. \nThe value could be too small. If so, ' + 'set the penalty coefficient manually.' ) self.assertIn(warning, log.output)
def test_auto_penalty(self): """ Test auto penalty function""" op = QuadraticProgram() op.binary_var('x') op.binary_var('y') op.binary_var('z') op.minimize(constant=3, linear={'x': 1}, quadratic={('x', 'y'): 2}) op.linear_constraint(linear={'x': 1, 'y': 1, 'z': 1}, sense='EQ', rhs=2, name='xyz_eq') lineq2penalty = LinearEqualityToPenalty(penalty=1e5) lineq2penalty_auto = LinearEqualityToPenalty() qubo = lineq2penalty.encode(op) qubo_auto = lineq2penalty_auto.encode(op) exact_mes = NumPyMinimumEigensolver() exact = MinimumEigenOptimizer(exact_mes) result = exact.solve(qubo) result_auto = exact.solve(qubo_auto) self.assertEqual(result.fval, result_auto.fval) self.assertListEqual(result.x, result_auto.x)
def _test_readme_sample(self): """ readme sample test """ # pylint: disable=import-outside-toplevel,redefined-builtin def print(*args): """ overloads print to log values """ if args: self.log.debug(args[0], *args[1:]) # Fix the random seed of SPSA (Optional) from qiskit.aqua import aqua_globals aqua_globals.random_seed = 123 # --- Exact copy of sample code ---------------------------------------- import networkx as nx import numpy as np from qiskit.optimization import QuadraticProgram from qiskit.optimization.algorithms import MinimumEigenOptimizer from qiskit import BasicAer from qiskit.aqua.algorithms import QAOA from qiskit.aqua.components.optimizers import SPSA # Generate a graph of 4 nodes n = 4 graph = nx.Graph() graph.add_nodes_from(np.arange(0, n, 1)) elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)] graph.add_weighted_edges_from(elist) # Compute the weight matrix from the graph w = nx.adjacency_matrix(graph) # Formulate the problem as quadratic program problem = QuadraticProgram() _ = [problem.binary_var('x{}'.format(i)) for i in range(n)] # create n binary variables linear = w.dot(np.ones(n)) quadratic = -w problem.maximize(linear=linear, quadratic=quadratic) # Fix node 0 to be 1 to break the symmetry of the max-cut solution problem.linear_constraint([1, 0, 0, 0], '==', 1) # Run quantum algorithm QAOA on qasm simulator spsa = SPSA(maxiter=250) backend = BasicAer.get_backend('qasm_simulator') qaoa = QAOA(optimizer=spsa, p=5, quantum_instance=backend) algorithm = MinimumEigenOptimizer(qaoa) result = algorithm.solve(problem) print(result) # prints solution, x=[1, 0, 1, 0], the cost, fval=4 # ---------------------------------------------------------------------- np.testing.assert_array_almost_equal(result.x, [1, 0, 1, 0]) self.assertAlmostEqual(result.fval, 4.0)
def test_evaluate(self): """ test evaluate. """ quadratic_program = QuadraticProgram() x = [quadratic_program.continuous_var() for _ in range(5)] coefficients_list = [[0 for _ in range(5)] for _ in range(5)] for i, v in enumerate(coefficients_list): for j, _ in enumerate(v): coefficients_list[min(i, j)][max(i, j)] += i * j quadratic = QuadraticExpression(quadratic_program, coefficients_list) values_list = list(range(len(x))) values_array = np.array(values_list) values_dict_int = {i: i for i in range(len(x))} values_dict_str = {'x{}'.format(i): i for i in range(len(x))} for values in [values_list, values_array, values_dict_int, values_dict_str]: self.assertEqual(quadratic.evaluate(values), 900)
def test_binary_to_integer(self): """ Test binary to integer """ op = QuadraticProgram() for i in range(0, 2): op.binary_var(name='x{}'.format(i)) op.integer_var(name='x2', lowerbound=0, upperbound=5) linear = {} linear['x0'] = 1 linear['x1'] = 2 linear['x2'] = 1 op.maximize(0, linear, {}) linear = {} for x in op.variables: linear[x.name] = 1 op.linear_constraint(linear, Constraint.Sense.EQ, 6, 'x0x1x2') conv = IntegerToBinary() _ = conv.encode(op) result = OptimizationResult(x=[0, 1, 1, 1, 1], fval=17) new_result = conv.decode(result) self.assertListEqual(new_result.x, [0, 1, 5]) self.assertEqual(new_result.fval, 17)
def test_binary_to_integer(self): """ Test binary to integer """ op = QuadraticProgram() for i in range(0, 2): op.binary_var(name='x{}'.format(i)) op.integer_var(name='x2', lowerbound=0, upperbound=5) linear = {'x0': 1, 'x1': 2, 'x2': 1} op.maximize(0, linear, {}) linear = {} for x in op.variables: linear[x.name] = 1 op.linear_constraint(linear, Constraint.Sense.EQ, 6, 'x0x1x2') conv = IntegerToBinary() op2 = conv.convert(op) result = OptimizationResult(x=[0, 1, 1, 1, 1], fval=17, variables=op2.variables, status=OptimizationResultStatus.SUCCESS) new_result = conv.interpret(result) np.testing.assert_array_almost_equal(new_result.x, [0, 1, 5]) self.assertEqual(new_result.fval, 17) self.assertListEqual(new_result.variable_names, ['x0', 'x1', 'x2']) self.assertDictEqual(new_result.variables_dict, {'x0': 0, 'x1': 1, 'x2': 5})
def test_empty_problem(self): """ Test empty problem """ op = QuadraticProgram() conv = InequalityToEquality() op = conv.encode(op) conv = IntegerToBinary() op = conv.encode(op) conv = LinearEqualityToPenalty() op = conv.encode(op) conv = QuadraticProgramToIsing() _, shift = conv.encode(op) self.assertEqual(shift, 0.0)
def test_objective_handling(self): """test objective handling""" q_p = QuadraticProgram() q_p.binary_var('x') q_p.binary_var('y') q_p.binary_var('z') q_p.minimize() obj = q_p.objective self.assertEqual(obj.sense, QuadraticObjective.Sense.MINIMIZE) self.assertEqual(obj.constant, 0) self.assertDictEqual(obj.linear.to_dict(), {}) self.assertDictEqual(obj.quadratic.to_dict(), {}) q_p.maximize(1, {'y': 1}, {('z', 'x'): 1, ('y', 'y'): 1}) obj = q_p.objective self.assertEqual(obj.sense, QuadraticObjective.Sense.MAXIMIZE) self.assertEqual(obj.constant, 1) self.assertDictEqual(obj.linear.to_dict(), {1: 1}) self.assertDictEqual(obj.linear.to_dict(use_name=True), {'y': 1}) self.assertListEqual(obj.linear.to_array().tolist(), [0, 1, 0]) self.assertDictEqual(obj.quadratic.to_dict(), {(0, 2): 1, (1, 1): 1}) self.assertDictEqual(obj.quadratic.to_dict(symmetric=True), { (0, 2): 0.5, (2, 0): 0.5, (1, 1): 1 }) self.assertDictEqual(obj.quadratic.to_dict(use_name=True), { ('x', 'z'): 1, ('y', 'y'): 1 }) self.assertDictEqual( obj.quadratic.to_dict(use_name=True, symmetric=True), { ('x', 'z'): 0.5, ('z', 'x'): 0.5, ('y', 'y'): 1 }) self.assertListEqual(obj.quadratic.to_array().tolist(), [[0, 0, 1], [0, 1, 0], [0, 0, 0]]) self.assertListEqual( obj.quadratic.to_array(symmetric=True).tolist(), [[0, 0, 0.5], [0, 1, 0], [0.5, 0, 0]])
def test_valid_variable_type_deprecated(self): """Validate the types of the variables for QuadraticProgramToIsing.""" # Integer variable with self.assertRaises(QiskitOptimizationError): op = QuadraticProgram() op.integer_var(0, 10, "int_var") conv = QuadraticProgramToIsing() _ = conv.encode(op) # Continuous variable with self.assertRaises(QiskitOptimizationError): op = QuadraticProgram() op.continuous_var(0, 10, "continuous_var") conv = QuadraticProgramToIsing() _ = conv.encode(op)
def test_inequality_mode_integer(self): """ Test integer mode of InequalityToEqualityConverter() """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x1'] = 1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {} linear_constraint['x1'] = 1 linear_constraint['x2'] = -1 op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, 'x1x2') linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x2'] = 3 op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, 'x0x2') conv = InequalityToEquality(mode='integer') op2 = conv.convert(op) lst = [op2.variables[3].vartype, op2.variables[4].vartype] self.assertListEqual(lst, [Variable.Type.INTEGER, Variable.Type.INTEGER])
def test_feasibility(self): """Tests feasibility methods.""" mod = Model('test') # 0, 5 x = mod.continuous_var( -1, 1, 'x', ) y = mod.continuous_var(-10, 10, 'y') mod.minimize(x + y) mod.add(x + y <= 10, 'c0') mod.add(x + y >= -10, 'c1') mod.add(x + y == 5, 'c2') mod.add(x * x + y <= 10, 'c3') mod.add(x * x + y >= 5, 'c4') mod.add(x * x + y * y == 25, 'c5') q_p = QuadraticProgram() q_p.from_docplex(mod) self.assertTrue(q_p.is_feasible([0, 5])) self.assertFalse(q_p.is_feasible([1, 10])) self.assertFalse(q_p.is_feasible([1, -12])) self.assertFalse(q_p.is_feasible([1, 5])) self.assertFalse(q_p.is_feasible([5, 0])) self.assertFalse(q_p.is_feasible([1, 1])) self.assertFalse(q_p.is_feasible([0, 0])) feasible, variables, constraints = q_p.get_feasibility_info([10, 0]) self.assertFalse(feasible) self.assertIsNotNone(variables) self.assertEqual(1, len(variables)) self.assertEqual('x', variables[0].name) self.assertIsNotNone(constraints) self.assertEqual(3, len(constraints)) self.assertEqual('c2', constraints[0].name) self.assertEqual('c3', constraints[1].name) self.assertEqual('c5', constraints[2].name)
def test_penalize_binary(self): """ Test PenalizeLinearEqualityConstraints with binary variables """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x1'] = 1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {} linear_constraint['x1'] = 1 linear_constraint['x2'] = -1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x1x2') linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x2'] = 3 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x0x2') self.assertEqual(len(op.linear_constraints), 3) conv = LinearEqualityToPenalty() op2 = conv.convert(op) self.assertEqual(len(op2.linear_constraints), 0)
def test_inequality_mode_continuous(self): """ Test continuous mode of InequalityToEqualityConverter() """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x1'] = 1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {} linear_constraint['x1'] = 1 linear_constraint['x2'] = -1 op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, 'x1x2') linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x2'] = 3 op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, 'x0x2') conv = InequalityToEquality() op2 = conv.encode(op, mode='continuous') lst = [op2.variables[3].vartype, op2.variables[4].vartype] self.assertListEqual(lst, [Variable.Type.CONTINUOUS, Variable.Type.CONTINUOUS])
def test_penalize_sense(self): """ Test PenalizeLinearEqualityConstraints with senses """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x1'] = 1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {} linear_constraint['x1'] = 1 linear_constraint['x2'] = -1 op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, 'x1x2') linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x2'] = 3 op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, 'x0x2') self.assertEqual(len(op.linear_constraints), 3) conv = LinearEqualityToPenalty() with self.assertRaises(QiskitOptimizationError): conv.encode(op)
def test_penalize_integer(self): """ Test PenalizeLinearEqualityConstraints with integer variables """ op = QuadraticProgram() for i in range(3): op.integer_var(name='x{}'.format(i), lowerbound=-3, upperbound=3) # Linear constraints linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x1'] = 1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {} linear_constraint['x1'] = 1 linear_constraint['x2'] = -1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x1x2') linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x2'] = 3 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x0x2') self.assertEqual(len(op.linear_constraints), 3) conv = LinearEqualityToPenalty() op2 = conv.encode(op) self.assertEqual(len(op2.linear_constraints), 0)
def test_evaluate_gradient(self): """ test evaluate gradient. """ quadratic_program = QuadraticProgram() x = [quadratic_program.continuous_var() for _ in range(5)] coefficients_list = [[0 for _ in range(5)] for _ in range(5)] for i, v in enumerate(coefficients_list): for j, _ in enumerate(v): coefficients_list[min(i, j)][max(i, j)] += i * j quadratic = QuadraticExpression(quadratic_program, coefficients_list) values_list = list(range(len(x))) values_array = np.array(values_list) values_dict_int = {i: i for i in range(len(x))} values_dict_str = {'x{}'.format(i): i for i in range(len(x))} grad_values = [0., 60., 120., 180., 240.] for values in [ values_list, values_array, values_dict_int, values_dict_str ]: np.testing.assert_almost_equal(quadratic.evaluate_gradient(values), grad_values)
def test_continuous_variable_decode(self): """ Test decode func of IntegerToBinaryConverter for continuous variables""" try: mdl = Model('test_continuous_varable_decode') c = mdl.continuous_var(lb=0, ub=10.9, name='c') x = mdl.binary_var(name='x') mdl.maximize(c + x * x) op = QuadraticProgram() op.from_docplex(mdl) converter = IntegerToBinary() op = converter.convert(op) admm_params = ADMMParameters() qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver()) continuous_optimizer = CplexOptimizer() solver = ADMMOptimizer( qubo_optimizer=qubo_optimizer, continuous_optimizer=continuous_optimizer, params=admm_params, ) result = solver.solve(op) new_x = converter.interpret(result.x) self.assertEqual(new_x[0], 10.9) except MissingOptionalLibraryError as ex: self.skipTest(str(ex))