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_quadratic_constraints_handling(self):
"""test quadratic constraints handling"""
q_p = QuadraticProgram()
q_p.binary_var("x")
q_p.binary_var("y")
q_p.binary_var("z")
q_p.quadratic_constraint({"x": 1}, {("x", "y"): 1}, "==", 1)
q_p.quadratic_constraint({"y": 1}, {("y", "z"): 1}, "<=", 1)
q_p.quadratic_constraint({"z": 1}, {("z", "x"): 1}, ">=", 1)
self.assertEqual(q_p.get_num_quadratic_constraints(), 3)
quad = q_p.quadratic_constraints
self.assertEqual(len(quad), 3)
self.assertDictEqual(quad[0].linear.to_dict(), {0: 1})
self.assertDictEqual(quad[0].linear.to_dict(use_name=True), {"x": 1})
self.assertListEqual(quad[0].linear.to_array().tolist(), [1, 0, 0])
self.assertDictEqual(quad[0].quadratic.to_dict(), {(0, 1): 1})
self.assertDictEqual(quad[0].quadratic.to_dict(symmetric=True), {
(0, 1): 0.5,
(1, 0): 0.5
})
self.assertDictEqual(quad[0].quadratic.to_dict(use_name=True),
{("x", "y"): 1})
self.assertDictEqual(
quad[0].quadratic.to_dict(use_name=True, symmetric=True),
{
("x", "y"): 0.5,
("y", "x"): 0.5
},
)
self.assertListEqual(quad[0].quadratic.to_array().tolist(),
[[0, 1, 0], [0, 0, 0], [0, 0, 0]])
self.assertListEqual(
quad[0].quadratic.to_array(symmetric=True).tolist(),
[[0, 0.5, 0], [0.5, 0, 0], [0, 0, 0]],
)
self.assertEqual(quad[0].sense, Constraint.Sense.EQ)
self.assertEqual(quad[0].rhs, 1)
self.assertEqual(quad[0].name, "q0")
self.assertEqual(q_p.get_quadratic_constraint(0).name, "q0")
self.assertEqual(q_p.get_quadratic_constraint("q0").name, "q0")
self.assertDictEqual(quad[1].linear.to_dict(), {1: 1})
self.assertDictEqual(quad[1].linear.to_dict(use_name=True), {"y": 1})
self.assertListEqual(quad[1].linear.to_array().tolist(), [0, 1, 0])
self.assertDictEqual(quad[1].quadratic.to_dict(), {(1, 2): 1})
self.assertDictEqual(quad[1].quadratic.to_dict(symmetric=True), {
(1, 2): 0.5,
(2, 1): 0.5
})
self.assertDictEqual(quad[1].quadratic.to_dict(use_name=True),
{("y", "z"): 1})
self.assertDictEqual(
quad[1].quadratic.to_dict(use_name=True, symmetric=True),
{
("y", "z"): 0.5,
("z", "y"): 0.5
},
)
self.assertListEqual(quad[1].quadratic.to_array().tolist(),
[[0, 0, 0], [0, 0, 1], [0, 0, 0]])
self.assertListEqual(
quad[1].quadratic.to_array(symmetric=True).tolist(),
[[0, 0, 0], [0, 0, 0.5], [0, 0.5, 0]],
)
self.assertEqual(quad[1].sense, Constraint.Sense.LE)
self.assertEqual(quad[1].rhs, 1)
self.assertEqual(quad[1].name, "q1")
self.assertEqual(q_p.get_quadratic_constraint(1).name, "q1")
self.assertEqual(q_p.get_quadratic_constraint("q1").name, "q1")
self.assertDictEqual(quad[2].linear.to_dict(), {2: 1})
self.assertDictEqual(quad[2].linear.to_dict(use_name=True), {"z": 1})
self.assertListEqual(quad[2].linear.to_array().tolist(), [0, 0, 1])
self.assertDictEqual(quad[2].quadratic.to_dict(), {(0, 2): 1})
self.assertDictEqual(quad[2].quadratic.to_dict(symmetric=True), {
(0, 2): 0.5,
(2, 0): 0.5
})
self.assertDictEqual(quad[2].quadratic.to_dict(use_name=True),
{("x", "z"): 1})
self.assertDictEqual(
quad[2].quadratic.to_dict(use_name=True, symmetric=True),
{
("x", "z"): 0.5,
("z", "x"): 0.5
},
)
self.assertListEqual(quad[2].quadratic.to_array().tolist(),
[[0, 0, 1], [0, 0, 0], [0, 0, 0]])
self.assertListEqual(
quad[2].quadratic.to_array(symmetric=True).tolist(),
[[0, 0, 0.5], [0, 0, 0], [0.5, 0, 0]],
)
self.assertEqual(quad[2].sense, Constraint.Sense.GE)
self.assertEqual(quad[2].rhs, 1)
self.assertEqual(quad[2].name, "q2")
self.assertEqual(q_p.get_quadratic_constraint(2).name, "q2")
self.assertEqual(q_p.get_quadratic_constraint("q2").name, "q2")
with self.assertRaises(QiskitOptimizationError):
q_p.quadratic_constraint(name="q0")
with self.assertRaises(QiskitOptimizationError):
q_p.quadratic_constraint(name="q1")
with self.assertRaises(QiskitOptimizationError):
q_p.quadratic_constraint(name="q2")
with self.assertRaises(IndexError):
q_p.get_quadratic_constraint(4)
with self.assertRaises(KeyError):
q_p.get_quadratic_constraint("q3")
q_p.remove_quadratic_constraint("q1")
quad = q_p.quadratic_constraints
self.assertEqual(len(quad), 2)
self.assertDictEqual(quad[1].linear.to_dict(), {2: 1})
self.assertDictEqual(quad[1].linear.to_dict(use_name=True), {"z": 1})
self.assertListEqual(quad[1].linear.to_array().tolist(), [0, 0, 1])
self.assertDictEqual(quad[1].quadratic.to_dict(), {(0, 2): 1})
self.assertDictEqual(quad[1].quadratic.to_dict(symmetric=True), {
(0, 2): 0.5,
(2, 0): 0.5
})
self.assertDictEqual(quad[1].quadratic.to_dict(use_name=True),
{("x", "z"): 1})
self.assertDictEqual(
quad[1].quadratic.to_dict(use_name=True, symmetric=True),
{
("x", "z"): 0.5,
("z", "x"): 0.5
},
)
self.assertListEqual(quad[1].quadratic.to_array().tolist(),
[[0, 0, 1], [0, 0, 0], [0, 0, 0]])
self.assertListEqual(
quad[1].quadratic.to_array(symmetric=True).tolist(),
[[0, 0, 0.5], [0, 0, 0], [0.5, 0, 0]],
)
self.assertEqual(quad[1].sense, Constraint.Sense.GE)
self.assertEqual(quad[1].rhs, 1)
self.assertEqual(quad[1].name, "q2")
self.assertEqual(q_p.get_quadratic_constraint(1).name, "q2")
self.assertEqual(q_p.get_quadratic_constraint("q2").name, "q2")
with self.assertRaises(KeyError):
q_p.remove_quadratic_constraint("q1")
with self.assertRaises(IndexError):
q_p.remove_quadratic_constraint(9)
def test_quadratic_constraints_handling(self):
"""test quadratic constraints handling"""
q_p = QuadraticProgram()
q_p.binary_var('x')
q_p.binary_var('y')
q_p.binary_var('z')
q_p.quadratic_constraint({'x': 1}, {('x', 'y'): 1}, '==', 1)
q_p.quadratic_constraint({'y': 1}, {('y', 'z'): 1}, '<=', 1)
q_p.quadratic_constraint({'z': 1}, {('z', 'x'): 1}, '>=', 1)
self.assertEqual(q_p.get_num_quadratic_constraints(), 3)
quad = q_p.quadratic_constraints
self.assertEqual(len(quad), 3)
self.assertDictEqual(quad[0].linear.to_dict(), {0: 1})
self.assertDictEqual(quad[0].linear.to_dict(use_name=True), {'x': 1})
self.assertListEqual(quad[0].linear.to_array().tolist(), [1, 0, 0])
self.assertDictEqual(quad[0].quadratic.to_dict(), {(0, 1): 1})
self.assertDictEqual(quad[0].quadratic.to_dict(symmetric=True), {
(0, 1): 0.5,
(1, 0): 0.5
})
self.assertDictEqual(quad[0].quadratic.to_dict(use_name=True),
{('x', 'y'): 1})
self.assertDictEqual(
quad[0].quadratic.to_dict(use_name=True, symmetric=True), {
('x', 'y'): 0.5,
('y', 'x'): 0.5
})
self.assertListEqual(quad[0].quadratic.to_array().tolist(),
[[0, 1, 0], [0, 0, 0], [0, 0, 0]])
self.assertListEqual(
quad[0].quadratic.to_array(symmetric=True).tolist(),
[[0, 0.5, 0], [0.5, 0, 0], [0, 0, 0]])
self.assertEqual(quad[0].sense, Constraint.Sense.EQ)
self.assertEqual(quad[0].rhs, 1)
self.assertEqual(quad[0].name, 'q0')
self.assertEqual(q_p.get_quadratic_constraint(0).name, 'q0')
self.assertEqual(q_p.get_quadratic_constraint('q0').name, 'q0')
self.assertDictEqual(quad[1].linear.to_dict(), {1: 1})
self.assertDictEqual(quad[1].linear.to_dict(use_name=True), {'y': 1})
self.assertListEqual(quad[1].linear.to_array().tolist(), [0, 1, 0])
self.assertDictEqual(quad[1].quadratic.to_dict(), {(1, 2): 1})
self.assertDictEqual(quad[1].quadratic.to_dict(symmetric=True), {
(1, 2): 0.5,
(2, 1): 0.5
})
self.assertDictEqual(quad[1].quadratic.to_dict(use_name=True),
{('y', 'z'): 1})
self.assertDictEqual(
quad[1].quadratic.to_dict(use_name=True, symmetric=True), {
('y', 'z'): 0.5,
('z', 'y'): 0.5
})
self.assertListEqual(quad[1].quadratic.to_array().tolist(),
[[0, 0, 0], [0, 0, 1], [0, 0, 0]])
self.assertListEqual(
quad[1].quadratic.to_array(symmetric=True).tolist(),
[[0, 0, 0], [0, 0, 0.5], [0, 0.5, 0]])
self.assertEqual(quad[1].sense, Constraint.Sense.LE)
self.assertEqual(quad[1].rhs, 1)
self.assertEqual(quad[1].name, 'q1')
self.assertEqual(q_p.get_quadratic_constraint(1).name, 'q1')
self.assertEqual(q_p.get_quadratic_constraint('q1').name, 'q1')
self.assertDictEqual(quad[2].linear.to_dict(), {2: 1})
self.assertDictEqual(quad[2].linear.to_dict(use_name=True), {'z': 1})
self.assertListEqual(quad[2].linear.to_array().tolist(), [0, 0, 1])
self.assertDictEqual(quad[2].quadratic.to_dict(), {(0, 2): 1})
self.assertDictEqual(quad[2].quadratic.to_dict(symmetric=True), {
(0, 2): 0.5,
(2, 0): 0.5
})
self.assertDictEqual(quad[2].quadratic.to_dict(use_name=True),
{('x', 'z'): 1})
self.assertDictEqual(
quad[2].quadratic.to_dict(use_name=True, symmetric=True), {
('x', 'z'): 0.5,
('z', 'x'): 0.5
})
self.assertListEqual(quad[2].quadratic.to_array().tolist(),
[[0, 0, 1], [0, 0, 0], [0, 0, 0]])
self.assertListEqual(
quad[2].quadratic.to_array(symmetric=True).tolist(),
[[0, 0, 0.5], [0, 0, 0], [0.5, 0, 0]])
self.assertEqual(quad[2].sense, Constraint.Sense.GE)
self.assertEqual(quad[2].rhs, 1)
self.assertEqual(quad[2].name, 'q2')
self.assertEqual(q_p.get_quadratic_constraint(2).name, 'q2')
self.assertEqual(q_p.get_quadratic_constraint('q2').name, 'q2')
with self.assertRaises(QiskitOptimizationError):
q_p.quadratic_constraint(name='q0')
with self.assertRaises(QiskitOptimizationError):
q_p.quadratic_constraint(name='q1')
with self.assertRaises(QiskitOptimizationError):
q_p.quadratic_constraint(name='q2')
with self.assertRaises(IndexError):
q_p.get_quadratic_constraint(4)
with self.assertRaises(KeyError):
q_p.get_quadratic_constraint('q3')
q_p.remove_quadratic_constraint('q1')
quad = q_p.quadratic_constraints
self.assertEqual(len(quad), 2)
self.assertDictEqual(quad[1].linear.to_dict(), {2: 1})
self.assertDictEqual(quad[1].linear.to_dict(use_name=True), {'z': 1})
self.assertListEqual(quad[1].linear.to_array().tolist(), [0, 0, 1])
self.assertDictEqual(quad[1].quadratic.to_dict(), {(0, 2): 1})
self.assertDictEqual(quad[1].quadratic.to_dict(symmetric=True), {
(0, 2): 0.5,
(2, 0): 0.5
})
self.assertDictEqual(quad[1].quadratic.to_dict(use_name=True),
{('x', 'z'): 1})
self.assertDictEqual(
quad[1].quadratic.to_dict(use_name=True, symmetric=True), {
('x', 'z'): 0.5,
('z', 'x'): 0.5
})
self.assertListEqual(quad[1].quadratic.to_array().tolist(),
[[0, 0, 1], [0, 0, 0], [0, 0, 0]])
self.assertListEqual(
quad[1].quadratic.to_array(symmetric=True).tolist(),
[[0, 0, 0.5], [0, 0, 0], [0.5, 0, 0]])
self.assertEqual(quad[1].sense, Constraint.Sense.GE)
self.assertEqual(quad[1].rhs, 1)
self.assertEqual(quad[1].name, 'q2')
self.assertEqual(q_p.get_quadratic_constraint(1).name, 'q2')
self.assertEqual(q_p.get_quadratic_constraint('q2').name, 'q2')
with self.assertRaises(KeyError):
q_p.remove_quadratic_constraint('q1')
with self.assertRaises(IndexError):
q_p.remove_quadratic_constraint(9)
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}'>",
)
