def test_get_quadratic(self):
op = OptimizationProblem()
n = 10
op.variables.add(names=[str(i) for i in range(n)])
obj = op.objective
obj.set_quadratic([1.5 * i for i in range(n)])
sp = obj.get_quadratic(8)
self.assertListEqual(sp.ind, [8])
self.assertListEqual(sp.val, [12.0])
sp = obj.get_quadratic('1', 3)
self.assertListEqual(sp[0].ind, [1])
self.assertListEqual(sp[0].val, [1.5])
self.assertListEqual(sp[1].ind, [2])
self.assertListEqual(sp[1].val, [3.0])
self.assertListEqual(sp[2].ind, [3])
self.assertListEqual(sp[2].val, [4.5])
sp = obj.get_quadratic([3, '1', 5])
self.assertListEqual(sp[0].ind, [3])
self.assertListEqual(sp[0].val, [4.5])
self.assertListEqual(sp[1].ind, [1])
self.assertListEqual(sp[1].val, [1.5])
self.assertListEqual(sp[2].ind, [5])
self.assertListEqual(sp[2].val, [7.5])
sp = obj.get_quadratic(range(n))
for i in range(n):
self.assertListEqual(sp[i].ind, [i])
self.assertListEqual(sp[i].val, [1.5 * i])
def test_get_sense(self):
op = OptimizationProblem()
self.assertEqual(op.objective.sense[op.objective.get_sense()], 'minimize')
op.objective.set_sense(op.objective.sense.maximize)
self.assertEqual(op.objective.sense[op.objective.get_sense()], 'maximize')
op.objective.set_sense(op.objective.sense.minimize)
self.assertEqual(op.objective.sense[op.objective.get_sense()], 'minimize')
def test_set_quadratic_coefficients(self):
op = OptimizationProblem()
n = 3
op.variables.add(names=[str(i) for i in range(n)])
obj = op.objective
obj.set_quadratic_coefficients(0, 1, 1.0)
lst = op.objective.get_quadratic(range(n))
self.assertListEqual(lst[0].ind, [1])
self.assertListEqual(lst[0].val, [1.0])
self.assertListEqual(lst[1].ind, [0])
self.assertListEqual(lst[1].val, [1.0])
self.assertListEqual(lst[2].ind, [])
self.assertListEqual(lst[2].val, [])
obj.set_quadratic_coefficients([(1, 1, 2.0), (0, 2, 3.0)])
lst = op.objective.get_quadratic(range(n))
self.assertListEqual(lst[0].ind, [1, 2])
self.assertListEqual(lst[0].val, [1.0, 3.0])
self.assertListEqual(lst[1].ind, [0, 1])
self.assertListEqual(lst[1].val, [1.0, 2.0])
self.assertListEqual(lst[2].ind, [0])
self.assertListEqual(lst[2].val, [3.0])
obj.set_quadratic_coefficients([(0, 1, 4.0), (1, 0, 5.0)])
lst = op.objective.get_quadratic(range(n))
self.assertListEqual(lst[0].ind, [1, 2])
self.assertListEqual(lst[0].val, [5.0, 3.0])
self.assertListEqual(lst[1].ind, [0, 1])
self.assertListEqual(lst[1].val, [5.0, 2.0])
self.assertListEqual(lst[2].ind, [0])
self.assertListEqual(lst[2].val, [3.0])
def test_set_names(self):
op = OptimizationProblem()
op.linear_constraints.add(names=["c0", "c1", "c2", "c3"])
op.linear_constraints.set_names("c1", "second")
self.assertEqual(op.linear_constraints.get_names(1), 'second')
op.linear_constraints.set_names([("c3", "last"), (2, "middle")])
self.assertListEqual(op.linear_constraints.get_names(),
['c0', 'second', 'middle', 'last'])
def test_set_range_values(self):
op = OptimizationProblem()
op.linear_constraints.add(names=["c0", "c1", "c2", "c3"])
op.linear_constraints.set_range_values("c1", 1.0)
self.assertListEqual(op.linear_constraints.get_range_values(),
[0.0, 1.0, 0.0, 0.0])
op.linear_constraints.set_range_values([("c3", 2.0), (2, -1.0)])
self.assertListEqual(op.linear_constraints.get_range_values(),
[0.0, 1.0, -1.0, 2.0])
def test_set_senses(self):
op = OptimizationProblem()
op.linear_constraints.add(names=["c0", "c1", "c2", "c3"])
self.assertListEqual(op.linear_constraints.get_senses(),
['E', 'E', 'E', 'E'])
op.linear_constraints.set_senses("c1", "G")
self.assertEqual(op.linear_constraints.get_senses(1), 'G')
op.linear_constraints.set_senses([("c3", "L"), (2, "R")])
self.assertListEqual(op.linear_constraints.get_senses(),
['E', 'G', 'R', 'L'])
def test_get_names(self):
op = OptimizationProblem()
op.linear_constraints.add(names=["c" + str(i) for i in range(10)])
self.assertEqual(op.linear_constraints.get_num(), 10)
self.assertEqual(op.linear_constraints.get_names(8), 'c8')
self.assertListEqual(op.linear_constraints.get_names([2, 0, 5]),
['c2', 'c0', 'c5'])
self.assertEqual(
op.linear_constraints.get_names(),
['c0', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9'])
def test_get_quadratic(self):
op = OptimizationProblem()
n = 3
op.variables.add(names=[str(i) for i in range(n)])
obj = op.objective
obj.set_quadratic_coefficients(0, 1, 1.0)
self.assertEqual(obj.get_quadratic_coefficients('1', 0), 1.0)
obj.set_quadratic_coefficients([(1, 1, 2.0), (0, 2, 3.0), (1, 0, 5.0)])
self.assertListEqual(obj.get_quadratic_coefficients([(1, 0), (1, "1"), (2, "0")]),
[5.0, 2.0, 3.0])
def test_get_rhs(self):
op = OptimizationProblem()
op.linear_constraints.add(rhs=[1.5 * i for i in range(10)],
names=[str(i) for i in range(10)])
self.assertEqual(op.linear_constraints.get_num(), 10)
self.assertAlmostEqual(op.linear_constraints.get_rhs(8), 12.0)
self.assertListEqual(op.linear_constraints.get_rhs([2, "0", 5]),
[3.0, 0.0, 7.5])
self.assertEqual(op.linear_constraints.get_rhs(),
[0.0, 1.5, 3.0, 4.5, 6.0, 7.5, 9.0, 10.5, 12.0, 13.5])
def test_inequality_binary(self):
op = OptimizationProblem()
op.variables.add(names=['x', 'y', 'z'], types='B' * 3)
op.linear_constraints.add(lin_expr=[
SparsePair(ind=['x', 'y'], val=[1, 1]),
SparsePair(ind=['y', 'z'], val=[1, -1]),
SparsePair(ind=['z', 'x'], val=[1, 2])
],
senses=['E', 'L', 'G'],
rhs=[1, 2, 3],
names=['xy', 'yz', 'zx'])
conv = InequalityToEqualityConverter()
op2 = conv.encode(op)
self.assertEqual(op.get_problem_name(), op2.get_problem_name())
self.assertEqual(op.get_problem_type(), op2.get_problem_type())
cst = op2.linear_constraints
self.assertListEqual(cst.get_names(), ['xy', 'yz', 'zx'])
self.assertListEqual(cst.get_senses(), ['E', 'E', 'E'])
self.assertListEqual(cst.get_rhs(), [1, 2, 3])
def test_empty_problem(self):
op = OptimizationProblem()
conv = InequalityToEqualityConverter()
op = conv.encode(op)
conv = IntegerToBinaryConverter()
op = conv.encode(op)
conv = PenalizeLinearEqualityConstraints()
op = conv.encode(op)
conv = OptimizationProblemToOperator()
qubitop, shift = conv.encode(op)
self.assertEqual(shift, 0.0)
def test_get_num_quadratic_nonzeros(self):
op = OptimizationProblem()
n = 3
op.variables.add(names=[str(i) for i in range(n)])
obj = op.objective
obj.set_quadratic_coefficients(0, 1, 1.0)
self.assertEqual(obj.get_num_quadratic_nonzeros(), 2)
obj.set_quadratic_coefficients([(1, 1, 2.0), (0, 2, 3.0)])
self.assertEqual(obj.get_num_quadratic_nonzeros(), 5)
obj.set_quadratic_coefficients([(0, 1, 4.0), (1, 0, 0.0)])
self.assertEqual(obj.get_num_quadratic_nonzeros(), 3)
def test_get_linear(self):
op = OptimizationProblem()
n = 10
op.variables.add(names=[str(i) for i in range(n)])
obj = op.objective
obj.set_linear([(i, 1.5 * i) for i in range(n)])
self.assertEqual(op.variables.get_num(), 10)
self.assertEqual(obj.get_linear(8), 12)
self.assertListEqual(obj.get_linear('1', 3), [1.5, 3.0, 4.5])
self.assertListEqual(obj.get_linear([2, '0', 5]), [3.0, 0.0, 7.5])
self.assertListEqual(obj.get_linear(range(n)),
[0.0, 1.5, 3.0, 4.5, 6.0, 7.5, 9.0, 10.5, 12.0, 13.5])
def test_get_coefficients(self):
op = OptimizationProblem()
op.variables.add(names=["x0", "x1"])
op.linear_constraints.add(names=["c0", "c1"],
lin_expr=[[[1], [1.0]], [[0, 1], [2.0,
-1.0]]])
self.assertAlmostEqual(
op.linear_constraints.get_coefficients("c0", "x1"), 1.0)
self.assertListEqual(
op.linear_constraints.get_coefficients([("c1", "x0"),
("c1", "x1")]),
[2.0, -1.0])
def test_get_senses(self):
op = OptimizationProblem()
op.linear_constraints.add(senses=["E", "G", "L", "R"],
names=[str(i) for i in range(4)])
self.assertEqual(op.linear_constraints.get_num(), 4)
self.assertEqual(op.linear_constraints.get_senses(1), 'G')
self.assertListEqual(op.linear_constraints.get_senses("1", 3),
['G', 'L', 'R'])
self.assertListEqual(op.linear_constraints.get_senses([2, "0", 1]),
['L', 'E', 'G'])
self.assertListEqual(op.linear_constraints.get_senses(),
['E', 'G', 'L', 'R'])
def test_set_linear(self):
op = OptimizationProblem()
n = 4
op.variables.add(names=[str(i) for i in range(n)])
self.assertDictEqual(op.objective.get_linear(), {})
op.objective.set_linear(0, 1.0)
self.assertDictEqual(op.objective.get_linear(), {0: 1.0})
self.assertListEqual(op.objective.get_linear(range(n)), [1.0, 0.0, 0.0, 0.0])
op.objective.set_linear('3', -1.0)
self.assertDictEqual(op.objective.get_linear(), {0: 1.0, 3: -1.0})
op.objective.set_linear([("2", 2.0), (1, 0.5)])
self.assertDictEqual(op.objective.get_linear(), {0: 1.0, 1: 0.5, 2: 2.0, 3: -1.0})
self.assertListEqual(op.objective.get_linear(range(n)), [1.0, 0.5, 2.0, -1.0])
def test_set_coeffients(self):
op = OptimizationProblem()
op.linear_constraints.add(names=["c0", "c1", "c2", "c3"])
op.variables.add(names=["x0", "x1"])
op.linear_constraints.set_coefficients("c0", "x1", 1.0)
sp = op.linear_constraints.get_rows(0)
self.assertListEqual(sp.ind, [1])
self.assertListEqual(sp.val, [1.0])
op.linear_constraints.set_coefficients([("c2", "x0", 2.0),
("c2", "x1", -1.0)])
sp = op.linear_constraints.get_rows("c2")
self.assertListEqual(sp.ind, [0, 1])
self.assertListEqual(sp.val, [2.0, -1.0])
def test_penalize_binary(self):
op = OptimizationProblem()
op.variables.add(names=['x', 'y', 'z'], types='B' * 3)
op.linear_constraints.add(lin_expr=[
SparsePair(ind=['x', 'y'], val=[1, 1]),
SparsePair(ind=['y', 'z'], val=[1, -1])
],
senses=['E', 'E'],
rhs=[1, 2],
names=['xy', 'yz'])
self.assertEqual(op.linear_constraints.get_num(), 2)
conv = PenalizeLinearEqualityConstraints()
op2 = conv.encode(op)
self.assertEqual(op2.linear_constraints.get_num(), 0)
def test_penalize_sense(self):
op = OptimizationProblem()
op.variables.add(names=['x', 'y', 'z'], types='B' * 3)
op.linear_constraints.add(lin_expr=[
SparsePair(ind=['x', 'y'], val=[1, 1]),
SparsePair(ind=['y', 'z'], val=[1, -1]),
SparsePair(ind=['z', 'x'], val=[1, 2])
],
senses=['E', 'L', 'G'],
rhs=[1, 2, 3],
names=['xy', 'yz', 'zx'])
self.assertEqual(op.linear_constraints.get_num(), 3)
conv = PenalizeLinearEqualityConstraints()
self.assertRaises(QiskitOptimizationError, lambda: conv.encode(op))
def test_add(self):
op = OptimizationProblem()
op.variables.add(names=["x1", "x2", "x3"])
op.linear_constraints.add(lin_expr=[
SparsePair(ind=["x1", "x3"], val=[1.0, -1.0]),
SparsePair(ind=["x1", "x2"], val=[1.0, 1.0]),
SparsePair(ind=["x1", "x2", "x3"], val=[-1.0] * 3),
SparsePair(ind=["x2", "x3"], val=[10.0, -2.0])
],
senses=["E", "L", "G", "R"],
rhs=[0.0, 1.0, -1.0, 2.0],
range_values=[0.0, 0.0, 0.0, -10.0],
names=["c0", "c1", "c2", "c3"])
self.assertListEqual(op.linear_constraints.get_rhs(),
[0.0, 1.0, -1.0, 2.0])
def test_delete(self):
op = OptimizationProblem()
op.linear_constraints.add(names=[str(i) for i in range(10)])
self.assertEqual(op.linear_constraints.get_num(), 10)
op.linear_constraints.delete(8)
self.assertListEqual(op.linear_constraints.get_names(),
['0', '1', '2', '3', '4', '5', '6', '7', '9'])
op.linear_constraints.delete("1", 3)
self.assertListEqual(op.linear_constraints.get_names(),
['0', '4', '5', '6', '7', '9'])
op.linear_constraints.delete([2, "0", 5])
self.assertListEqual(op.linear_constraints.get_names(),
['4', '6', '7'])
op.linear_constraints.delete()
self.assertListEqual(op.linear_constraints.get_names(), [])
def test_get_num_nonzeros(self):
op = OptimizationProblem()
op.variables.add(names=["x1", "x2", "x3"])
op.linear_constraints.add(names=["c0", "c1", "c2", "c3"],
lin_expr=[
SparsePair(ind=["x1", "x3"],
val=[1.0, -1.0]),
SparsePair(ind=["x1", "x2"],
val=[1.0, 1.0]),
SparsePair(ind=["x1", "x2", "x3"],
val=[-1.0] * 3),
SparsePair(ind=["x2", "x3"],
val=[10.0, -2.0])
])
self.assertEqual(op.linear_constraints.get_num_nonzeros(), 9)
op.linear_constraints.set_coefficients("c0", "x3", 0)
self.assertEqual(op.linear_constraints.get_num_nonzeros(), 8)
def test_integer_to_binary(self):
op = OptimizationProblem()
op.variables.add(names=['x', 'y', 'z'],
types='BIC',
lb=[0, 0, 0],
ub=[1, 5, 10])
self.assertEqual(op.variables.get_num(), 3)
conv = IntegerToBinaryConverter()
op2 = conv.encode(op)
print(op2.variables.get_num())
names = op2.variables.get_names()
self.assertIn('x', names)
self.assertIn('z', names)
vars = op2.variables
self.assertEqual(vars.get_lower_bounds('x'), 0.0)
self.assertEqual(vars.get_lower_bounds('z'), 0.0)
self.assertEqual(vars.get_upper_bounds('x'), 1.0)
self.assertEqual(vars.get_upper_bounds('z'), 10.0)
self.assertListEqual(vars.get_types(['x', 'z']), ['B', 'C'])
def test_set_linear_components(self):
op = OptimizationProblem()
op.linear_constraints.add(names=["c0", "c1", "c2", "c3"])
op.variables.add(names=["x0", "x1"])
op.linear_constraints.set_linear_components("c0", [["x0"], [1.0]])
sp = op.linear_constraints.get_rows("c0")
self.assertListEqual(sp.ind, [0])
self.assertListEqual(sp.val, [1.0])
op.linear_constraints.set_linear_components([("c3",
SparsePair(ind=["x1"],
val=[-1.0])),
(2, [[0, 1], [-2.0,
3.0]])])
sp = op.linear_constraints.get_rows("c3")
self.assertListEqual(sp.ind, [1])
self.assertListEqual(sp.val, [-1.0])
sp = op.linear_constraints.get_rows(2)
self.assertListEqual(sp.ind, [0, 1])
self.assertListEqual(sp.val, [-2.0, 3.0])
def test_get_rows(self):
op = OptimizationProblem()
op.variables.add(names=["x1", "x2", "x3"])
op.linear_constraints.add(names=["c0", "c1", "c2", "c3"],
lin_expr=[
SparsePair(ind=["x1", "x3"],
val=[1.0, -1.0]),
SparsePair(ind=["x1", "x2"],
val=[1.0, 1.0]),
SparsePair(ind=["x1", "x2", "x3"],
val=[-1.0] * 3),
SparsePair(ind=["x2", "x3"],
val=[10.0, -2.0])
])
sp = op.linear_constraints.get_rows(0)
self.assertListEqual(sp.ind, [0, 2])
self.assertListEqual(sp.val, [1.0, -1.0])
sp = op.linear_constraints.get_rows(1, 3)
self.assertListEqual(sp[0].ind, [0, 1])
self.assertListEqual(sp[0].val, [1.0, 1.0])
self.assertListEqual(sp[1].ind, [0, 1, 2])
self.assertListEqual(sp[1].val, [-1.0, -1.0, -1.0])
self.assertListEqual(sp[2].ind, [1, 2])
self.assertListEqual(sp[2].val, [10.0, -2.0])
sp = op.linear_constraints.get_rows(['c2', 0])
self.assertListEqual(sp[0].ind, [0, 1, 2])
self.assertListEqual(sp[0].val, [-1.0, -1.0, -1.0])
self.assertListEqual(sp[1].ind, [0, 2])
self.assertListEqual(sp[1].val, [1.0, -1.0])
sp = op.linear_constraints.get_rows()
self.assertListEqual(sp[0].ind, [0, 2])
self.assertListEqual(sp[0].val, [1.0, -1.0])
self.assertListEqual(sp[1].ind, [0, 1])
self.assertListEqual(sp[1].val, [1.0, 1.0])
self.assertListEqual(sp[2].ind, [0, 1, 2])
self.assertListEqual(sp[2].val, [-1.0, -1.0, -1.0])
self.assertListEqual(sp[3].ind, [1, 2])
self.assertListEqual(sp[3].val, [10.0, -2.0])
def test_set_quadratic(self):
op = OptimizationProblem()
n = 3
op.variables.add(names=[str(i) for i in range(n)])
obj = op.objective
obj.set_quadratic([SparsePair(ind=[0, 1, 2], val=[1.0, -2.0, 0.5]),
([0, 1], [-2.0, -1.0]),
SparsePair(ind=[0, 2], val=[0.5, -3.0])])
lst = obj.get_quadratic(range(n))
self.assertListEqual(lst[0].ind, [0, 1, 2])
self.assertListEqual(lst[0].val, [1.0, -2.0, 0.5])
self.assertListEqual(lst[1].ind, [0, 1])
self.assertListEqual(lst[1].val, [-2.0, -1.0])
self.assertListEqual(lst[2].ind, [0, 2])
self.assertListEqual(lst[2].val, [0.5, -3.0])
obj.set_quadratic([1.0, 2.0, 3.0])
lst = obj.get_quadratic(range(n))
self.assertListEqual(lst[0].ind, [0])
self.assertListEqual(lst[0].val, [1.0])
self.assertListEqual(lst[1].ind, [1])
self.assertListEqual(lst[1].val, [2.0])
self.assertListEqual(lst[2].ind, [2])
self.assertListEqual(lst[2].val, [3.0])
def test_set_empty_quadratic(self):
op = OptimizationProblem()
op.objective.set_quadratic([])
self.assertRaises(TypeError, lambda: op.objective.set_quadratic())
def test_obj_sense(self):
op = OptimizationProblem()
self.assertEqual(op.objective.sense.minimize, 1)
self.assertEqual(op.objective.sense.maximize, -1)
self.assertEqual(op.objective.sense[1], 'minimize')
self.assertEqual(op.objective.sense[-1], 'maximize')
def test_offset(self):
op = OptimizationProblem()
self.assertEqual(op.objective.get_offset(), 0.0)
op.objective.set_offset(3.14)
self.assertEqual(op.objective.get_offset(), 3.14)
def test_get_name(self):
op = OptimizationProblem()
op.objective.set_name('cost')
self.assertEqual(op.objective.get_name(), 'cost')
