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)