def test_str_repr(self):
"""Test str and repr"""
with self.subTest("5 variables"):
n = 5
quadratic_program = QuadraticProgram()
quadratic_program.binary_var_list(n) # x0,...,x4
expr = LinearExpression(quadratic_program,
[float(e) for e in range(n)])
self.assertEqual(str(expr), "x1 + 2*x2 + 3*x3 + 4*x4")
self.assertEqual(repr(expr),
"<LinearExpression: x1 + 2*x2 + 3*x3 + 4*x4>")
with self.subTest("50 variables"):
# pylint: disable=cyclic-import
from qiskit_optimization.translators.prettyprint import DEFAULT_TRUNCATE
n = 50
quadratic_program = QuadraticProgram()
quadratic_program.binary_var_list(n) # x0,...,x49
expr = LinearExpression(quadratic_program,
[float(e) for e in range(n)])
expected = " ".join(["x1"] +
sorted([f"+ {i}*x{i}" for i in range(2, n)],
key=lambda e: e.split(" ")[1]))
self.assertEqual(str(expr), expected)
self.assertEqual(
repr(expr),
f"<LinearExpression: {expected[:DEFAULT_TRUNCATE]}...>")
def test_linear_inequality_to_penalty3(self):
"""Test special constraint to penalty x1+x2+x3+... >= n-1 -> P(x1*x2+x1*x3+...)"""
op = QuadraticProgram()
lip = LinearInequalityToPenalty()
op.binary_var_list(5)
# Linear constraints
n = 5
op.linear_constraint([1, 1, 1, 1, 1], Constraint.Sense.GE, n - 1, "")
# Test with no max/min
with self.subTest("No max/min"):
self.assertEqual(op.get_num_linear_constraints(), 1)
penalty = 5
lip.penalty = penalty
constant = 10
linear = [n - 1, n - 1, n - 1, n - 1, n - 1]
quadratic = [
[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)
cnst2 = op2.objective.constant / penalty
ldct2 = op2.objective.linear.to_array() / penalty * -1
qdct2 = op2.objective.quadratic.to_array() / penalty
self.assertEqual(cnst2, constant)
self.assertEqual(ldct2.tolist(), linear)
self.assertEqual(qdct2.tolist(), quadratic)
self.assertEqual(op2.get_num_linear_constraints(), 0)
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 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 test_printable_name(self):
"""Test non-printable names"""
name = "\n"
with self.assertWarns(UserWarning):
_ = QuadraticProgram(name)
q_p = QuadraticProgram()
with self.assertWarns(UserWarning):
q_p.binary_var(name + "bin")
with self.assertWarns(UserWarning):
q_p.binary_var_list(10, name)
with self.assertWarns(UserWarning):
q_p.binary_var_dict(10, name)
with self.assertWarns(UserWarning):
q_p.integer_var(0, 1, name + "int")
with self.assertWarns(UserWarning):
q_p.integer_var_list(10, 0, 1, name)
with self.assertWarns(UserWarning):
q_p.integer_var_dict(10, 0, 1, name)
with self.assertWarns(UserWarning):
q_p.continuous_var(0, 1, name + "cont")
with self.assertWarns(UserWarning):
q_p.continuous_var_list(10, 0, 1, name)
with self.assertWarns(UserWarning):
q_p.continuous_var_dict(10, 0, 1, name)
with self.assertWarns(UserWarning):
q_p.linear_constraint(name=name)
with self.assertWarns(UserWarning):
q_p.quadratic_constraint(name=name)
def test_str_repr(self):
"""Test str and repr"""
with self.subTest("5 variables"):
n = 5
q_p = QuadraticProgram()
q_p.binary_var_list(n) # x0,...,x4
expr = QuadraticExpression(q_p, {(i, i): float(i) for i in range(n)})
self.assertEqual(str(expr), "x1^2 + 2*x2^2 + 3*x3^2 + 4*x4^2")
self.assertEqual(repr(expr), "<QuadraticExpression: x1^2 + 2*x2^2 + 3*x3^2 + 4*x4^2>")
expr = QuadraticExpression(q_p, {(i, (i + 1) % n): float(i) for i in range(n)})
self.assertEqual(str(expr), "4*x0*x4 + x1*x2 + 2*x2*x3 + 3*x3*x4")
self.assertEqual(
repr(expr), "<QuadraticExpression: 4*x0*x4 + x1*x2 + 2*x2*x3 + 3*x3*x4>"
)
with self.subTest("50 variables"):
# pylint: disable=cyclic-import
from qiskit_optimization.translators.prettyprint import DEFAULT_TRUNCATE
n = 50
q_p = QuadraticProgram()
q_p.binary_var_list(n) # x0,...,x49
expr = QuadraticExpression(q_p, {(i, i): float(i) for i in range(n)})
expected = " ".join(
["x1^2"]
+ sorted([f"+ {i}*x{i}^2" for i in range(2, n)], key=lambda e: e.split(" ")[1])
)
self.assertEqual(str(expr), expected)
self.assertEqual(repr(expr), f"<QuadraticExpression: {expected[:DEFAULT_TRUNCATE]}...>")
expr = QuadraticExpression(q_p, {(i, (i + 1) % n): float(i) for i in range(n)})
expected = " ".join(
[f"{n-1}*x0*x{n-1}", "+ x1*x2"]
+ sorted(
[f"+ {i}*x{i}*x{i + 1}" for i in range(2, n - 1)], key=lambda e: e.split(" ")[1]
)
)
self.assertEqual(str(expr), expected)
self.assertEqual(repr(expr), f"<QuadraticExpression: {expected[:DEFAULT_TRUNCATE]}...>")
def test_empty_objective(self):
"""test empty objective"""
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(3)
_ = q_p.objective.evaluate([0, 0, 0])
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(3)
_ = q_p.objective.evaluate_gradient([0, 0, 0])
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(3)
_ = q_p.objective.evaluate({})
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(3)
_ = q_p.objective.evaluate_gradient({})
def test_var_list(self):
"""test {binary,integer,continuous}_var_list"""
q_p = QuadraticProgram()
c_count = 0
b_count = 0
i_count = 0
def verify_counts():
self.assertEqual(q_p.get_num_vars(), c_count + b_count + i_count)
self.assertEqual(q_p.get_num_continuous_vars(), c_count)
self.assertEqual(q_p.get_num_binary_vars(), b_count)
self.assertEqual(q_p.get_num_integer_vars(), i_count)
def check_list(var_list, offset):
verify_counts()
for i, x in enumerate(var_list):
y = q_p.get_variable(i + offset)
z = q_p.get_variable(x.name)
self.assert_equal(x, y)
self.assert_equal(x, z)
d_0 = q_p.continuous_var_list(name='a', key_format='_{}', keys=3)
c_count += 3
check_list(d_0, 0)
d_1 = q_p.binary_var_list(name='b', keys=5)
b_count += 5
check_list(d_1, len(d_0))
d_2 = q_p.integer_var_list(key_format='_{}',
keys=7,
lowerbound=-4,
upperbound=10)
i_count += 7
check_list(d_2, len(d_0) + len(d_1))
d_3 = q_p.continuous_var_list(name='a', key_format='_{}', keys=3)
c_count += 3
check_list(d_3, len(d_0) + len(d_1) + len(d_2))
d_4 = q_p.continuous_var_list(name='c', keys=range(3))
c_count += 3
check_list(d_4, len(d_0) + len(d_1) + len(d_2) + len(d_3))
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var_list(name='c0')
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var_list(name='c', keys=range(3))
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(key_format='{}{}')
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=0)
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(name='a')
q_p.binary_var_list(name='a')
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(key_format='_{{}}')
def test_var_list(self):
"""test {binary,integer,continuous}_var_list"""
q_p = QuadraticProgram()
d_0 = q_p.continuous_var_list(name="a", key_format="_{}", keys=3)
names = ["a_0", "a_1", "a_2"]
self.assertSetEqual({var.name
for var in q_p.variables}, {"a_0", "a_1", "a_2"})
for i, var in enumerate(q_p.variables):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, 0)
self.assertAlmostEqual(var.upperbound, INFINITY)
self.assertEqual(var.vartype, VarType.CONTINUOUS)
self.assertTupleEqual(var.as_tuple(), d_0[i].as_tuple())
d_1 = q_p.binary_var_list(name="b", keys=5)
names = ["b3", "b4", "b5", "b6", "b7"]
self.assertSetEqual(
{var.name
for var in q_p.variables},
{"a_0", "a_1", "a_2", "b3", "b4", "b5", "b6", "b7"},
)
for i, var in enumerate(q_p.variables[-5:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, 0)
self.assertAlmostEqual(var.upperbound, 1)
self.assertEqual(var.vartype, VarType.BINARY)
self.assertTupleEqual(var.as_tuple(), d_1[i].as_tuple())
d_2 = q_p.integer_var_list(keys=1,
key_format="-{}",
lowerbound=-4,
upperbound=10)
names = ["x-8"]
self.assertSetEqual(
{var.name
for var in q_p.variables},
{"a_0", "a_1", "a_2", "b3", "b4", "b5", "b6", "b7", "x-8"},
)
for i, var in enumerate(q_p.variables[-1:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, -4)
self.assertAlmostEqual(var.upperbound, 10)
self.assertEqual(var.vartype, VarType.INTEGER)
self.assertTupleEqual(var.as_tuple(), d_2[i].as_tuple())
d_3 = q_p.binary_var_list(name="c", keys=range(3))
names = ["c0", "c1", "c2"]
self.assertSetEqual(
{var.name
for var in q_p.variables},
{
"a_0",
"a_1",
"a_2",
"b3",
"b4",
"b5",
"b6",
"b7",
"x-8",
"c0",
"c1",
"c2",
},
)
for i, var in enumerate(q_p.variables[-3:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, 0)
self.assertAlmostEqual(var.upperbound, 1)
self.assertEqual(var.vartype, VarType.BINARY)
self.assertTupleEqual(var.as_tuple(), d_3[i].as_tuple())
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var_list(name="c", keys=range(3))
d_4 = q_p.binary_var_dict(1, "x", "_")
names = ["x_"]
self.assertSetEqual(
{var.name
for var in q_p.variables},
{
"a_0",
"a_1",
"a_2",
"b3",
"b4",
"b5",
"b6",
"b7",
"x-8",
"c0",
"c1",
"c2",
"x_",
},
)
for i, var in enumerate(q_p.variables[-1:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, 0)
self.assertAlmostEqual(var.upperbound, 1)
self.assertEqual(var.vartype, VarType.BINARY)
self.assertTupleEqual(var.as_tuple(), d_4[var.name].as_tuple())
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var_list(1, "x", "_")
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var("x_")
d_5 = q_p.integer_var_list(1, -1, 2, "", "")
names = [""]
self.assertSetEqual(
{var.name
for var in q_p.variables},
{
"a_0",
"a_1",
"a_2",
"b3",
"b4",
"b5",
"b6",
"b7",
"x-8",
"c0",
"c1",
"c2",
"x_",
"",
},
)
for i, var in enumerate(q_p.variables[-1:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, -1)
self.assertAlmostEqual(var.upperbound, 2)
self.assertEqual(var.vartype, VarType.INTEGER)
self.assertTupleEqual(var.as_tuple(), d_5[i].as_tuple())
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var_list(1, "", "")
with self.assertRaises(QiskitOptimizationError):
q_p.integer_var(0, 1, "")
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=1, key_format="{}{}")
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=0)
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=1, key_format="_{{}}")
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=2, key_format="")
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=range(2), key_format="")
class TestLinearConstraint(QiskitOptimizationTestCase):
"""Test LinearConstraint."""
def setUp(self) -> None:
super().setUp()
self.quadratic_program = QuadraticProgram()
self.quadratic_program.binary_var_list(3, name="x")
self.quadratic_program.linear_constraint({"x0": 1, "x1": -2}, "<=", 1)
self.quadratic_program.linear_constraint({"x0": 1, "x1": -2}, "<", 1)
self.quadratic_program.linear_constraint({"x0": 1, "x1": -2}, "LE", 1)
self.quadratic_program.linear_constraint({"x0": 1, "x1": -2}, "L", 1)
self.quadratic_program.linear_constraint({"x0": -1, "x1": 2}, "==", 2)
self.quadratic_program.linear_constraint({"x0": -1, "x1": 2}, "=", 2)
self.quadratic_program.linear_constraint({"x0": -1, "x1": 2}, "EQ", 2)
self.quadratic_program.linear_constraint({"x0": -1, "x1": 2}, "E", 2)
self.quadratic_program.linear_constraint({"x1": 2, "x2": -1}, ">=", 3)
self.quadratic_program.linear_constraint({"x1": 2, "x2": -1}, ">", 3)
self.quadratic_program.linear_constraint({"x1": 2, "x2": -1}, "GE", 3)
self.quadratic_program.linear_constraint({"x1": 2, "x2": -1}, "G", 3)
def test_init(self):
"""test init."""
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
self.assertEqual(quadratic_program.get_num_linear_constraints(), 0)
coefficients = np.array(range(5))
# equality constraints
quadratic_program.linear_constraint(sense="==")
self.assertEqual(quadratic_program.get_num_linear_constraints(), 1)
self.assertEqual(quadratic_program.linear_constraints[0].name, "c0")
self.assertEqual(
len(quadratic_program.linear_constraints[0].linear.to_dict()), 0)
self.assertEqual(quadratic_program.linear_constraints[0].sense,
Constraint.Sense.EQ)
self.assertEqual(quadratic_program.linear_constraints[0].rhs, 0.0)
self.assertEqual(
quadratic_program.linear_constraints[0],
quadratic_program.get_linear_constraint("c0"),
)
self.assertEqual(
quadratic_program.linear_constraints[0],
quadratic_program.get_linear_constraint(0),
)
with self.assertRaises(QiskitOptimizationError):
quadratic_program.linear_constraint(name="c0")
quadratic_program.linear_constraint(coefficients, "==", 1.0, "c1")
self.assertEqual(quadratic_program.get_num_linear_constraints(), 2)
self.assertEqual(quadratic_program.linear_constraints[1].name, "c1")
self.assertTrue(
(quadratic_program.linear_constraints[1].linear.to_array() ==
coefficients).all())
self.assertEqual(quadratic_program.linear_constraints[1].sense,
Constraint.Sense.EQ)
self.assertEqual(quadratic_program.linear_constraints[1].rhs, 1.0)
self.assertEqual(
quadratic_program.linear_constraints[1],
quadratic_program.get_linear_constraint("c1"),
)
self.assertEqual(
quadratic_program.linear_constraints[1],
quadratic_program.get_linear_constraint(1),
)
# geq constraints
quadratic_program.linear_constraint(sense=">=")
self.assertEqual(quadratic_program.get_num_linear_constraints(), 3)
self.assertEqual(quadratic_program.linear_constraints[2].name, "c2")
self.assertEqual(
len(quadratic_program.linear_constraints[2].linear.to_dict()), 0)
self.assertEqual(quadratic_program.linear_constraints[2].sense,
Constraint.Sense.GE)
self.assertEqual(quadratic_program.linear_constraints[2].rhs, 0.0)
self.assertEqual(
quadratic_program.linear_constraints[2],
quadratic_program.get_linear_constraint("c2"),
)
self.assertEqual(
quadratic_program.linear_constraints[2],
quadratic_program.get_linear_constraint(2),
)
with self.assertRaises(QiskitOptimizationError):
quadratic_program.linear_constraint(name="c2", sense=">=")
quadratic_program.linear_constraint(coefficients, ">=", 1.0, "c3")
self.assertEqual(quadratic_program.get_num_linear_constraints(), 4)
self.assertEqual(quadratic_program.linear_constraints[3].name, "c3")
self.assertTrue(
(quadratic_program.linear_constraints[3].linear.to_array() ==
coefficients).all())
self.assertEqual(quadratic_program.linear_constraints[3].sense,
Constraint.Sense.GE)
self.assertEqual(quadratic_program.linear_constraints[3].rhs, 1.0)
self.assertEqual(
quadratic_program.linear_constraints[3],
quadratic_program.get_linear_constraint("c3"),
)
self.assertEqual(
quadratic_program.linear_constraints[3],
quadratic_program.get_linear_constraint(3),
)
# leq constraints
quadratic_program.linear_constraint(sense="<=")
self.assertEqual(quadratic_program.get_num_linear_constraints(), 5)
self.assertEqual(quadratic_program.linear_constraints[4].name, "c4")
self.assertEqual(
len(quadratic_program.linear_constraints[4].linear.to_dict()), 0)
self.assertEqual(quadratic_program.linear_constraints[4].sense,
Constraint.Sense.LE)
self.assertEqual(quadratic_program.linear_constraints[4].rhs, 0.0)
self.assertEqual(
quadratic_program.linear_constraints[4],
quadratic_program.get_linear_constraint("c4"),
)
self.assertEqual(
quadratic_program.linear_constraints[4],
quadratic_program.get_linear_constraint(4),
)
with self.assertRaises(QiskitOptimizationError):
quadratic_program.linear_constraint(name="c4", sense="<=")
quadratic_program.linear_constraint(coefficients, "<=", 1.0, "c5")
self.assertEqual(quadratic_program.get_num_linear_constraints(), 6)
self.assertEqual(quadratic_program.linear_constraints[5].name, "c5")
self.assertTrue(
(quadratic_program.linear_constraints[5].linear.to_array() ==
coefficients).all())
self.assertEqual(quadratic_program.linear_constraints[5].sense,
Constraint.Sense.LE)
self.assertEqual(quadratic_program.linear_constraints[5].rhs, 1.0)
self.assertEqual(
quadratic_program.linear_constraints[5],
quadratic_program.get_linear_constraint("c5"),
)
self.assertEqual(
quadratic_program.linear_constraints[5],
quadratic_program.get_linear_constraint(5),
)
def test_str(self):
"""Test str"""
self.assertEqual(self.quadratic_program.get_num_linear_constraints(),
12)
for i in range(0, 4):
self.assertEqual(
str(self.quadratic_program.get_linear_constraint(i)),
f"x0 - 2*x1 <= 1 'c{i}'")
for i in range(4, 8):
self.assertEqual(
str(self.quadratic_program.get_linear_constraint(i)),
f"-x0 + 2*x1 == 2 'c{i}'")
for i in range(8, 12):
self.assertEqual(
str(self.quadratic_program.get_linear_constraint(i)),
f"2*x1 - x2 >= 3 'c{i}'")
def test_repr(self):
"""Test repr"""
self.assertEqual(self.quadratic_program.get_num_linear_constraints(),
12)
for i in range(0, 4):
self.assertEqual(
repr(self.quadratic_program.get_linear_constraint(i)),
f"<LinearConstraint: x0 - 2*x1 <= 1 'c{i}'>",
)
for i in range(4, 8):
self.assertEqual(
repr(self.quadratic_program.get_linear_constraint(i)),
f"<LinearConstraint: -x0 + 2*x1 == 2 'c{i}'>",
)
for i in range(8, 12):
self.assertEqual(
repr(self.quadratic_program.get_linear_constraint(i)),
f"<LinearConstraint: 2*x1 - x2 >= 3 'c{i}'>",
)
def test_var_list(self):
"""test {binary,integer,continuous}_var_list"""
q_p = QuadraticProgram()
d_0 = q_p.continuous_var_list(name='a', key_format='_{}', keys=3)
names = ['a_0', 'a_1', 'a_2']
self.assertSetEqual({var.name
for var in q_p.variables}, {'a_0', 'a_1', 'a_2'})
for i, var in enumerate(q_p.variables):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, 0)
self.assertAlmostEqual(var.upperbound, INFINITY)
self.assertEqual(var.vartype, VarType.CONTINUOUS)
self.assertTupleEqual(var.as_tuple(), d_0[i].as_tuple())
d_1 = q_p.binary_var_list(name='b', keys=5)
names = ['b3', 'b4', 'b5', 'b6', 'b7']
self.assertSetEqual(
{var.name
for var in q_p.variables},
{'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6', 'b7'})
for i, var in enumerate(q_p.variables[-5:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, 0)
self.assertAlmostEqual(var.upperbound, 1)
self.assertEqual(var.vartype, VarType.BINARY)
self.assertTupleEqual(var.as_tuple(), d_1[i].as_tuple())
d_2 = q_p.integer_var_list(keys=1,
key_format='-{}',
lowerbound=-4,
upperbound=10)
names = ['x-8']
self.assertSetEqual(
{var.name
for var in q_p.variables},
{'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6', 'b7', 'x-8'})
for i, var in enumerate(q_p.variables[-1:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, -4)
self.assertAlmostEqual(var.upperbound, 10)
self.assertEqual(var.vartype, VarType.INTEGER)
self.assertTupleEqual(var.as_tuple(), d_2[i].as_tuple())
d_3 = q_p.binary_var_list(name='c', keys=range(3))
names = ['c0', 'c1', 'c2']
self.assertSetEqual({var.name
for var in q_p.variables}, {
'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6',
'b7', 'x-8', 'c0', 'c1', 'c2'
})
for i, var in enumerate(q_p.variables[-3:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, 0)
self.assertAlmostEqual(var.upperbound, 1)
self.assertEqual(var.vartype, VarType.BINARY)
self.assertTupleEqual(var.as_tuple(), d_3[i].as_tuple())
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var_list(name='c', keys=range(3))
d_4 = q_p.binary_var_dict(1, 'x', '_')
names = ['x_']
self.assertSetEqual({var.name
for var in q_p.variables}, {
'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6',
'b7', 'x-8', 'c0', 'c1', 'c2', 'x_'
})
for i, var in enumerate(q_p.variables[-1:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, 0)
self.assertAlmostEqual(var.upperbound, 1)
self.assertEqual(var.vartype, VarType.BINARY)
self.assertTupleEqual(var.as_tuple(), d_4[var.name].as_tuple())
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var_list(1, 'x', '_')
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var('x_')
d_5 = q_p.integer_var_list(1, -1, 2, '', '')
names = ['']
self.assertSetEqual({var.name
for var in q_p.variables}, {
'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6',
'b7', 'x-8', 'c0', 'c1', 'c2', 'x_', ''
})
for i, var in enumerate(q_p.variables[-1:]):
self.assertEqual(var.name, names[i])
self.assertAlmostEqual(var.lowerbound, -1)
self.assertAlmostEqual(var.upperbound, 2)
self.assertEqual(var.vartype, VarType.INTEGER)
self.assertTupleEqual(var.as_tuple(), d_5[i].as_tuple())
with self.assertRaises(QiskitOptimizationError):
q_p.binary_var_list(1, '', '')
with self.assertRaises(QiskitOptimizationError):
q_p.integer_var(0, 1, '')
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=1, key_format='{}{}')
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=0)
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=1, key_format='_{{}}')
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=2, key_format='')
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.binary_var_list(keys=range(2), key_format='')
class TestQuadraticConstraint(QiskitOptimizationTestCase):
"""Test QuadraticConstraint."""
def setUp(self) -> None:
super().setUp()
self.quadratic_program = QuadraticProgram()
self.quadratic_program.binary_var_list(3, name="x")
self.quadratic_program.quadratic_constraint({
"x0": 1,
"x1": -2
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "<=", 1)
self.quadratic_program.quadratic_constraint({
"x0": 1,
"x1": -2
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "<", 1)
self.quadratic_program.quadratic_constraint({
"x0": 1,
"x1": -2
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "LE", 1)
self.quadratic_program.quadratic_constraint({
"x0": 1,
"x1": -2
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "L", 1)
self.quadratic_program.quadratic_constraint({
"x0": -1,
"x1": 2
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "==", 2)
self.quadratic_program.quadratic_constraint({
"x0": -1,
"x1": 2
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "=", 2)
self.quadratic_program.quadratic_constraint({
"x0": -1,
"x1": 2
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "EQ", 2)
self.quadratic_program.quadratic_constraint({
"x0": -1,
"x1": 2
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "E", 2)
self.quadratic_program.quadratic_constraint({
"x1": 2,
"x2": -1
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, ">=", 3)
self.quadratic_program.quadratic_constraint({
"x1": 2,
"x2": -1
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, ">", 3)
self.quadratic_program.quadratic_constraint({
"x1": 2,
"x2": -1
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "GE", 3)
self.quadratic_program.quadratic_constraint({
"x1": 2,
"x2": -1
}, {
("x0", "x0"): -1,
("x2", "x1"): 2
}, "G", 3)
def test_init(self):
"""test init."""
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 0)
linear_coeffs = np.array(range(5))
lst = [[0 for _ in range(5)] for _ in range(5)]
for i, v in enumerate(lst):
for j, _ in enumerate(v):
lst[min(i, j)][max(i, j)] += i * j
quadratic_coeffs = np.array(lst)
# equality constraints
quadratic_program.quadratic_constraint(sense="==")
self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 1)
self.assertEqual(quadratic_program.quadratic_constraints[0].name, "q0")
self.assertEqual(
len(quadratic_program.quadratic_constraints[0].linear.to_dict()),
0)
self.assertEqual(
len(quadratic_program.quadratic_constraints[0].quadratic.to_dict()
), 0)
self.assertEqual(quadratic_program.quadratic_constraints[0].sense,
Constraint.Sense.EQ)
self.assertEqual(quadratic_program.quadratic_constraints[0].rhs, 0.0)
self.assertEqual(
quadratic_program.quadratic_constraints[0],
quadratic_program.get_quadratic_constraint("q0"),
)
self.assertEqual(
quadratic_program.quadratic_constraints[0],
quadratic_program.get_quadratic_constraint(0),
)
self.assertEqual(
quadratic_program.quadratic_constraints[0].evaluate(linear_coeffs),
0.0)
with self.assertRaises(QiskitOptimizationError):
quadratic_program.quadratic_constraint(name="q0", sense="==")
quadratic_program.quadratic_constraint(linear_coeffs, quadratic_coeffs,
"==", 1.0, "q1")
self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 2)
self.assertEqual(quadratic_program.quadratic_constraints[1].name, "q1")
self.assertTrue(
(quadratic_program.quadratic_constraints[1].linear.to_array() ==
linear_coeffs).all())
self.assertTrue(
(quadratic_program.quadratic_constraints[1].quadratic.to_array() ==
quadratic_coeffs).all())
self.assertEqual(quadratic_program.quadratic_constraints[1].sense,
Constraint.Sense.EQ)
self.assertEqual(quadratic_program.quadratic_constraints[1].rhs, 1.0)
self.assertEqual(
quadratic_program.quadratic_constraints[1],
quadratic_program.get_quadratic_constraint("q1"),
)
self.assertEqual(
quadratic_program.quadratic_constraints[1],
quadratic_program.get_quadratic_constraint(1),
)
self.assertEqual(
quadratic_program.quadratic_constraints[1].evaluate(linear_coeffs),
930.0)
# geq constraints
quadratic_program.quadratic_constraint(sense=">=")
self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 3)
self.assertEqual(quadratic_program.quadratic_constraints[2].name, "q2")
self.assertEqual(
len(quadratic_program.quadratic_constraints[2].linear.to_dict()),
0)
self.assertEqual(
len(quadratic_program.quadratic_constraints[2].quadratic.to_dict()
), 0)
self.assertEqual(quadratic_program.quadratic_constraints[2].sense,
Constraint.Sense.GE)
self.assertEqual(quadratic_program.quadratic_constraints[2].rhs, 0.0)
self.assertEqual(
quadratic_program.quadratic_constraints[2],
quadratic_program.get_quadratic_constraint("q2"),
)
self.assertEqual(
quadratic_program.quadratic_constraints[2],
quadratic_program.get_quadratic_constraint(2),
)
self.assertEqual(
quadratic_program.quadratic_constraints[2].evaluate(linear_coeffs),
0.0)
with self.assertRaises(QiskitOptimizationError):
quadratic_program.quadratic_constraint(name="q2", sense=">=")
quadratic_program.quadratic_constraint(linear_coeffs, quadratic_coeffs,
">=", 1.0, "q3")
self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 4)
self.assertEqual(quadratic_program.quadratic_constraints[3].name, "q3")
self.assertTrue(
(quadratic_program.quadratic_constraints[3].linear.to_array() ==
linear_coeffs).all())
self.assertTrue(
(quadratic_program.quadratic_constraints[3].quadratic.to_array() ==
quadratic_coeffs).all())
self.assertEqual(quadratic_program.quadratic_constraints[3].sense,
Constraint.Sense.GE)
self.assertEqual(quadratic_program.quadratic_constraints[3].rhs, 1.0)
self.assertEqual(
quadratic_program.quadratic_constraints[3],
quadratic_program.get_quadratic_constraint("q3"),
)
self.assertEqual(
quadratic_program.quadratic_constraints[3],
quadratic_program.get_quadratic_constraint(3),
)
self.assertEqual(
quadratic_program.quadratic_constraints[3].evaluate(linear_coeffs),
930.0)
# leq constraints
quadratic_program.quadratic_constraint(sense="<=")
self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 5)
self.assertEqual(quadratic_program.quadratic_constraints[4].name, "q4")
self.assertEqual(
len(quadratic_program.quadratic_constraints[4].linear.to_dict()),
0)
self.assertEqual(quadratic_program.quadratic_constraints[4].sense,
Constraint.Sense.LE)
self.assertEqual(quadratic_program.quadratic_constraints[4].rhs, 0.0)
self.assertEqual(
quadratic_program.quadratic_constraints[4],
quadratic_program.get_quadratic_constraint("q4"),
)
self.assertEqual(
quadratic_program.quadratic_constraints[4],
quadratic_program.get_quadratic_constraint(4),
)
self.assertEqual(
quadratic_program.quadratic_constraints[4].evaluate(linear_coeffs),
0.0)
with self.assertRaises(QiskitOptimizationError):
quadratic_program.quadratic_constraint(name="q4", sense="<=")
quadratic_program.quadratic_constraint(linear_coeffs, quadratic_coeffs,
"<=", 1.0, "q5")
self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 6)
self.assertEqual(quadratic_program.quadratic_constraints[5].name, "q5")
self.assertTrue(
(quadratic_program.quadratic_constraints[5].linear.to_array() ==
linear_coeffs).all())
self.assertTrue(
(quadratic_program.quadratic_constraints[5].quadratic.to_array() ==
quadratic_coeffs).all())
self.assertEqual(quadratic_program.quadratic_constraints[5].sense,
Constraint.Sense.LE)
self.assertEqual(quadratic_program.quadratic_constraints[5].rhs, 1.0)
self.assertEqual(
quadratic_program.quadratic_constraints[5],
quadratic_program.get_quadratic_constraint("q5"),
)
self.assertEqual(
quadratic_program.quadratic_constraints[5],
quadratic_program.get_quadratic_constraint(5),
)
self.assertEqual(
quadratic_program.quadratic_constraints[5].evaluate(linear_coeffs),
930.0)
def test_str(self):
"""Test str"""
self.assertEqual(
self.quadratic_program.get_num_quadratic_constraints(), 12)
for i in range(0, 4):
self.assertEqual(
str(self.quadratic_program.get_quadratic_constraint(i)),
f"-x0^2 + 2*x1*x2 + x0 - 2*x1 <= 1 'q{i}'",
)
for i in range(4, 8):
self.assertEqual(
str(self.quadratic_program.get_quadratic_constraint(i)),
f"-x0^2 + 2*x1*x2 - x0 + 2*x1 == 2 'q{i}'",
)
for i in range(8, 12):
self.assertEqual(
str(self.quadratic_program.get_quadratic_constraint(i)),
f"-x0^2 + 2*x1*x2 + 2*x1 - x2 >= 3 'q{i}'",
)
def test_repr(self):
"""Test repr"""
self.assertEqual(
self.quadratic_program.get_num_quadratic_constraints(), 12)
for i in range(0, 4):
self.assertEqual(
repr(self.quadratic_program.get_quadratic_constraint(i)),
f"<QuadraticConstraint: -x0^2 + 2*x1*x2 + x0 - 2*x1 <= 1 'q{i}'>",
)
for i in range(4, 8):
self.assertEqual(
repr(self.quadratic_program.get_quadratic_constraint(i)),
f"<QuadraticConstraint: -x0^2 + 2*x1*x2 - x0 + 2*x1 == 2 'q{i}'>",
)
for i in range(8, 12):
self.assertEqual(
repr(self.quadratic_program.get_quadratic_constraint(i)),
f"<QuadraticConstraint: -x0^2 + 2*x1*x2 + 2*x1 - x2 >= 3 'q{i}'>",
)
