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_integer_to_binary2(self): """Test integer to binary variables 2""" mod = QuadraticProgram() mod.integer_var(name="x", lowerbound=0, upperbound=1) mod.integer_var(name="y", lowerbound=0, upperbound=1) mod.minimize(1, {"x": 1}, {("x", "y"): 2}) mod.linear_constraint({"x": 1}, "==", 1) mod.quadratic_constraint({"x": 1}, {("x", "y"): 2}, "==", 1) mod2 = IntegerToBinary().convert(mod) self.assertListEqual([e.name + "@0" for e in mod.variables], [e.name for e in mod2.variables]) self.assertDictEqual(mod.objective.linear.to_dict(), mod2.objective.linear.to_dict()) self.assertDictEqual(mod.objective.quadratic.to_dict(), mod2.objective.quadratic.to_dict()) self.assertEqual(mod.get_num_linear_constraints(), mod2.get_num_linear_constraints()) for cst, cst2 in zip(mod.linear_constraints, mod2.linear_constraints): self.assertDictEqual(cst.linear.to_dict(), cst2.linear.to_dict()) self.assertEqual(mod.get_num_quadratic_constraints(), mod2.get_num_quadratic_constraints()) for cst, cst2 in zip(mod.quadratic_constraints, mod2.quadratic_constraints): self.assertDictEqual(cst.linear.to_dict(), cst2.linear.to_dict()) self.assertDictEqual(cst.quadratic.to_dict(), cst2.quadratic.to_dict())
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_ising_to_quadraticprogram_quadratic(self): """Test optimization problem to operators with linear=False""" op = QUBIT_OP_MAXIMIZE_SAMPLE offset = OFFSET_MAXIMIZE_SAMPLE quadratic = QuadraticProgram() quadratic.from_ising(op, offset, linear=False) self.assertEqual(quadratic.get_num_vars(), 4) self.assertEqual(quadratic.get_num_linear_constraints(), 0) self.assertEqual(quadratic.get_num_quadratic_constraints(), 0) self.assertEqual(quadratic.objective.sense, quadratic.objective.Sense.MINIMIZE) self.assertAlmostEqual(quadratic.objective.constant, 900000) quadratic_matrix = np.zeros((4, 4)) quadratic_matrix[0, 0] = -500001 quadratic_matrix[0, 1] = 400000 quadratic_matrix[0, 2] = 600000 quadratic_matrix[0, 3] = 800000 quadratic_matrix[1, 1] = -800001 quadratic_matrix[1, 2] = 1200000 quadratic_matrix[1, 3] = 1600000 quadratic_matrix[2, 2] = -900001 quadratic_matrix[2, 3] = 2400000 quadratic_matrix[3, 3] = -800001 np.testing.assert_array_almost_equal( quadratic.objective.quadratic.coefficients.toarray(), quadratic_matrix)
def test_constructor(self): """test constructor""" quadratic_program = QuadraticProgram() self.assertEqual(quadratic_program.name, "") self.assertEqual(quadratic_program.status, QuadraticProgram.Status.VALID) self.assertEqual(quadratic_program.get_num_vars(), 0) self.assertEqual(quadratic_program.get_num_linear_constraints(), 0) self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 0) self.assertEqual(quadratic_program.objective.constant, 0) self.assertDictEqual(quadratic_program.objective.linear.to_dict(), {}) self.assertDictEqual(quadratic_program.objective.quadratic.to_dict(), {})
def test_linear_inequality_to_penalty7(self): """Test special constraint to penalty 6 x-y >= 0 -> P(y-x*y)""" op = QuadraticProgram() lip = LinearInequalityToPenalty() op.binary_var(name="x") op.binary_var(name="y") # Linear constraints linear_constraint = {"x": 1, "y": -1} op.linear_constraint(linear_constraint, Constraint.Sense.GE, 0, "P(y-xy)") # Test with no max/min with self.subTest("No max/min"): self.assertEqual(op.get_num_linear_constraints(), 1) penalty = 1 linear = {"y": penalty} quadratic = {("x", "y"): -1 * penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0) # Test maximize with self.subTest("Maximize"): linear = {"x": 2, "y": 1} op.maximize(linear=linear) penalty = 4 linear["y"] = linear["y"] - penalty quadratic = {("x", "y"): penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0) # Test minimize with self.subTest("Minimize"): linear = {"x": 2, "y": 1} op.minimize(linear={"x": 2, "y": 1}) penalty = 4 linear["y"] = linear["y"] + penalty quadratic = {("x", "y"): -1 * penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0)
def test_penalize_sense(self): """Test PenalizeLinearEqualityConstraints with senses""" op = QuadraticProgram() for i in range(3): op.binary_var(name="x{}".format(i)) # Linear constraints linear_constraint = {"x0": 1, "x1": 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, "x0x1") linear_constraint = {"x1": 1, "x2": -1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, "x1x2") linear_constraint = {"x0": 1, "x2": 3} op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, "x0x2") self.assertEqual(op.get_num_linear_constraints(), 3) conv = LinearEqualityToPenalty() with self.assertRaises(QiskitOptimizationError): conv.convert(op)
def test_clear(self): """test clear""" q_p = QuadraticProgram("test") q_p.binary_var("x") q_p.binary_var("y") q_p.minimize(constant=1, linear={"x": 1, "y": 2}, quadratic={("x", "x"): 1}) q_p.linear_constraint({"x": 1}, "==", 1) q_p.quadratic_constraint({"x": 1}, {("y", "y"): 2}, "<=", 1) q_p.clear() self.assertEqual(q_p.name, "") self.assertEqual(q_p.status, QuadraticProgram.Status.VALID) self.assertEqual(q_p.get_num_vars(), 0) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) self.assertEqual(q_p.objective.constant, 0) self.assertDictEqual(q_p.objective.linear.to_dict(), {}) self.assertDictEqual(q_p.objective.quadratic.to_dict(), {})
def test_penalize_binary(self): """Test PenalizeLinearEqualityConstraints with binary variables""" op = QuadraticProgram() for i in range(3): op.binary_var(name="x{}".format(i)) # Linear constraints linear_constraint = {"x0": 1, "x1": 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, "x0x1") linear_constraint = {"x1": 1, "x2": -1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, "x1x2") linear_constraint = {"x0": 1, "x2": 3} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, "x0x2") self.assertEqual(op.get_num_linear_constraints(), 3) conv = LinearEqualityToPenalty() op2 = conv.convert(op) self.assertEqual(op2.get_num_linear_constraints(), 0) new_x = conv.interpret(np.arange(3)) np.testing.assert_array_almost_equal(new_x, np.arange(3))
def test_penalize_integer(self): """Test PenalizeLinearEqualityConstraints with integer variables""" op = QuadraticProgram() for i in range(3): op.integer_var(name="x{}".format(i), lowerbound=-3, upperbound=3) # Linear constraints linear_constraint = {"x0": 1, "x1": 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, "x0x1") linear_constraint = {"x1": 1, "x2": -1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, "x1x2") linear_constraint = {"x0": 1, "x2": -1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, "x0x2") op.minimize(constant=3, linear={"x0": 1}, quadratic={("x1", "x2"): 2}) self.assertEqual(op.get_num_linear_constraints(), 3) conv = LinearEqualityToPenalty() op2 = conv.convert(op) self.assertEqual(op2.get_num_linear_constraints(), 0) new_x = conv.interpret([0, 1, -1]) np.testing.assert_array_almost_equal(new_x, [0, 1, -1])
def test_integer_to_binary_quadratic(self): """Test integer to binary variables with quadratic expressions""" mod = QuadraticProgram() mod.integer_var(name="x", lowerbound=10, upperbound=13) mod.minimize(quadratic={("x", "x"): 1}) mod2 = IntegerToBinary().convert(mod) self.assertListEqual([e.name for e in mod2.variables], ["x@0", "x@1"]) self.assertEqual(mod.get_num_linear_constraints(), 0) self.assertEqual(mod.get_num_quadratic_constraints(), 0) self.assertAlmostEqual(mod2.objective.constant, 100) self.assertDictEqual(mod2.objective.linear.to_dict(use_name=True), { "x@0": 20, "x@1": 40 }) self.assertDictEqual( mod2.objective.quadratic.to_dict(use_name=True), { ("x@0", "x@0"): 1, ("x@1", "x@1"): 4, ("x@0", "x@1"): 4 }, )
def test_clear(self): """ test clear """ q_p = QuadraticProgram('test') q_p.binary_var('x') q_p.binary_var('y') q_p.minimize(constant=1, linear={ 'x': 1, 'y': 2 }, quadratic={('x', 'x'): 1}) q_p.linear_constraint({'x': 1}, '==', 1) q_p.quadratic_constraint({'x': 1}, {('y', 'y'): 2}, '<=', 1) q_p.clear() self.assertEqual(q_p.name, '') self.assertEqual(q_p.status, QuadraticProgram.Status.VALID) self.assertEqual(q_p.get_num_vars(), 0) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) self.assertEqual(q_p.objective.constant, 0) self.assertDictEqual(q_p.objective.linear.to_dict(), {}) self.assertDictEqual(q_p.objective.quadratic.to_dict(), {})
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))
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_linear_inequality_to_penalty1(self): """Test special constraint to penalty x+y <= 1 -> P(x*y)""" op = QuadraticProgram() lip = LinearInequalityToPenalty() op.binary_var(name="x") op.binary_var(name="y") # Linear constraints linear_constraint = {"x": 1, "y": 1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 1, "P(xy)") # Test with no max/min with self.subTest("No max/min"): self.assertEqual(op.get_num_linear_constraints(), 1) lip.penalty = 1 quadratic = {("x", "y"): lip.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 with self.subTest("Maximize"): linear = {"x": 2, "y": 1} op.maximize(linear=linear) lip.penalty = 5 quadratic = {("x", "y"): -1 * lip.penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0) # Test minimize with self.subTest("Minimize"): linear = {"x": 2, "y": 1} op.minimize(linear=linear) lip.penalty = 5 quadratic = {("x", "y"): lip.penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0) # Test combination with self.subTest("Combination"): op = QuadraticProgram() lip = LinearInequalityToPenalty() op.binary_var(name="x") op.binary_var(name="y") op.binary_var(name="z") op.binary_var(name="w") linear = {"x": 2, "y": 1, "z": -1, "w": 1} quadratic = {("y", "z"): -2, ("w", "w"): 1} op.minimize(linear=linear, quadratic=quadratic) linear_constraint = {"x": 1, "w": 1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 1, "P(xw)") linear_constraint = {"y": 1, "z": 1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 1, "P(yz)") linear_constraint = {"y": 2, "z": 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, "None 1") quadratic_constraint = {("x", "x"): -2, ("y", "w"): 1} op.quadratic_constraint(linear_constraint, quadratic_constraint, Constraint.Sense.LE, 1, "None 2") lip.penalty = 5 op2 = lip.convert(op) quadratic[("x", "w")] = lip.penalty quadratic[("y", "z")] = quadratic[("y", "z")] + lip.penalty ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 1) self.assertEqual(op2.get_num_quadratic_constraints(), 1)
def test_integer_to_binary_zero_range_variable(self): """Test integer to binary variables with zero range variables""" with self.subTest( "zero range variable in a linear expression of the objective"): mod = QuadraticProgram() mod.integer_var(name="x", lowerbound=10, upperbound=10) mod.minimize(linear={"x": 1}) mod2 = IntegerToBinary().convert(mod) self.assertListEqual([e.name for e in mod2.variables], ["x@0"]) self.assertEqual(mod.get_num_linear_constraints(), 0) self.assertEqual(mod.get_num_quadratic_constraints(), 0) self.assertAlmostEqual(mod2.objective.constant, 10) self.assertDictEqual(mod2.objective.linear.to_dict(), {}) self.assertDictEqual(mod2.objective.quadratic.to_dict(), {}) with self.subTest( "zero range variable in a quadratic expression of the objective" ): mod = QuadraticProgram() mod.integer_var(name="x", lowerbound=10, upperbound=10) mod.minimize(quadratic={("x", "x"): 1}) mod2 = IntegerToBinary().convert(mod) self.assertListEqual([e.name for e in mod2.variables], ["x@0"]) self.assertEqual(mod.get_num_linear_constraints(), 0) self.assertEqual(mod.get_num_quadratic_constraints(), 0) self.assertAlmostEqual(mod2.objective.constant, 100) self.assertDictEqual(mod2.objective.linear.to_dict(), {}) self.assertDictEqual(mod2.objective.quadratic.to_dict(), {}) with self.subTest("zero range variable in a linear constraint"): mod = QuadraticProgram() mod.integer_var(name="x", lowerbound=10, upperbound=10) mod.binary_var(name="y") mod.linear_constraint({"x": 1, "y": 1}, "<=", 100) mod2 = IntegerToBinary().convert(mod) self.assertListEqual([e.name for e in mod2.variables], ["x@0", "y"]) self.assertEqual(mod.get_num_linear_constraints(), 1) self.assertEqual(mod.get_num_quadratic_constraints(), 0) self.assertAlmostEqual(mod2.objective.constant, 0) self.assertDictEqual(mod2.objective.linear.to_dict(), {}) self.assertDictEqual(mod2.objective.quadratic.to_dict(), {}) cst = mod2.get_linear_constraint(0) self.assertDictEqual(cst.linear.to_dict(use_name=True), {"y": 1}) self.assertEqual(cst.sense, Constraint.Sense.LE) self.assertAlmostEqual(cst.rhs, 90) self.assertEqual(cst.name, "c0") with self.subTest("zero range variable in a quadratic constraint"): mod = QuadraticProgram() mod.integer_var(name="x", lowerbound=10, upperbound=10) mod.binary_var(name="y") mod.quadratic_constraint({"x": 1}, { ("x", "x"): 2, ("x", "y"): 3 }, ">=", 100) mod2 = IntegerToBinary().convert(mod) self.assertListEqual([e.name for e in mod2.variables], ["x@0", "y"]) self.assertEqual(mod.get_num_linear_constraints(), 0) self.assertEqual(mod.get_num_quadratic_constraints(), 1) self.assertAlmostEqual(mod2.objective.constant, 0) self.assertDictEqual(mod2.objective.linear.to_dict(), {}) self.assertDictEqual(mod2.objective.quadratic.to_dict(), {}) cst = mod2.get_quadratic_constraint(0) self.assertDictEqual(cst.linear.to_dict(use_name=True), {"y": 30}) self.assertEqual(cst.sense, Constraint.Sense.GE) self.assertAlmostEqual(cst.rhs, -110) self.assertEqual(cst.name, "q0")
def test_linear_constraints_handling(self): """test linear constraints handling""" q_p = QuadraticProgram() q_p.binary_var("x") q_p.binary_var("y") q_p.binary_var("z") q_p.linear_constraint({"x": 1}, "==", 1) q_p.linear_constraint({"y": 1}, "<=", 1) q_p.linear_constraint({"z": 1}, ">=", 1) self.assertEqual(q_p.get_num_linear_constraints(), 3) lin = q_p.linear_constraints self.assertEqual(len(lin), 3) self.assertDictEqual(lin[0].linear.to_dict(), {0: 1}) self.assertDictEqual(lin[0].linear.to_dict(use_name=True), {"x": 1}) self.assertListEqual(lin[0].linear.to_array().tolist(), [1, 0, 0]) self.assertEqual(lin[0].sense, Constraint.Sense.EQ) self.assertEqual(lin[0].rhs, 1) self.assertEqual(lin[0].name, "c0") self.assertEqual(q_p.get_linear_constraint(0).name, "c0") self.assertEqual(q_p.get_linear_constraint("c0").name, "c0") self.assertDictEqual(lin[1].linear.to_dict(), {1: 1}) self.assertDictEqual(lin[1].linear.to_dict(use_name=True), {"y": 1}) self.assertListEqual(lin[1].linear.to_array().tolist(), [0, 1, 0]) self.assertEqual(lin[1].sense, Constraint.Sense.LE) self.assertEqual(lin[1].rhs, 1) self.assertEqual(lin[1].name, "c1") self.assertEqual(q_p.get_linear_constraint(1).name, "c1") self.assertEqual(q_p.get_linear_constraint("c1").name, "c1") self.assertDictEqual(lin[2].linear.to_dict(), {2: 1}) self.assertDictEqual(lin[2].linear.to_dict(use_name=True), {"z": 1}) self.assertListEqual(lin[2].linear.to_array().tolist(), [0, 0, 1]) self.assertEqual(lin[2].sense, Constraint.Sense.GE) self.assertEqual(lin[2].rhs, 1) self.assertEqual(lin[2].name, "c2") self.assertEqual(q_p.get_linear_constraint(2).name, "c2") self.assertEqual(q_p.get_linear_constraint("c2").name, "c2") with self.assertRaises(QiskitOptimizationError): q_p.linear_constraint(name="c0") with self.assertRaises(QiskitOptimizationError): q_p.linear_constraint(name="c1") with self.assertRaises(QiskitOptimizationError): q_p.linear_constraint(name="c2") with self.assertRaises(IndexError): q_p.get_linear_constraint(4) with self.assertRaises(KeyError): q_p.get_linear_constraint("c3") q_p.remove_linear_constraint("c1") lin = q_p.linear_constraints self.assertEqual(len(lin), 2) self.assertDictEqual(lin[1].linear.to_dict(), {2: 1}) self.assertDictEqual(lin[1].linear.to_dict(use_name=True), {"z": 1}) self.assertListEqual(lin[1].linear.to_array().tolist(), [0, 0, 1]) self.assertEqual(lin[1].sense, Constraint.Sense.GE) self.assertEqual(lin[1].rhs, 1) self.assertEqual(lin[1].name, "c2") self.assertEqual(q_p.get_linear_constraint(1).name, "c2") self.assertEqual(q_p.get_linear_constraint("c2").name, "c2") with self.assertRaises(KeyError): q_p.remove_linear_constraint("c1") with self.assertRaises(IndexError): q_p.remove_linear_constraint(9) q_p.linear_constraint(sense="E") self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ) q_p.linear_constraint(sense="G") self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE) q_p.linear_constraint(sense="L") self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.LE) q_p.linear_constraint(sense="EQ") self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ) q_p.linear_constraint(sense="GE") self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE) q_p.linear_constraint(sense="LE") self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.LE) q_p.linear_constraint(sense="=") self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ) q_p.linear_constraint(sense=">") self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE) q_p.linear_constraint(sense="<") with self.assertRaises(QiskitOptimizationError): q_p.linear_constraint(sense="=>")
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_read_from_lp_file(self): """test read lp file""" try: q_p = QuadraticProgram() with self.assertRaises(FileNotFoundError): q_p.read_from_lp_file('') with self.assertRaises(FileNotFoundError): q_p.read_from_lp_file('no_file.txt') lp_file = self.get_resource_path( path.join('resources', 'test_quadratic_program.lp')) q_p.read_from_lp_file(lp_file) self.assertEqual(q_p.name, 'my problem') self.assertEqual(q_p.get_num_vars(), 3) self.assertEqual(q_p.get_num_binary_vars(), 1) self.assertEqual(q_p.get_num_integer_vars(), 1) self.assertEqual(q_p.get_num_continuous_vars(), 1) self.assertEqual(q_p.get_num_linear_constraints(), 3) self.assertEqual(q_p.get_num_quadratic_constraints(), 3) self.assertEqual(q_p.variables[0].name, 'x') self.assertEqual(q_p.variables[0].vartype, Variable.Type.BINARY) self.assertEqual(q_p.variables[0].lowerbound, 0) self.assertEqual(q_p.variables[0].upperbound, 1) self.assertEqual(q_p.variables[1].name, 'y') self.assertEqual(q_p.variables[1].vartype, Variable.Type.INTEGER) self.assertEqual(q_p.variables[1].lowerbound, -1) self.assertEqual(q_p.variables[1].upperbound, 5) self.assertEqual(q_p.variables[2].name, 'z') self.assertEqual(q_p.variables[2].vartype, Variable.Type.CONTINUOUS) self.assertEqual(q_p.variables[2].lowerbound, -1) self.assertEqual(q_p.variables[2].upperbound, 5) self.assertEqual(q_p.objective.sense, QuadraticObjective.Sense.MINIMIZE) self.assertEqual(q_p.objective.constant, 1) self.assertDictEqual(q_p.objective.linear.to_dict(use_name=True), { 'x': 1, 'y': -1, 'z': 10 }) self.assertDictEqual( q_p.objective.quadratic.to_dict(use_name=True), { ('x', 'x'): 0.5, ('y', 'z'): -1 }) cst = q_p.linear_constraints self.assertEqual(cst[0].name, 'lin_eq') self.assertDictEqual(cst[0].linear.to_dict(use_name=True), { 'x': 1, 'y': 2 }) self.assertEqual(cst[0].sense, Constraint.Sense.EQ) self.assertEqual(cst[0].rhs, 1) self.assertEqual(cst[1].name, 'lin_leq') self.assertDictEqual(cst[1].linear.to_dict(use_name=True), { 'x': 1, 'y': 2 }) self.assertEqual(cst[1].sense, Constraint.Sense.LE) self.assertEqual(cst[1].rhs, 1) self.assertEqual(cst[2].name, 'lin_geq') self.assertDictEqual(cst[2].linear.to_dict(use_name=True), { 'x': 1, 'y': 2 }) self.assertEqual(cst[2].sense, Constraint.Sense.GE) self.assertEqual(cst[2].rhs, 1) cst = q_p.quadratic_constraints self.assertEqual(cst[0].name, 'quad_eq') self.assertDictEqual(cst[0].linear.to_dict(use_name=True), { 'x': 1, 'y': 1 }) self.assertDictEqual(cst[0].quadratic.to_dict(use_name=True), { ('x', 'x'): 1, ('y', 'z'): -1, ('z', 'z'): 2 }) self.assertEqual(cst[0].sense, Constraint.Sense.EQ) self.assertEqual(cst[0].rhs, 1) self.assertEqual(cst[1].name, 'quad_leq') self.assertDictEqual(cst[1].linear.to_dict(use_name=True), { 'x': 1, 'y': 1 }) self.assertDictEqual(cst[1].quadratic.to_dict(use_name=True), { ('x', 'x'): 1, ('y', 'z'): -1, ('z', 'z'): 2 }) self.assertEqual(cst[1].sense, Constraint.Sense.LE) self.assertEqual(cst[1].rhs, 1) self.assertEqual(cst[2].name, 'quad_geq') self.assertDictEqual(cst[2].linear.to_dict(use_name=True), { 'x': 1, 'y': 1 }) self.assertDictEqual(cst[2].quadratic.to_dict(use_name=True), { ('x', 'x'): 1, ('y', 'z'): -1, ('z', 'z'): 2 }) self.assertEqual(cst[2].sense, Constraint.Sense.GE) self.assertEqual(cst[2].rhs, 1) except MissingOptionalLibraryError as ex: self.skipTest(str(ex)) except RuntimeError as ex: self.fail(str(ex))
def test_linear_constraints_handling(self): """test linear constraints handling""" q_p = QuadraticProgram() q_p.binary_var('x') q_p.binary_var('y') q_p.binary_var('z') q_p.linear_constraint({'x': 1}, '==', 1) q_p.linear_constraint({'y': 1}, '<=', 1) q_p.linear_constraint({'z': 1}, '>=', 1) self.assertEqual(q_p.get_num_linear_constraints(), 3) lin = q_p.linear_constraints self.assertEqual(len(lin), 3) self.assertDictEqual(lin[0].linear.to_dict(), {0: 1}) self.assertDictEqual(lin[0].linear.to_dict(use_name=True), {'x': 1}) self.assertListEqual(lin[0].linear.to_array().tolist(), [1, 0, 0]) self.assertEqual(lin[0].sense, Constraint.Sense.EQ) self.assertEqual(lin[0].rhs, 1) self.assertEqual(lin[0].name, 'c0') self.assertEqual(q_p.get_linear_constraint(0).name, 'c0') self.assertEqual(q_p.get_linear_constraint('c0').name, 'c0') self.assertDictEqual(lin[1].linear.to_dict(), {1: 1}) self.assertDictEqual(lin[1].linear.to_dict(use_name=True), {'y': 1}) self.assertListEqual(lin[1].linear.to_array().tolist(), [0, 1, 0]) self.assertEqual(lin[1].sense, Constraint.Sense.LE) self.assertEqual(lin[1].rhs, 1) self.assertEqual(lin[1].name, 'c1') self.assertEqual(q_p.get_linear_constraint(1).name, 'c1') self.assertEqual(q_p.get_linear_constraint('c1').name, 'c1') self.assertDictEqual(lin[2].linear.to_dict(), {2: 1}) self.assertDictEqual(lin[2].linear.to_dict(use_name=True), {'z': 1}) self.assertListEqual(lin[2].linear.to_array().tolist(), [0, 0, 1]) self.assertEqual(lin[2].sense, Constraint.Sense.GE) self.assertEqual(lin[2].rhs, 1) self.assertEqual(lin[2].name, 'c2') self.assertEqual(q_p.get_linear_constraint(2).name, 'c2') self.assertEqual(q_p.get_linear_constraint('c2').name, 'c2') with self.assertRaises(QiskitOptimizationError): q_p.linear_constraint(name='c0') with self.assertRaises(QiskitOptimizationError): q_p.linear_constraint(name='c1') with self.assertRaises(QiskitOptimizationError): q_p.linear_constraint(name='c2') with self.assertRaises(IndexError): q_p.get_linear_constraint(4) with self.assertRaises(KeyError): q_p.get_linear_constraint('c3') q_p.remove_linear_constraint('c1') lin = q_p.linear_constraints self.assertEqual(len(lin), 2) self.assertDictEqual(lin[1].linear.to_dict(), {2: 1}) self.assertDictEqual(lin[1].linear.to_dict(use_name=True), {'z': 1}) self.assertListEqual(lin[1].linear.to_array().tolist(), [0, 0, 1]) self.assertEqual(lin[1].sense, Constraint.Sense.GE) self.assertEqual(lin[1].rhs, 1) self.assertEqual(lin[1].name, 'c2') self.assertEqual(q_p.get_linear_constraint(1).name, 'c2') self.assertEqual(q_p.get_linear_constraint('c2').name, 'c2') with self.assertRaises(KeyError): q_p.remove_linear_constraint('c1') with self.assertRaises(IndexError): q_p.remove_linear_constraint(9) q_p.linear_constraint(sense='E') self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ) q_p.linear_constraint(sense='G') self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE) q_p.linear_constraint(sense='L') self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.LE) q_p.linear_constraint(sense='EQ') self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ) q_p.linear_constraint(sense='GE') self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE) q_p.linear_constraint(sense='LE') self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.LE) q_p.linear_constraint(sense='=') self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ) q_p.linear_constraint(sense='>') self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE) q_p.linear_constraint(sense='<') with self.assertRaises(QiskitOptimizationError): q_p.linear_constraint(sense='=>')
def test_read_from_lp_file(self): """test read lp file""" try: q_p = QuadraticProgram() with self.assertRaises(FileNotFoundError): q_p.read_from_lp_file("") with self.assertRaises(FileNotFoundError): q_p.read_from_lp_file("no_file.txt") lp_file = self.get_resource_path("test_quadratic_program.lp", "problems/resources") q_p.read_from_lp_file(lp_file) self.assertEqual(q_p.name, "my problem") self.assertEqual(q_p.get_num_vars(), 3) self.assertEqual(q_p.get_num_binary_vars(), 1) self.assertEqual(q_p.get_num_integer_vars(), 1) self.assertEqual(q_p.get_num_continuous_vars(), 1) self.assertEqual(q_p.get_num_linear_constraints(), 3) self.assertEqual(q_p.get_num_quadratic_constraints(), 3) self.assertEqual(q_p.variables[0].name, "x") self.assertEqual(q_p.variables[0].vartype, Variable.Type.BINARY) self.assertEqual(q_p.variables[0].lowerbound, 0) self.assertEqual(q_p.variables[0].upperbound, 1) self.assertEqual(q_p.variables[1].name, "y") self.assertEqual(q_p.variables[1].vartype, Variable.Type.INTEGER) self.assertEqual(q_p.variables[1].lowerbound, -1) self.assertEqual(q_p.variables[1].upperbound, 5) self.assertEqual(q_p.variables[2].name, "z") self.assertEqual(q_p.variables[2].vartype, Variable.Type.CONTINUOUS) self.assertEqual(q_p.variables[2].lowerbound, -1) self.assertEqual(q_p.variables[2].upperbound, 5) self.assertEqual(q_p.objective.sense, QuadraticObjective.Sense.MINIMIZE) self.assertEqual(q_p.objective.constant, 1) self.assertDictEqual(q_p.objective.linear.to_dict(use_name=True), { "x": 1, "y": -1, "z": 10 }) self.assertDictEqual( q_p.objective.quadratic.to_dict(use_name=True), { ("x", "x"): 0.5, ("y", "z"): -1 }, ) cst = q_p.linear_constraints self.assertEqual(cst[0].name, "lin_eq") self.assertDictEqual(cst[0].linear.to_dict(use_name=True), { "x": 1, "y": 2 }) self.assertEqual(cst[0].sense, Constraint.Sense.EQ) self.assertEqual(cst[0].rhs, 1) self.assertEqual(cst[1].name, "lin_leq") self.assertDictEqual(cst[1].linear.to_dict(use_name=True), { "x": 1, "y": 2 }) self.assertEqual(cst[1].sense, Constraint.Sense.LE) self.assertEqual(cst[1].rhs, 1) self.assertEqual(cst[2].name, "lin_geq") self.assertDictEqual(cst[2].linear.to_dict(use_name=True), { "x": 1, "y": 2 }) self.assertEqual(cst[2].sense, Constraint.Sense.GE) self.assertEqual(cst[2].rhs, 1) cst = q_p.quadratic_constraints self.assertEqual(cst[0].name, "quad_eq") self.assertDictEqual(cst[0].linear.to_dict(use_name=True), { "x": 1, "y": 1 }) self.assertDictEqual( cst[0].quadratic.to_dict(use_name=True), { ("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2 }, ) self.assertEqual(cst[0].sense, Constraint.Sense.EQ) self.assertEqual(cst[0].rhs, 1) self.assertEqual(cst[1].name, "quad_leq") self.assertDictEqual(cst[1].linear.to_dict(use_name=True), { "x": 1, "y": 1 }) self.assertDictEqual( cst[1].quadratic.to_dict(use_name=True), { ("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2 }, ) self.assertEqual(cst[1].sense, Constraint.Sense.LE) self.assertEqual(cst[1].rhs, 1) self.assertEqual(cst[2].name, "quad_geq") self.assertDictEqual(cst[2].linear.to_dict(use_name=True), { "x": 1, "y": 1 }) self.assertDictEqual( cst[2].quadratic.to_dict(use_name=True), { ("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2 }, ) self.assertEqual(cst[2].sense, Constraint.Sense.GE) self.assertEqual(cst[2].rhs, 1) except RuntimeError as ex: self.fail(str(ex))