def test_socp(self):
"""Test SOCP problems.
"""
for solver in self.solvers:
# Basic.
p = Problem(Minimize(self.b), [pnorm(self.x, p=2) <= self.b])
pmod = Problem(Minimize(self.b), [SOC(self.b, self.x)])
self.assertTrue(ConeMatrixStuffing().accepts(pmod))
p_new = ConeMatrixStuffing().apply(pmod)
if not solver.accepts(p_new[0]):
return
result = p.solve(solver.name())
sltn = solve_wrapper(solver, p_new[0])
self.assertAlmostEqual(sltn.opt_val, result)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result)
for var in p.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value)
# More complex.
p = Problem(Minimize(self.b), [pnorm(self.x/2 + self.y[:2], p=2) <= self.b+5,
self.x >= 1, self.y == 5])
pmod = Problem(Minimize(self.b), [SOC(self.b+5, self.x/2 + self.y[:2]),
self.x >= 1, self.y == 5])
self.assertTrue(ConeMatrixStuffing().accepts(pmod))
result = p.solve(solver.name())
p_new = ConeMatrixStuffing().apply(pmod)
sltn = solve_wrapper(solver, p_new[0])
self.assertAlmostEqual(sltn.opt_val, result, places=2)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result, places=2)
for var in p.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value, places=2)
def test_matrix_lp(self):
for solver in self.solvers:
T = Constant(numpy.ones((2, 2))).value
p = Problem(Minimize(1 + self.a),
[self.A == T + self.a, self.a >= 0])
self.assertTrue(ConeMatrixStuffing().accepts(p))
result = p.solve(solver.name())
p_new = ConeMatrixStuffing().apply(p)
sltn = solver.solve(p_new[0], False, False, {})
self.assertAlmostEqual(sltn.opt_val, result - 1)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result)
for var in p.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value)
T = Constant(numpy.ones((2, 3)) * 2).value
p = Problem(
Minimize(1),
[self.A >= T * self.C, self.A == self.B, self.C == T.T])
self.assertTrue(ConeMatrixStuffing().accepts(p))
result = p.solve(solver.name())
p_new = ConeMatrixStuffing().apply(p)
sltn = solver.solve(p_new[0], False, False, {})
self.assertAlmostEqual(sltn.opt_val, result - 1)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result)
for var in p.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value)
def exp_cone(self):
"""Test exponential cone problems.
"""
for solver in self.solvers:
# Basic.
p = Problem(Minimize(self.b), [exp(self.a) <= self.b, self.a >= 1])
pmod = Problem(Minimize(self.b), [ExpCone(self.a, Constant(1), self.b), self.a >= 1])
self.assertTrue(ConeMatrixStuffing().accepts(pmod))
p_new = ConeMatrixStuffing().apply(pmod)
if not solver.accepts(p_new[0]):
return
result = p.solve(solver.name())
sltn = solve_wrapper(solver, p_new[0])
self.assertAlmostEqual(sltn.opt_val, result, places=1)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result, places=1)
for var in pmod.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value, places=1)
# More complex.
p = Problem(Minimize(self.b), [exp(self.a/2 + self.c) <= self.b+5,
self.a >= 1, self.c >= 5])
pmod = Problem(Minimize(self.b), [ExpCone(self.a/2 + self.c, Constant(1), self.b+5),
self.a >= 1, self.c >= 5])
self.assertTrue(ConeMatrixStuffing().accepts(pmod))
result = p.solve(solver.name())
p_new = ConeMatrixStuffing().apply(pmod)
sltn = solve_wrapper(solver, p_new[0])
self.assertAlmostEqual(sltn.opt_val, result, places=0)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result, places=0)
for var in pmod.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value, places=0)
def mat_norm_2(self, solver):
A = np.random.randn(5, 3)
B = np.random.randn(5, 2)
p = Problem(Minimize(norm(A @ self.C - B, 2)))
s = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(lstsq(A, B)[0],
s.primal_vars[var.id], places=1)
def norm_2(self, solver):
A = np.random.randn(10, 5)
b = np.random.randn(10)
p = Problem(Minimize(norm(A @ self.w - b, 2)))
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(lstsq(A, b)[0].flatten(), var.value,
places=1)
def square_affine(self, solver):
A = numpy.random.randn(10, 2)
b = numpy.random.randn(10, 1)
p = Problem(Minimize(sum_squares(A * self.x - b)))
s = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(lstsq(A, b)[0].flatten(),
s.primal_vars[var.id],
places=1)
def square_affine(self, solver):
A = np.random.randn(10, 2)
b = np.random.randn(10)
p = Problem(Minimize(sum_squares(A * self.x - b)))
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(lstsq(A, b)[0].flatten(),
var.value,
places=1)
def maximize_problem(self, solver):
A = np.random.randn(5, 2)
A = np.maximum(A, 0)
b = np.random.randn(5)
b = np.maximum(b, 0)
p = Problem(Maximize(-sum(self.x)), [self.x >= 0, A * self.x <= b])
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual([0., 0.], var.value, places=3)
def norm_2(self, solver):
A = numpy.random.randn(10, 5)
b = numpy.random.randn(10, 1)
p = Problem(Minimize(norm(A * self.w - b, 2)))
s = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(lstsq(A, b)[0].flatten(),
s.primal_vars[var.id],
places=1)
def affine_problem(self, solver):
A = numpy.random.randn(5, 2)
A = numpy.maximum(A, 0)
b = numpy.random.randn(5, 1)
b = numpy.maximum(b, 0)
p = Problem(Minimize(sum(self.x)), [self.x >= 0, A * self.x <= b])
s = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual([0., 0.], s.primal_vars[var.id])
def quad_over_lin(self, solver):
p = Problem(Minimize(0.5 * quad_over_lin(abs(self.x-1), 1)),
[self.x <= -1])
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(np.array([-1., -1.]),
var.value, places=4)
for con in p.constraints:
self.assertItemsAlmostEqual(np.array([2., 2.]),
con.dual_value, places=4)
def quad_over_lin(self, solver):
p = Problem(Minimize(0.5 * quad_over_lin(abs(self.x - 1), 1)),
[self.x <= -1])
s = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(numpy.array([-1., -1.]),
s.primal_vars[var.id])
for con in p.constraints:
self.assertItemsAlmostEqual(numpy.array([2., 2.]),
s.dual_vars[con.id])
def quad_form_bound(self, solver):
P = numpy.matrix([[13, 12, -2], [12, 17, 6], [-2, 6, 12]])
q = numpy.matrix([[-22], [-14.5], [13]])
r = 1
y_star = numpy.matrix([[1], [0.5], [-1]])
p = Problem(Minimize(0.5 * QuadForm(self.y, P) + q.T * self.y + r),
[self.y >= -1, self.y <= 1])
s = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(y_star, s.primal_vars[var.id])
def quad_form_coeff(self, solver):
numpy.random.seed(0)
A = numpy.random.randn(5, 5)
z = numpy.random.randn(5, 1)
P = A.T.dot(A)
q = -2 * P.dot(z)
p = Problem(Minimize(QuadForm(self.w, P) + q.T * self.w))
qp_solution = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(z, qp_solution.primal_vars[var.id])
def quad_form_bound(self, solver):
P = np.array([[13, 12, -2], [12, 17, 6], [-2, 6, 12]])
q = np.array([[-22], [-14.5], [13]])
r = 1
y_star = np.array([[1], [0.5], [-1]])
p = Problem(Minimize(0.5 * QuadForm(self.y, P) + q.T * self.y + r),
[self.y >= -1, self.y <= 1])
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(y_star, var.value, places=4)
def quad_form_coeff(self, solver):
np.random.seed(0)
A = np.random.randn(5, 5)
z = np.random.randn(5)
P = A.T.dot(A)
q = -2 * P.dot(z)
p = Problem(Minimize(QuadForm(self.w, P) + q.T * self.w))
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(z, var.value, places=4)
def rep_quad_form(self, solver) -> None:
"""A problem where the quad_form term is used multiple times.
"""
np.random.seed(0)
A = np.random.randn(5, 5)
z = np.random.randn(5)
P = A.T.dot(A)
q = -2 * P.dot(z)
qf = QuadForm(self.w, P)
p = Problem(Minimize(0.5 * qf + 0.5 * qf + q.T @ self.w))
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(z, var.value, places=4)
def test_vector_lp(self):
for solver in self.solvers:
c = Constant(numpy.array([1, 2]))
p = Problem(Minimize(c.T * self.x), [self.x >= c])
result = p.solve(solver.name())
self.assertTrue(ConeMatrixStuffing().accepts(p))
p_new = ConeMatrixStuffing().apply(p)
# result_new = p_new[0].solve(solver.name())
# self.assertAlmostEqual(result, result_new)
self.assertTrue(solver.accepts(p_new[0]))
sltn = solver.solve(p_new[0], False, False, {})
self.assertAlmostEqual(sltn.opt_val, result)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
p_new1 = ConeMatrixStuffing().apply(p)
self.assertTrue(solver.accepts(p_new1[0]))
sltn = solver.solve(p_new1[0], False, False, {})
self.assertAlmostEqual(sltn.opt_val, result)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new1[1])
self.assertAlmostEqual(inv_sltn.opt_val, result)
self.assertItemsAlmostEqual(inv_sltn.primal_vars[self.x.id],
self.x.value)
A = Constant(numpy.array([[3, 5], [1, 2]]).T).value
Imat = Constant([[1, 0], [0, 1]])
p = Problem(Minimize(c.T * self.x + self.a), [
A * self.x >= [-1, 1], 4 * Imat * self.z == self.x,
self.z >= [2, 2], self.a >= 2
])
self.assertTrue(ConeMatrixStuffing().accepts(p))
result = p.solve(solver.name())
p_new = ConeMatrixStuffing().apply(p)
result_new = p_new[0].solve(solver.name())
self.assertAlmostEqual(result, result_new)
self.assertTrue(solver.accepts(p_new[0]))
sltn = solver.solve(p_new[0], False, False, {})
self.assertAlmostEqual(sltn.opt_val, result, places=1)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result, places=1)
for var in p.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value,
places=1)
def power_matrix(self, solver):
p = Problem(Minimize(sum(power(self.A - 3., 2))), [])
s = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual([3., 3., 3., 3.],
s.primal_vars[var.id])
def power(self, solver):
p = Problem(Minimize(sum(power(self.x, 2))), [])
s = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual([0., 0.], var.value, places=4)
def power_matrix(self, solver):
p = Problem(Minimize(sum(power(self.A - 3., 2))), [])
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual([3., 3., 3., 3.], var.value, places=4)
