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}'>", )