def test_init(self):
"""test init."""
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
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
coefficients_array = np.array(coefficients_list)
coefficients_dok = dok_matrix(coefficients_list)
coefficients_dict_int = {(i, j): v
for (i, j), v in coefficients_dok.items()}
coefficients_dict_str = {(f"x{i}", f"x{j}"): v
for (i, j), v in coefficients_dok.items()}
for coeffs in [
coefficients_list,
coefficients_array,
coefficients_dok,
coefficients_dict_int,
coefficients_dict_str,
]:
quadratic = QuadraticExpression(quadratic_program, coeffs)
self.assertEqual((quadratic.coefficients != coefficients_dok).nnz,
0)
self.assertTrue((quadratic.to_array() == coefficients_list).all())
self.assertDictEqual(quadratic.to_dict(use_name=False),
coefficients_dict_int)
self.assertDictEqual(quadratic.to_dict(use_name=True),
coefficients_dict_str)
def test_setters(self):
"""test setters."""
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
zeros = np.zeros(quadratic_program.get_num_vars())
linear = LinearExpression(quadratic_program, zeros)
coefficients_list = list(range(5))
coefficients_array = np.array(coefficients_list)
coefficients_dok = dok_matrix([coefficients_list])
coefficients_dict_int = {i: i for i in range(1, 5)}
coefficients_dict_str = {f"x{i}": i for i in range(1, 5)}
for coeffs in [
coefficients_list,
coefficients_array,
coefficients_dok,
coefficients_dict_int,
coefficients_dict_str,
]:
linear.coefficients = coeffs
self.assertEqual((linear.coefficients != coefficients_dok).nnz, 0)
self.assertTrue((linear.to_array() == coefficients_list).all())
self.assertDictEqual(linear.to_dict(use_name=False), coefficients_dict_int)
self.assertDictEqual(linear.to_dict(use_name=True), coefficients_dict_str)
def test_feasibility(self):
"""Tests feasibility methods."""
q_p = QuadraticProgram("test")
_ = q_p.continuous_var(-1, 1, "x")
_ = q_p.continuous_var(-10, 10, "y")
q_p.minimize(linear={"x": 1, "y": 1})
q_p.linear_constraint({"x": 1, "y": 1}, "<=", 10, "c0")
q_p.linear_constraint({"x": 1, "y": 1}, ">=", -10, "c1")
q_p.linear_constraint({"x": 1, "y": 1}, "==", 5, "c2")
q_p.quadratic_constraint({"y": 1}, {("x", "x"): 1}, "<=", 10, "c3")
q_p.quadratic_constraint({"y": 1}, {("x", "x"): 1}, ">=", 5, "c4")
q_p.quadratic_constraint(None, {
("x", "x"): 1,
("y", "y"): 1
}, "==", 25, "c5")
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_setters(self):
""" test setters. """
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
n = quadratic_program.get_num_vars()
zeros = np.zeros((n, n))
quadratic = QuadraticExpression(quadratic_program, zeros)
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
coefficients_array = np.array(coefficients_list)
coefficients_dok = dok_matrix(coefficients_list)
coefficients_dict_int = {(i, j): v for (i, j), v in coefficients_dok.items()}
coefficients_dict_str = {('x{}'.format(i), 'x{}'.format(j)): v for (i, j), v in
coefficients_dok.items()}
for coeffs in [coefficients_list,
coefficients_array,
coefficients_dok,
coefficients_dict_int,
coefficients_dict_str]:
quadratic.coefficients = coeffs
self.assertEqual((quadratic.coefficients != coefficients_dok).nnz, 0)
self.assertTrue((quadratic.to_array() == coefficients_list).all())
self.assertDictEqual(quadratic.to_dict(use_name=False), coefficients_dict_int)
self.assertDictEqual(quadratic.to_dict(use_name=True), coefficients_dict_str)
def test_init(self):
"""test init."""
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
coefficients_list = list(range(5))
coefficients_array = np.array(coefficients_list)
coefficients_dok = dok_matrix([coefficients_list])
coefficients_dict_int = {i: i for i in range(1, 5)}
coefficients_dict_str = {"x{}".format(i): i for i in range(1, 5)}
for coeffs in [
coefficients_list,
coefficients_array,
coefficients_dok,
coefficients_dict_int,
coefficients_dict_str,
]:
linear = LinearExpression(quadratic_program, coeffs)
self.assertEqual((linear.coefficients != coefficients_dok).nnz, 0)
self.assertTrue((linear.to_array() == coefficients_list).all())
self.assertDictEqual(linear.to_dict(use_name=False),
coefficients_dict_int)
self.assertDictEqual(linear.to_dict(use_name=True),
coefficients_dict_str)
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 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_get_item(self):
"""test get_item."""
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
coefficients = list(range(5))
linear = LinearExpression(quadratic_program, coefficients)
for i, v in enumerate(coefficients):
self.assertEqual(linear[i], v)
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 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_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"""
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",
)
self.assertEqual(
str(q_p),
"minimize 0.5*x^2 - y*z + x - y + 10*z + 1 (3 variables, 6 constraints, 'my problem')",
)
self.assertEqual(
repr(q_p),
"<QuadraticProgram: minimize 0.5*x^2 - y*z + x - y + 10*z + 1, "
"3 variables, 6 constraints, 'my problem'>",
)
def test_evaluate_gradient(self):
""" test evaluate gradient. """
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]:
np.testing.assert_almost_equal(linear.evaluate_gradient(values), coefficients_list)
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 = {f"x{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_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_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_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])
def test_bounds(self):
"""test lowerbound and upperbound"""
with self.subTest("bounded"):
q_p = QuadraticProgram()
q_p.continuous_var(1, 2, "x")
q_p.continuous_var(-2, -1, "y")
q_p.continuous_var(-1, 2, "z")
bounds = QuadraticExpression(q_p, {
("x", "y"): 1,
("y", "z"): 2,
("z", "z"): 3
}).bounds
self.assertAlmostEqual(bounds.lowerbound, -12)
self.assertAlmostEqual(bounds.upperbound, 15)
with self.subTest("bounded2"):
q_p = QuadraticProgram()
q_p.integer_var(-1, 2, "x")
bounds = QuadraticExpression(q_p, {("x", "x"): 1}).bounds
self.assertAlmostEqual(bounds.lowerbound, 0)
self.assertAlmostEqual(bounds.upperbound, 4)
bounds = QuadraticExpression(q_p, {("x", "x"): -1}).bounds
self.assertAlmostEqual(bounds.lowerbound, -4)
self.assertAlmostEqual(bounds.upperbound, 0)
bounds = QuadraticExpression(q_p, {("x", "x"): 0}).bounds
self.assertAlmostEqual(bounds.lowerbound, 0)
self.assertAlmostEqual(bounds.upperbound, 0)
with self.subTest("bounded3"):
q_p = QuadraticProgram()
q_p.integer_var(-2, -1, "x")
bounds = QuadraticExpression(q_p, {("x", "x"): 1}).bounds
self.assertAlmostEqual(bounds.lowerbound, 1)
self.assertAlmostEqual(bounds.upperbound, 4)
bounds = QuadraticExpression(q_p, {("x", "x"): -1}).bounds
self.assertAlmostEqual(bounds.lowerbound, -4)
self.assertAlmostEqual(bounds.upperbound, -1)
bounds = QuadraticExpression(q_p, {("x", "x"): 0}).bounds
self.assertAlmostEqual(bounds.lowerbound, 0)
self.assertAlmostEqual(bounds.upperbound, 0)
with self.subTest("bounded4"):
q_p = QuadraticProgram()
q_p.integer_var(-2, 3, "x")
q_p.integer_var(-10, 20, "y")
bounds = QuadraticExpression(q_p, {("x", "y"): 1}).bounds
self.assertAlmostEqual(bounds.lowerbound, -40)
self.assertAlmostEqual(bounds.upperbound, 60)
bounds = QuadraticExpression(q_p, {("x", "y"): -1}).bounds
self.assertAlmostEqual(bounds.lowerbound, -60)
self.assertAlmostEqual(bounds.upperbound, 40)
bounds = QuadraticExpression(q_p, {("x", "y"): 0}).bounds
self.assertAlmostEqual(bounds.lowerbound, 0)
self.assertAlmostEqual(bounds.upperbound, 0)
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.continuous_var(1, 2, "x")
q_p.continuous_var(-2, -1, "y")
q_p.continuous_var(-INFINITY, 2, "z")
_ = QuadraticExpression(q_p, {
("x", "y"): 1,
("y", "z"): 2,
("z", "z"): 3
}).bounds
with self.assertRaises(QiskitOptimizationError):
q_p = QuadraticProgram()
q_p.continuous_var(1, 2, "x")
q_p.continuous_var(-2, -1, "y")
q_p.continuous_var(-1, INFINITY, "z")
_ = QuadraticExpression(q_p, {
("x", "y"): 1,
("y", "z"): 2,
("z", "z"): 3
}).bounds
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_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_substitute_variables(self):
"""test substitute variables"""
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 = q_p.substitute_variables(constants={'x': -1})
self.assertEqual(q_p2.status, QuadraticProgram.Status.INFEASIBLE)
q_p2 = q_p.substitute_variables(constants={'y': -3})
self.assertEqual(q_p2.status, QuadraticProgram.Status.INFEASIBLE)
q_p2 = q_p.substitute_variables(constants={'x': 1, 'z': 2})
self.assertEqual(q_p2.status, QuadraticProgram.Status.INFEASIBLE)
q_p2.clear()
self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
q_p2 = q_p.substitute_variables(constants={'x': 0})
self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True),
{'y': 2})
self.assertDictEqual(q_p2.objective.quadratic.to_dict(use_name=True),
{('z', 'z'): 2})
self.assertEqual(q_p2.objective.constant, 1)
self.assertEqual(len(q_p2.linear_constraints), 1)
self.assertEqual(len(q_p2.quadratic_constraints), 1)
cst = q_p2.linear_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {'z': -1})
self.assertEqual(cst.sense.name, 'EQ')
self.assertEqual(cst.rhs, 1)
cst = q_p2.quadratic_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {'z': -1})
self.assertDictEqual(cst.quadratic.to_dict(use_name=True),
{('y', 'z'): 3})
self.assertEqual(cst.sense.name, 'LE')
self.assertEqual(cst.rhs, -1)
q_p2 = q_p.substitute_variables(constants={'z': -1})
self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True), {
'x': 1,
'y': 2
})
self.assertDictEqual(q_p2.objective.quadratic.to_dict(use_name=True),
{('x', 'y'): -1})
self.assertEqual(q_p2.objective.constant, 3)
self.assertEqual(len(q_p2.linear_constraints), 2)
self.assertEqual(len(q_p2.quadratic_constraints), 0)
cst = q_p2.linear_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {'x': 2})
self.assertEqual(cst.sense.name, 'EQ')
self.assertEqual(cst.rhs, 0)
cst = q_p2.linear_constraints[1]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {
'x': 2,
'y': -3
})
self.assertEqual(cst.sense.name, 'LE')
self.assertEqual(cst.rhs, -2)
q_p2 = q_p.substitute_variables(variables={'y': ('x', -0.5)})
self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True), {})
self.assertDictEqual(q_p2.objective.quadratic.to_dict(use_name=True), {
('x', 'x'): 0.5,
('z', 'z'): 2
})
self.assertEqual(q_p2.objective.constant, 1)
self.assertEqual(len(q_p2.linear_constraints), 1)
self.assertEqual(len(q_p2.quadratic_constraints), 1)
cst = q_p2.linear_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {
'x': 2,
'z': -1
})
self.assertEqual(cst.sense.name, 'EQ')
self.assertEqual(cst.rhs, 1)
cst = q_p2.quadratic_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {
'x': 2,
'z': -1
})
self.assertDictEqual(cst.quadratic.to_dict(use_name=True),
{('x', 'z'): -1.5})
self.assertEqual(cst.sense.name, 'LE')
self.assertEqual(cst.rhs, -1)
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])
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(
path.join('resources', 'test_quadratic_program.lp'))
temp_output_file = tempfile.NamedTemporaryFile(mode='w+t',
suffix='.lp')
q_p.write_to_lp_file(temp_output_file.name)
with open(reference_file_name) as reference:
lines1 = temp_output_file.readlines()
lines2 = reference.readlines()
self.assertListEqual(lines1, lines2)
temp_output_file.close() # automatically deleted
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')) as file1, open(
reference_file_name) 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 test_substitute_variables(self):
"""test substitute variables"""
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)
with self.subTest("x <- -1"):
q_p2 = substitute_variables(q_p, constants={"x": -1})
self.assertEqual(q_p2.status, QuadraticProgram.Status.INFEASIBLE)
q_p2 = substitute_variables(q_p, constants={"y": -3})
self.assertEqual(q_p2.status, QuadraticProgram.Status.INFEASIBLE)
q_p2 = substitute_variables(q_p, constants={"x": 1, "z": 2})
self.assertEqual(q_p2.status, QuadraticProgram.Status.INFEASIBLE)
q_p2.clear()
self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
with self.subTest("x <- 0"):
q_p2 = substitute_variables(q_p, constants={"x": 0})
self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True),
{"y": 2})
self.assertDictEqual(
q_p2.objective.quadratic.to_dict(use_name=True),
{("z", "z"): 2})
self.assertEqual(q_p2.objective.constant, 1)
self.assertEqual(len(q_p2.linear_constraints), 1)
self.assertEqual(len(q_p2.quadratic_constraints), 1)
cst = q_p2.linear_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {"z": -1})
self.assertEqual(cst.sense.name, "EQ")
self.assertEqual(cst.rhs, 1)
cst = q_p2.quadratic_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {"z": -1})
self.assertDictEqual(cst.quadratic.to_dict(use_name=True),
{("y", "z"): 3})
self.assertEqual(cst.sense.name, "LE")
self.assertEqual(cst.rhs, -1)
with self.subTest("z <- -1"):
q_p2 = substitute_variables(q_p, constants={"z": -1})
self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True),
{
"x": 1,
"y": 2
})
self.assertDictEqual(
q_p2.objective.quadratic.to_dict(use_name=True),
{("x", "y"): -1})
self.assertEqual(q_p2.objective.constant, 3)
self.assertEqual(len(q_p2.linear_constraints), 2)
self.assertEqual(len(q_p2.quadratic_constraints), 0)
cst = q_p2.linear_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {"x": 2})
self.assertEqual(cst.sense.name, "EQ")
self.assertEqual(cst.rhs, 0)
cst = q_p2.linear_constraints[1]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {
"x": 2,
"y": -3
})
self.assertEqual(cst.sense.name, "LE")
self.assertEqual(cst.rhs, -2)
with self.subTest("y <- -0.5 * x"):
q_p2 = substitute_variables(q_p, variables={"y": ("x", -0.5)})
self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID)
self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True),
{})
self.assertDictEqual(
q_p2.objective.quadratic.to_dict(use_name=True),
{
("x", "x"): 0.5,
("z", "z"): 2
},
)
self.assertEqual(q_p2.objective.constant, 1)
self.assertEqual(len(q_p2.linear_constraints), 1)
self.assertEqual(len(q_p2.quadratic_constraints), 1)
cst = q_p2.linear_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {
"x": 2,
"z": -1
})
self.assertEqual(cst.sense.name, "EQ")
self.assertEqual(cst.rhs, 1)
cst = q_p2.quadratic_constraints[0]
self.assertDictEqual(cst.linear.to_dict(use_name=True), {
"x": 2,
"z": -1
})
self.assertDictEqual(cst.quadratic.to_dict(use_name=True),
{("x", "z"): -1.5})
self.assertEqual(cst.sense.name, "LE")
self.assertEqual(cst.rhs, -1)
def test_variables_handling(self):
""" test add variables """
quadratic_program = QuadraticProgram()
self.assertEqual(quadratic_program.get_num_vars(), 0)
self.assertEqual(quadratic_program.get_num_continuous_vars(), 0)
self.assertEqual(quadratic_program.get_num_binary_vars(), 0)
self.assertEqual(quadratic_program.get_num_integer_vars(), 0)
x_0 = quadratic_program.continuous_var()
self.assertEqual(x_0.name, 'x0')
self.assertEqual(x_0.lowerbound, 0)
self.assertEqual(x_0.upperbound, INFINITY)
self.assertEqual(x_0.vartype, Variable.Type.CONTINUOUS)
self.assertEqual(quadratic_program.get_num_vars(), 1)
self.assertEqual(quadratic_program.get_num_continuous_vars(), 1)
self.assertEqual(quadratic_program.get_num_binary_vars(), 0)
self.assertEqual(quadratic_program.get_num_integer_vars(), 0)
x_1 = quadratic_program.continuous_var(name='x1',
lowerbound=5,
upperbound=10)
self.assertEqual(x_1.name, 'x1')
self.assertEqual(x_1.lowerbound, 5)
self.assertEqual(x_1.upperbound, 10)
self.assertEqual(x_1.vartype, Variable.Type.CONTINUOUS)
self.assertEqual(quadratic_program.get_num_vars(), 2)
self.assertEqual(quadratic_program.get_num_continuous_vars(), 2)
self.assertEqual(quadratic_program.get_num_binary_vars(), 0)
self.assertEqual(quadratic_program.get_num_integer_vars(), 0)
x_2 = quadratic_program.binary_var()
self.assertEqual(x_2.name, 'x2')
self.assertEqual(x_2.lowerbound, 0)
self.assertEqual(x_2.upperbound, 1)
self.assertEqual(x_2.vartype, Variable.Type.BINARY)
self.assertEqual(quadratic_program.get_num_vars(), 3)
self.assertEqual(quadratic_program.get_num_continuous_vars(), 2)
self.assertEqual(quadratic_program.get_num_binary_vars(), 1)
self.assertEqual(quadratic_program.get_num_integer_vars(), 0)
x_3 = quadratic_program.binary_var(name='x3')
self.assertEqual(x_3.name, 'x3')
self.assertEqual(x_3.lowerbound, 0)
self.assertEqual(x_3.upperbound, 1)
self.assertEqual(x_3.vartype, Variable.Type.BINARY)
self.assertEqual(quadratic_program.get_num_vars(), 4)
self.assertEqual(quadratic_program.get_num_continuous_vars(), 2)
self.assertEqual(quadratic_program.get_num_binary_vars(), 2)
self.assertEqual(quadratic_program.get_num_integer_vars(), 0)
x_4 = quadratic_program.integer_var()
self.assertEqual(x_4.name, 'x4')
self.assertEqual(x_4.lowerbound, 0)
self.assertEqual(x_4.upperbound, INFINITY)
self.assertEqual(x_4.vartype, Variable.Type.INTEGER)
self.assertEqual(quadratic_program.get_num_vars(), 5)
self.assertEqual(quadratic_program.get_num_continuous_vars(), 2)
self.assertEqual(quadratic_program.get_num_binary_vars(), 2)
self.assertEqual(quadratic_program.get_num_integer_vars(), 1)
x_5 = quadratic_program.integer_var(name='x5',
lowerbound=5,
upperbound=10)
self.assertEqual(x_5.name, 'x5')
self.assertEqual(x_5.lowerbound, 5)
self.assertEqual(x_5.upperbound, 10)
self.assertEqual(x_5.vartype, Variable.Type.INTEGER)
self.assertEqual(quadratic_program.get_num_vars(), 6)
self.assertEqual(quadratic_program.get_num_continuous_vars(), 2)
self.assertEqual(quadratic_program.get_num_binary_vars(), 2)
self.assertEqual(quadratic_program.get_num_integer_vars(), 2)
with self.assertRaises(QiskitOptimizationError):
quadratic_program.continuous_var(name='x0')
with self.assertRaises(QiskitOptimizationError):
quadratic_program.binary_var(name='x0')
with self.assertRaises(QiskitOptimizationError):
quadratic_program.integer_var(name='x0')
variables = [x_0, x_1, x_2, x_3, x_4, x_5]
for i, x in enumerate(variables):
y = quadratic_program.get_variable(i)
z = quadratic_program.get_variable(x.name)
self.assertEqual(x.name, y.name)
self.assertEqual(x.name, z.name)
self.assertDictEqual(quadratic_program.variables_index,
{'x' + str(i): i
for i in range(6)})
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)
