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.convert(op)
qubo_auto = lineq2penalty_auto.convert(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)
np.testing.assert_array_almost_equal(result.x, result_auto.x)
def build_qubo_unconstrained_from_edges_dict(G, all_edges_dict, variables):
qubo = QuadraticProgram()
linear, quadratic = get_linear_quadratic_coeffs(G, all_edges_dict)
for var in variables:
qubo.binary_var(var)
qubo.minimize(linear=linear, quadratic=quadratic)
return qubo, linear, quadratic
def test_maximize_to_minimize(self):
"""Test maximization to minimization conversion"""
op_max = QuadraticProgram()
op_min = QuadraticProgram()
for i in range(2):
op_max.binary_var(name="x{}".format(i))
op_min.binary_var(name="x{}".format(i))
op_max.integer_var(name="x{}".format(2), lowerbound=-3, upperbound=3)
op_min.integer_var(name="x{}".format(2), lowerbound=-3, upperbound=3)
op_max.maximize(constant=3,
linear={"x0": 1},
quadratic={("x1", "x2"): 2})
op_min.minimize(constant=3,
linear={"x0": 1},
quadratic={("x1", "x2"): 2})
# check conversion of maximization problem
conv = MaximizeToMinimize()
op_conv = conv.convert(op_max)
self.assertEqual(op_conv.objective.sense,
op_conv.objective.Sense.MINIMIZE)
x = [0, 1, 2]
fval_min = op_conv.objective.evaluate(conv.interpret(x))
self.assertAlmostEqual(fval_min, -7)
self.assertAlmostEqual(op_max.objective.evaluate(x), -fval_min)
# check conversion of minimization problem
op_conv = conv.convert(op_min)
self.assertEqual(op_conv.objective.sense, op_min.objective.sense)
fval_min = op_conv.objective.evaluate(conv.interpret(x))
self.assertAlmostEqual(op_min.objective.evaluate(x), fval_min)
def test_penalty_recalculation_when_reusing(self):
"""Test the penalty retrieval and recalculation of LinearEqualityToPenalty"""
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")
# First, create a converter with no penalty
lineq2penalty = LinearEqualityToPenalty()
self.assertIsNone(lineq2penalty.penalty)
# Then converter must calculate the penalty for the problem (should be 4.0)
lineq2penalty.convert(op)
self.assertEqual(4, lineq2penalty.penalty)
# Re-use the converter with a newly defined penalty
lineq2penalty.penalty = 3
lineq2penalty.convert(op)
self.assertEqual(3, lineq2penalty.penalty)
# Re-use the converter letting the penalty be calculated again
lineq2penalty.penalty = None
lineq2penalty.convert(op)
self.assertEqual(4, lineq2penalty.penalty)
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_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)
new_x = lineq2penalty.interpret(result.x)
np.testing.assert_array_almost_equal(new_x, [1, 1, 0])
infeasible_x = lineq2penalty.interpret([1, 1, 1])
np.testing.assert_array_almost_equal(infeasible_x, [1, 1, 1])
def setUp(self):
super().setUp()
random.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]))
op = QuadraticProgram()
for i in range(16):
op.binary_var()
self.result = OptimizationResult(
x=[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
fval=272,
variables=op.variables,
status=OptimizationResultStatus.SUCCESS,
)
def test_quadratic_program_to_qubo_inequality_to_penalty(self):
"""Test QuadraticProgramToQubo, passing inequality pattern"""
op = QuadraticProgram()
conv = QuadraticProgramToQubo()
op.binary_var(name="x")
op.binary_var(name="y")
# Linear constraints
linear_constraint = {"x": 1, "y": 1}
op.linear_constraint(linear_constraint, Constraint.Sense.GE, 1,
"P(1-x-y+xy)")
conv.penalty = 1
constant = 1
linear = {"x": -conv.penalty, "y": -conv.penalty}
quadratic = {("x", "y"): conv.penalty}
op2 = conv.convert(op)
cnst = op2.objective.constant
ldct = op2.objective.linear.to_dict(use_name=True)
qdct = op2.objective.quadratic.to_dict(use_name=True)
self.assertEqual(cnst, constant)
self.assertEqual(ldct, linear)
self.assertEqual(qdct, quadratic)
self.assertEqual(op2.get_num_linear_constraints(), 0)
def test_write_to_lp_file(self):
"""test write problem"""
q_p = QuadraticProgram("my problem")
q_p.binary_var("x")
q_p.integer_var(-1, 5, "y")
q_p.continuous_var(-1, 5, "z")
q_p.minimize(1, {"x": 1, "y": -1, "z": 10}, {("x", "x"): 0.5, ("y", "z"): -1})
q_p.linear_constraint({"x": 1, "y": 2}, "==", 1, "lin_eq")
q_p.linear_constraint({"x": 1, "y": 2}, "<=", 1, "lin_leq")
q_p.linear_constraint({"x": 1, "y": 2}, ">=", 1, "lin_geq")
q_p.quadratic_constraint(
{"x": 1, "y": 1},
{("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2},
"==",
1,
"quad_eq",
)
q_p.quadratic_constraint(
{"x": 1, "y": 1},
{("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2},
"<=",
1,
"quad_leq",
)
q_p.quadratic_constraint(
{"x": 1, "y": 1},
{("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2},
">=",
1,
"quad_geq",
)
reference_file_name = self.get_resource_path(
"test_quadratic_program.lp", "problems/resources"
)
with tempfile.TemporaryDirectory() as tmp:
temp_output_path = path.join(tmp, "temp.lp")
q_p.write_to_lp_file(temp_output_path)
with open(reference_file_name, encoding="utf8") as reference, open(
temp_output_path, encoding="utf8"
) as temp_output_file:
lines1 = temp_output_file.readlines()
lines2 = reference.readlines()
self.assertListEqual(lines1, lines2)
with tempfile.TemporaryDirectory() as temp_problem_dir:
q_p.write_to_lp_file(temp_problem_dir)
with open(path.join(temp_problem_dir, "my_problem.lp"), encoding="utf8") as file1, open(
reference_file_name, encoding="utf8"
) as file2:
lines1 = file1.readlines()
lines2 = file2.readlines()
self.assertListEqual(lines1, lines2)
with self.assertRaises(OSError):
q_p.write_to_lp_file("/cannot/write/this/file.lp")
with self.assertRaises(DOcplexException):
q_p.write_to_lp_file("")
def build_qubo_unconstrained_from_nodes(G, routes_dict):
all_edges_dict = get_edges_dict(routes_dict)
qubo = QuadraticProgram()
linear, quadratic = get_linear_quadratic_coeffs(G, all_edges_dict)
for var in routes_dict.keys():
qubo.binary_var(var)
qubo.minimize(linear=linear, quadratic=quadratic)
return qubo, linear, quadratic
def test_empty_name(self):
"""Test empty names"""
with self.subTest("problem name"):
q_p = QuadraticProgram("")
self.assertEqual(q_p.name, "")
with self.subTest("variable name"):
q_p = QuadraticProgram()
x = q_p.binary_var(name="")
y = q_p.integer_var(name="")
z = q_p.continuous_var(name="")
self.assertEqual(x.name, "x0")
self.assertEqual(y.name, "x1")
self.assertEqual(z.name, "x2")
with self.subTest("variable name 2"):
q_p = QuadraticProgram()
w = q_p.binary_var(name="w")
x = q_p.binary_var(name="")
y = q_p.integer_var(name="")
z = q_p.continuous_var(name="")
self.assertEqual(w.name, "w")
self.assertEqual(x.name, "x1")
self.assertEqual(y.name, "x2")
self.assertEqual(z.name, "x3")
with self.subTest("variable name list"):
q_p = QuadraticProgram()
x = q_p.binary_var_list(2, name="")
y = q_p.integer_var_list(2, name="")
z = q_p.continuous_var_list(2, name="")
self.assertListEqual([v.name for v in x], ["x0", "x1"])
self.assertListEqual([v.name for v in y], ["x2", "x3"])
self.assertListEqual([v.name for v in z], ["x4", "x5"])
with self.subTest("variable name dict"):
q_p = QuadraticProgram()
x = q_p.binary_var_dict(2, name="")
y = q_p.integer_var_dict(2, name="")
z = q_p.continuous_var_dict(2, name="")
self.assertDictEqual({k: v.name for k, v in x.items()}, {"x0": "x0", "x1": "x1"})
self.assertDictEqual({k: v.name for k, v in y.items()}, {"x2": "x2", "x3": "x3"})
self.assertDictEqual({k: v.name for k, v in z.items()}, {"x4": "x4", "x5": "x5"})
with self.subTest("linear constraint name"):
q_p = QuadraticProgram()
x = q_p.linear_constraint(name="")
y = q_p.linear_constraint(name="")
self.assertEqual(x.name, "c0")
self.assertEqual(y.name, "c1")
with self.subTest("quadratic constraint name"):
q_p = QuadraticProgram()
x = q_p.quadratic_constraint(name="")
y = q_p.quadratic_constraint(name="")
self.assertEqual(x.name, "q0")
self.assertEqual(y.name, "q1")
def setUp(self):
"""Set up for the test"""
super().setUp()
self.num_set = [8, 7, 6, 5, 4]
op = QuadraticProgram()
for _ in range(5):
op.binary_var()
self.result = OptimizationResult(
x=[1, 1, 0, 0, 0], fval=0, variables=op.variables,
status=OptimizationResultStatus.SUCCESS)
def setUp(self):
"""set up the test class"""
super().setUp()
self.graph = nx.gnm_random_graph(5, 4, 3)
op = QuadraticProgram()
for _ in range(5):
op.binary_var()
self.result = OptimizationResult(
x=[0, 0, 0, 0, 1], fval=1, variables=op.variables,
status=OptimizationResultStatus.SUCCESS)
def test_symmetric_set(self):
""" test symmetric set """
q_p = QuadraticProgram()
q_p.binary_var('x')
q_p.binary_var('y')
q_p.binary_var('z')
quad = QuadraticExpression(q_p, {('x', 'y'): -1, ('y', 'x'): 2, ('z', 'x'): 3})
self.assertDictEqual(quad.to_dict(use_name=True), {('x', 'y'): 1, ('x', 'z'): 3})
self.assertDictEqual(quad.to_dict(symmetric=True, use_name=True),
{('x', 'y'): 0.5, ('y', 'x'): 0.5, ('x', 'z'): 1.5, ('z', 'x'): 1.5})
def setUp(self):
super().setUp()
self.graph = nx.gnm_random_graph(5, 4, 3)
op = QuadraticProgram()
for _ in range(5):
op.binary_var()
self.result = OptimizationResult(
x=[1, 1, 1, 1, 0],
fval=4,
variables=op.variables,
status=OptimizationResultStatus.SUCCESS)
def test_linear_inequality_to_penalty7(self):
"""Test special constraint to penalty 6 x-y >= 0 -> P(y-x*y)"""
op = QuadraticProgram()
lip = LinearInequalityToPenalty()
op.binary_var(name="x")
op.binary_var(name="y")
# Linear constraints
linear_constraint = {"x": 1, "y": -1}
op.linear_constraint(linear_constraint, Constraint.Sense.GE, 0,
"P(y-xy)")
# Test with no max/min
with self.subTest("No max/min"):
self.assertEqual(op.get_num_linear_constraints(), 1)
penalty = 1
linear = {"y": penalty}
quadratic = {("x", "y"): -1 * penalty}
op2 = lip.convert(op)
ldct = op2.objective.linear.to_dict(use_name=True)
qdct = op2.objective.quadratic.to_dict(use_name=True)
self.assertEqual(ldct, linear)
self.assertEqual(qdct, quadratic)
self.assertEqual(op2.get_num_linear_constraints(), 0)
# Test maximize
with self.subTest("Maximize"):
linear = {"x": 2, "y": 1}
op.maximize(linear=linear)
penalty = 4
linear["y"] = linear["y"] - penalty
quadratic = {("x", "y"): penalty}
op2 = lip.convert(op)
ldct = op2.objective.linear.to_dict(use_name=True)
qdct = op2.objective.quadratic.to_dict(use_name=True)
self.assertEqual(ldct, linear)
self.assertEqual(qdct, quadratic)
self.assertEqual(op2.get_num_linear_constraints(), 0)
# Test minimize
with self.subTest("Minimize"):
linear = {"x": 2, "y": 1}
op.minimize(linear={"x": 2, "y": 1})
penalty = 4
linear["y"] = linear["y"] + penalty
quadratic = {("x", "y"): -1 * penalty}
op2 = lip.convert(op)
ldct = op2.objective.linear.to_dict(use_name=True)
qdct = op2.objective.quadratic.to_dict(use_name=True)
self.assertEqual(ldct, linear)
self.assertEqual(qdct, quadratic)
self.assertEqual(op2.get_num_linear_constraints(), 0)
def test_symmetric_set(self):
"""test symmetric set"""
q_p = QuadraticProgram()
q_p.binary_var("x")
q_p.binary_var("y")
q_p.binary_var("z")
quad = QuadraticExpression(q_p, {("x", "y"): -1, ("y", "x"): 2, ("z", "x"): 3})
self.assertDictEqual(quad.to_dict(use_name=True), {("x", "y"): 1, ("x", "z"): 3})
self.assertDictEqual(
quad.to_dict(symmetric=True, use_name=True),
{("x", "y"): 0.5, ("y", "x"): 0.5, ("x", "z"): 1.5, ("z", "x"): 1.5},
)
def setUp(self):
super().setUp()
self.total_set = [1, 2, 3, 4, 5]
self.list_of_subsets = [[1, 2, 3], [2, 3, 4], [4, 5], [1, 3], [2]]
op = QuadraticProgram()
for _ in range(5):
op.binary_var()
self.result = OptimizationResult(
x=[0, 0, 1, 1, 1],
fval=3,
variables=op.variables,
status=OptimizationResultStatus.SUCCESS)
def setUp(self):
"""Set up for the tests"""
super().setUp()
self.values = [10, 40, 30, 50]
self.weights = [5, 4, 6, 3]
self.max_weight = 10
op = QuadraticProgram()
for _ in range(4):
op.binary_var()
self.result = OptimizationResult(
x=[0, 1, 0, 1], fval=90, variables=op.variables,
status=OptimizationResultStatus.SUCCESS)
def setUp(self):
"""Set up for the tests"""
super().setUp()
self.graph = nx.gnm_random_graph(4, 4, 123)
op = QuadraticProgram()
for _ in range(4):
op.binary_var()
self.result = OptimizationResult(
x=[0, 1, 1, 0],
fval=2,
variables=op.variables,
status=OptimizationResultStatus.SUCCESS)
def setUp(self):
"""Set up for the tests"""
super().setUp()
self.total_set = [1, 2, 3, 4, 5]
self.list_of_subsets = [[1, 4], [2, 3, 4], [1, 5], [2, 3]]
op = QuadraticProgram()
for _ in range(4):
op.binary_var()
self.result = OptimizationResult(
x=[0, 1, 1, 0],
fval=2,
variables=op.variables,
status=OptimizationResultStatus.SUCCESS)
def test_linear_inequality_to_penalty4(self):
"""Test special constraint to penalty x1+x2+x3+... <= 1 -> P(x1*x2+x1*x3+...)"""
op = QuadraticProgram()
lip = LinearInequalityToPenalty()
op.binary_var(name="x")
op.binary_var(name="y")
op.binary_var(name="z")
# Linear constraints
linear_constraint = {"x": 1, "y": 1, "z": 1}
op.linear_constraint(linear_constraint, Constraint.Sense.LE, 1,
"P(xy+yz+zx)")
# Test with no max/min
with self.subTest("No max/min"):
self.assertEqual(op.get_num_linear_constraints(), 1)
penalty = 1
quadratic = {
("x", "y"): penalty,
("x", "z"): penalty,
("y", "z"): penalty
}
op2 = lip.convert(op)
qdct = op2.objective.quadratic.to_dict(use_name=True)
self.assertEqual(qdct, quadratic)
self.assertEqual(op2.get_num_linear_constraints(), 0)
# Test maximize
op = QuadraticProgram()
op.binary_var_list(5)
linear2 = [1, 1, 0, 0, 0]
op.maximize(linear=linear2)
op.linear_constraint([1, 1, 1, 1, 1], Constraint.Sense.LE, 1, "")
with self.subTest("Maximum"):
self.assertEqual(op.get_num_linear_constraints(), 1)
lip.penalty = 5
quadratic2 = [
[0, 1, 1, 1, 1],
[0, 0, 1, 1, 1],
[0, 0, 0, 1, 1],
[0, 0, 0, 0, 1],
[0, 0, 0, 0, 0],
]
op2 = lip.convert(op)
ldct2 = op2.objective.linear.to_array()
qdct2 = op2.objective.quadratic.to_array() / lip.penalty * -1
self.assertEqual(ldct2.tolist(), linear2)
self.assertEqual(qdct2.tolist(), quadratic2)
self.assertEqual(op2.get_num_linear_constraints(), 0)
def setUp(self):
"""Set up for the tests"""
super().setUp()
self.weights = [16, 9, 23]
self.max_weight = 40
self.max_number_of_bins = 2
op = QuadraticProgram()
for _ in range(12):
op.binary_var()
self.result = OptimizationResult(
x=[1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1],
fval=2.0,
variables=op.variables,
status=OptimizationResultStatus.SUCCESS,
)
def qaoa(G):
n = G.numberOfNodes()
G = nw.nxadapter.nk2nx(G)
w = nx.adjacency_matrix(G)
problem = QuadraticProgram()
_ = [problem.binary_var(f"x{i}") for i in range(n)]
linear = w.dot(np.ones(n))
quadratic = -w
problem.maximize(linear=linear, quadratic=quadratic)
c = [1]
for _ in range(n - 1):
c.append(0)
problem.linear_constraint(c, '==', 1)
cobyla = COBYLA()
backend = BasicAer.get_backend('qasm_simulator')
qaoa = QAOA(optimizer=cobyla, reps=3, quantum_instance=backend)
algorithm = MinimumEigenOptimizer(qaoa)
result = algorithm.solve(problem)
L = result.x
i = 0
res = {}
for x in L:
res[i] = x
i += 1
return res
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_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 = {"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, "x2": 3}
op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, "x0x2")
self.assertEqual(op.get_num_linear_constraints(), 3)
conv = LinearEqualityToPenalty()
with self.assertRaises(QiskitOptimizationError):
conv.convert(op)
def test_0var_range_inequality(self):
""" Test InequalityToEquality converter when the var_rang of the slack variable is 0"""
op = QuadraticProgram()
op.binary_var('x')
op.binary_var('y')
op.linear_constraint(linear={'x': 1, 'y': 1}, sense='LE', rhs=0, name='xy_leq1')
op.linear_constraint(linear={'x': 1, 'y': 1}, sense='GE', rhs=2, name='xy_geq1')
op.quadratic_constraint(quadratic={('x', 'x'): 1}, sense='LE', rhs=0, name='xy_leq2')
op.quadratic_constraint(quadratic={('x', 'y'): 1}, sense='GE', rhs=1, name='xy_geq2')
ineq2eq = InequalityToEquality()
new_op = ineq2eq.convert(op)
self.assertEqual(new_op.get_num_vars(), 2)
self.assertTrue(all(l_const.sense == Constraint.Sense.EQ
for l_const in new_op.linear_constraints))
self.assertTrue(all(q_const.sense == Constraint.Sense.EQ
for q_const in new_op.quadratic_constraints))
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_inequality_mode_integer(self):
"""Test integer mode of InequalityToEqualityConverter()"""
op = QuadraticProgram()
for i in range(3):
op.binary_var(name=f"x{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, "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_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 = {"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, "x2": 3}
op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, "x0x2")
conv = InequalityToEquality(mode="continuous")
op2 = conv.convert(op)
lst = [op2.variables[3].vartype, op2.variables[4].vartype]
self.assertListEqual(
lst, [Variable.Type.CONTINUOUS, Variable.Type.CONTINUOUS])
