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)
result = converter.interpret(result)
self.assertEqual(result.x[0], 10.9)
self.assertListEqual(result.variable_names, ['c', 'x'])
self.assertDictEqual(result.variables_dict, {'c': 10.9, 'x': 0})
except NameError as ex:
self.skipTest(str(ex))
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 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 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_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.encode(op)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params,
)
solution = solver.solve(op)
solution = converter.decode(solution)
self.assertEqual(solution.x[0], 10.9)
except NameError as ex:
self.skipTest(str(ex))
def test_docplex(self):
"""test from_docplex and to_docplex"""
q_p = QuadraticProgram('test')
q_p.binary_var(name='x')
q_p.integer_var(name='y', lowerbound=-2, upperbound=4)
q_p.continuous_var(name='z', lowerbound=-1.5, upperbound=3.2)
q_p.minimize(constant=1,
linear={
'x': 1,
'y': 2
},
quadratic={
('x', 'y'): -1,
('z', 'z'): 2
})
q_p.linear_constraint({'x': 2, 'z': -1}, '==', 1)
q_p.quadratic_constraint({'x': 2, 'z': -1}, {('y', 'z'): 3}, '==', 1)
q_p2 = QuadraticProgram()
q_p2.from_docplex(q_p.to_docplex())
self.assertEqual(q_p.export_as_lp_string(), q_p2.export_as_lp_string())
mod = Model('test')
x = mod.binary_var('x')
y = mod.integer_var(-2, 4, 'y')
z = mod.continuous_var(-1.5, 3.2, 'z')
mod.minimize(1 + x + 2 * y - x * y + 2 * z * z)
mod.add(2 * x - z == 1, 'c0')
mod.add(2 * x - z + 3 * y * z == 1, 'q0')
self.assertEqual(q_p.export_as_lp_string(), mod.export_as_lp_string())
with self.assertRaises(QiskitOptimizationError):
mod = Model()
mod.semiinteger_var(lb=1, name='x')
q_p.from_docplex(mod)
with self.assertRaises(QiskitOptimizationError):
mod = Model()
x = mod.binary_var('x')
mod.add_range(0, 2 * x, 1)
q_p.from_docplex(mod)
with self.assertRaises(QiskitOptimizationError):
mod = Model()
x = mod.binary_var('x')
y = mod.binary_var('y')
mod.add_indicator(x, x + y <= 1, 1)
q_p.from_docplex(mod)
with self.assertRaises(QiskitOptimizationError):
mod = Model()
x = mod.binary_var('x')
y = mod.binary_var('y')
mod.add_equivalence(x, x + y <= 1, 1)
q_p.from_docplex(mod)
with self.assertRaises(QiskitOptimizationError):
mod = Model()
x = mod.binary_var('x')
y = mod.binary_var('y')
mod.add(mod.not_equal_constraint(x, y + 1))
q_p.from_docplex(mod)
# test from_docplex without explicit variable names
mod = Model()
x = mod.binary_var()
y = mod.continuous_var()
z = mod.integer_var()
mod.minimize(x + y + z + x * y + y * z + x * z)
mod.add_constraint(x + y == z) # linear EQ
mod.add_constraint(x + y >= z) # linear GE
mod.add_constraint(x + y <= z) # linear LE
mod.add_constraint(x * y == z) # quadratic EQ
mod.add_constraint(x * y >= z) # quadratic GE
mod.add_constraint(x * y <= z) # quadratic LE
q_p = QuadraticProgram()
q_p.from_docplex(mod)
var_names = [v.name for v in q_p.variables]
self.assertListEqual(var_names, ['x0', 'x1', 'x2'])
senses = [
Constraint.Sense.EQ, Constraint.Sense.GE, Constraint.Sense.LE
]
for i, c in enumerate(q_p.linear_constraints):
self.assertDictEqual(c.linear.to_dict(use_name=True), {
'x0': 1,
'x1': 1,
'x2': -1
})
self.assertEqual(c.rhs, 0)
self.assertEqual(c.sense, senses[i])
for i, c in enumerate(q_p.quadratic_constraints):
self.assertEqual(c.rhs, 0)
self.assertDictEqual(c.linear.to_dict(use_name=True), {'x2': -1})
self.assertDictEqual(c.quadratic.to_dict(use_name=True),
{('x0', 'x1'): 1})
self.assertEqual(c.sense, senses[i])
