def test_normInf(self): # Constant argument. p = Problem(Minimize(normInf(-2))) result = p.solve() self.assertAlmostEqual(result, 2) # Scalar arguments. p = Problem(Minimize(normInf(self.a)), [self.a >= 2]) result = p.solve() self.assertAlmostEqual(result, 2) self.assertAlmostEqual(self.a.value, 2) p = Problem(Minimize(3 * normInf(self.a + 2 * self.b) + self.c), [self.a >= 2, self.b <= -1, self.c == 3]) result = p.solve() self.assertAlmostEqual(result, 3) self.assertAlmostEqual(self.a.value + 2 * self.b.value, 0) self.assertAlmostEqual(self.c.value, 3) # Maximize p = Problem(Maximize(-normInf(self.a)), [self.a <= -2]) result = p.solve() self.assertAlmostEqual(result, -2) self.assertAlmostEqual(self.a.value, -2) # Vector arguments. p = Problem(Minimize(normInf(self.x - self.z) + 5), [self.x >= [2, 3], self.z <= [-1, -4]]) result = p.solve() self.assertAlmostEqual(float(result), 12) self.assertAlmostEqual( float(list(self.x.value)[1] - list(self.z.value)[1]), 7)
def test_dual_variables(self): p = Problem(Minimize( norm1(self.x + self.z) ), [self.x >= [2,3], [[1,2],[3,4]]*self.z == [-1,-4], norm2(self.x + self.z) <= 100]) result = p.solve() self.assertAlmostEqual(result, 4) self.assertItemsAlmostEqual(self.x.value, [4,3]) self.assertItemsAlmostEqual(self.z.value, [-4,1]) # Dual values self.assertItemsAlmostEqual(p.constraints[0].dual_value, [0, 1]) self.assertItemsAlmostEqual(p.constraints[1].dual_value, [-1, 0.5]) self.assertAlmostEqual(p.constraints[2].dual_value, 0) T = matrix(2, (2, 3)) c = matrix([3,4]) p = Problem(Minimize(1), [self.A >= T*self.C, self.A == self.B, self.C == T.T]) result = p.solve() # Dual values self.assertItemsAlmostEqual(p.constraints[0].dual_value, 4*[0]) self.assertItemsAlmostEqual(p.constraints[1].dual_value, 4*[0]) self.assertItemsAlmostEqual(p.constraints[2].dual_value, 6*[0])
def test_norm2(self): # Constant argument. p = Problem(Minimize(norm2(-2))) result = p.solve() self.assertAlmostEqual(result, 2) # Scalar arguments. p = Problem(Minimize(norm2(self.a)), [self.a <= -2]) result = p.solve() self.assertAlmostEqual(result, 2) self.assertAlmostEqual(self.a.value, -2) # Maximize p = Problem(Maximize(-norm2(self.a)), [self.a <= -2]) result = p.solve() self.assertAlmostEqual(result, -2) self.assertAlmostEqual(self.a.value, -2) # Vector arguments. p = Problem(Minimize(norm2(self.x - self.z) + 5), [self.x >= [2, 3], self.z <= [-1, -4]]) result = p.solve() self.assertAlmostEqual(result, 12.61577) self.assertItemsAlmostEqual(self.x.value, [2, 3]) self.assertItemsAlmostEqual(self.z.value, [-1, -4]) # Row arguments. p = Problem(Minimize(norm2((self.x - self.z).T) + 5), [self.x >= [2, 3], self.z <= [-1, -4]]) result = p.solve() self.assertAlmostEqual(result, 12.61577) self.assertItemsAlmostEqual(self.x.value, [2, 3]) self.assertItemsAlmostEqual(self.z.value, [-1, -4])
def test_norm1(self): # Constant argument. p = Problem(Minimize(norm1(-2))) result = p.solve() self.assertAlmostEqual(result, 2) # Scalar arguments. p = Problem(Minimize(norm1(self.a)), [self.a <= -2]) result = p.solve() self.assertAlmostEqual(result, 2) self.assertAlmostEqual(self.a.value, -2) # Maximize p = Problem(Maximize(-norm1(self.a)), [self.a <= -2]) result = p.solve() self.assertAlmostEqual(result, -2) self.assertAlmostEqual(self.a.value, -2) # Vector arguments. p = Problem(Minimize(norm1(self.x - self.z) + 5), [self.x >= [2, 3], self.z <= [-1, -4]]) result = p.solve() self.assertAlmostEqual(float(result), 15) self.assertAlmostEqual( float(list(self.x.value)[1] - list(self.z.value)[1]), 7)
def test_verbose(self): # From http://stackoverflow.com/questions/5136611/capture-stdout-from-a-script-in-python # setup the environment outputs = {True: [], False: []} backup = sys.stdout # #### for verbose in [True, False]: for solver in s.SOLVERS: sys.stdout = StringIO() # capture output p = Problem(Minimize(self.a + self.x[0]), [self.a >= 2, self.x >= 2]) if solver in s.MIP_CAPABLE: p.constraints.append(BoolVar() == 0) p.solve(verbose=verbose, solver=solver) if solver in s.EXP_CAPABLE: p = Problem(Minimize(self.a), [log(self.a) >= 2]) p.solve(verbose=verbose, solver=solver) out = sys.stdout.getvalue() # release output outputs[verbose].append(out.upper()) # #### sys.stdout.close() # close the stream sys.stdout = backup # restore original stdout for output in outputs[True]: assert len(output) > 0 for output in outputs[False]: print output assert len(output) == 0
def test_quad_form(self): with self.assertRaises(Exception) as cm: Problem(Minimize(quad_form(self.x, self.A))).solve() self.assertEqual( str(cm.exception), "At least one argument to quad_form must be constant.") with self.assertRaises(Exception) as cm: Problem(Minimize(quad_form(1, self.A))).solve() self.assertEqual(str(cm.exception), "Invalid dimensions for arguments.") with self.assertRaises(Exception) as cm: Problem(Minimize(quad_form(self.x, [[-1, 0], [0, 9]]))).solve() self.assertEqual(str(cm.exception), "P has both positive and negative eigenvalues.") P = [[4, 0], [0, 9]] p = Problem(Minimize(quad_form(self.x, P)), [self.x >= 1]) result = p.solve() self.assertAlmostEqual(result, 13, places=3) c = [1, 2] p = Problem(Minimize(quad_form(c, self.A)), [self.A >= 1]) result = p.solve() self.assertAlmostEqual(result, 9) c = [1, 2] P = [[4, 0], [0, 9]] p = Problem(Minimize(quad_form(c, P))) result = p.solve() self.assertAlmostEqual(result, 40)
def test_indexing(self): # Vector variables p = Problem(Maximize(self.x[0, 0]), [self.x[0, 0] <= 2, self.x[1, 0] == 3]) result = p.solve() self.assertAlmostEqual(result, 2) self.assertItemsAlmostEqual(self.x.value, [2, 3]) n = 10 A = matrix(range(n * n), (n, n)) x = Variable(n, n) p = Problem(Minimize(sum_entries(x)), [x == A]) result = p.solve() answer = n * n * (n * n + 1) / 2 - n * n self.assertAlmostEqual(result, answer) # Matrix variables p = Problem( Maximize(sum(self.A[i, i] + self.A[i, 1 - i] for i in range(2))), [self.A <= [[1, -2], [-3, 4]]]) result = p.solve() self.assertAlmostEqual(result, 0) self.assertItemsAlmostEqual(self.A.value, [1, -2, -3, 4]) # Indexing arithmetic expressions. exp = [[1, 2], [3, 4]] * self.z + self.x p = Problem(Minimize(exp[1, 0]), [self.x == self.z, self.z == [1, 2]]) result = p.solve() self.assertAlmostEqual(result, 12) self.assertItemsAlmostEqual(self.x.value, self.z.value)
def test_duplicate_constraints(self): eq = (self.x == 2) le = (self.x <= 2) obj = 0 def test(self): objective, constraints = self.canonicalize() sym_data = SymData(objective, constraints, SOLVERS[s.ECOS]) return (len(sym_data.constr_map[s.EQ]), len(sym_data.constr_map[s.LEQ])) Problem.register_solve("test", test) p = Problem(Minimize(obj), [eq, eq, le, le]) result = p.solve(method="test") self.assertEqual(result, (1, 1)) # Internal constraints. X = Semidef(2) obj = sum_entries(X + X) p = Problem(Minimize(obj)) result = p.solve(method="test") self.assertEqual(result, (0, 1)) # Duplicates from non-linear constraints. exp = norm(self.x, 2) prob = Problem(Minimize(0), [exp <= 1, exp <= 2]) result = prob.solve(method="test") self.assertEqual(result, (0, 4))
def test_verbose(self): # From http://stackoverflow.com/questions/5136611/capture-stdout-from-a-script-in-python # setup the environment outputs = {True: [], False: []} backup = sys.stdout # #### for verbose in [True, False]: for solver in ["ecos", "cvxopt"]: sys.stdout = StringIO() # capture output p = Problem(Minimize(self.a), [self.a >= 2]) p.solve(verbose=verbose, solver=solver) p = Problem(Minimize(self.a), [log(self.a) >= 2]) p.solve(verbose=verbose, solver=solver) out = sys.stdout.getvalue() # release output outputs[verbose].append(out.upper()) # #### sys.stdout.close() # close the stream sys.stdout = backup # restore original stdout for output in outputs[True]: assert len(output) > 0 for output in outputs[False]: assert len(output) == 0
def test_duplicate_constraints(self): eq = (self.x == 2) le = (self.x <= 2) obj = 0 def test(self): objective, constr_map = self.canonicalize() self._presolve(objective, constr_map) print len(constr_map[s.SOC]) dims = self._format_for_solver(constr_map, s.ECOS) return (len(constr_map[s.EQ]),len(constr_map[s.LEQ])) Problem.register_solve("test", test) p = Problem(Minimize(obj),[eq,eq,le,le]) result = p.solve(method="test") self.assertEqual(result, (1, 1)) # Internal constraints. X = Semidef(2) obj = sum_entries(X + X) p = Problem(Minimize(obj)) result = p.solve(method="test") self.assertEqual(result, (1, 1)) # Duplicates from non-linear constraints. exp = norm(self.x, 2) prob = Problem(Minimize(0), [exp <= 1, exp <= 2]) result = prob.solve(method="test") self.assertEqual(result, (0, 4))
def test_vstack(self): c = matrix(1, (1, 5)) p = Problem(Minimize(c * vstack(self.x, self.y)), [self.x == [1, 2], self.y == [3, 4, 5]]) result = p.solve() self.assertAlmostEqual(result, 15) c = matrix(1, (1, 4)) p = Problem(Minimize(c * vstack(self.x, self.x)), [self.x == [1, 2]]) result = p.solve() self.assertAlmostEqual(result, 6) c = matrix(1, (2, 2)) p = Problem(Minimize(sum(vstack(self.A, self.C))), [self.A >= 2 * c, self.C == -2]) result = p.solve() self.assertAlmostEqual(result, -4) c = matrix(1, (1, 2)) p = Problem(Minimize(sum(vstack(c * self.A, c * self.B))), [self.A >= 2, self.B == -2]) result = p.solve() self.assertAlmostEqual(result, 0) c = matrix([1, -1]) p = Problem(Minimize(c.T * vstack(square(self.a), sqrt(self.b))), [self.a == 2, self.b == 16]) result = p.solve() self.assertAlmostEqual(result, 0)
def test_quad_form(self): with self.assertRaises(Exception) as cm: Problem(Minimize(quad_form(self.x, self.A))).solve() self.assertEqual(str(cm.exception), "At least one argument to quad_form must be constant.") with self.assertRaises(Exception) as cm: Problem(Minimize(quad_form(1, self.A))).solve() self.assertEqual(str(cm.exception), "Invalid dimensions for arguments.") with self.assertRaises(Exception) as cm: Problem(Minimize(quad_form(self.x, [[-1, 0], [0, 9]]))).solve() self.assertEqual(str(cm.exception), "P has both positive and negative eigenvalues.") P = [[4, 0], [0, 9]] p = Problem(Minimize(quad_form(self.x, P)), [self.x >= 1]) result = p.solve() self.assertAlmostEqual(result, 13, places=3) c = [1,2] p = Problem(Minimize(quad_form(c, self.A)), [self.A >= 1]) result = p.solve() self.assertAlmostEqual(result, 9) c = [1,2] P = [[4, 0], [0, 9]] p = Problem(Minimize(quad_form(c, P))) result = p.solve() self.assertAlmostEqual(result, 40)
def test_norm2(self): # Constant argument. p = Problem(Minimize(norm2(-2))) result = p.solve() self.assertAlmostEqual(result, 2) # Scalar arguments. p = Problem(Minimize(norm2(self.a)), [self.a <= -2]) result = p.solve() self.assertAlmostEqual(result, 2) self.assertAlmostEqual(self.a.value, -2) # Maximize p = Problem(Maximize(-norm2(self.a)), [self.a <= -2]) result = p.solve() self.assertAlmostEqual(result, -2) self.assertAlmostEqual(self.a.value, -2) # Vector arguments. p = Problem(Minimize(norm2(self.x - self.z) + 5), [self.x >= [2,3], self.z <= [-1,-4]]) result = p.solve() self.assertAlmostEqual(result, 12.61577) self.assertItemsAlmostEqual(self.x.value, [2,3]) self.assertItemsAlmostEqual(self.z.value, [-1,-4])
def test_duplicate_constraints(self): eq = (self.x == 2) le = (self.x <= 2) obj = 0 def test(self): objective, constr_map = self.canonicalize() print len(constr_map[s.SOC]) dims = self._format_for_solver(constr_map, s.ECOS) return (len(constr_map[s.EQ]), len(constr_map[s.LEQ])) Problem.register_solve("test", test) p = Problem(Minimize(obj), [eq, eq, le, le]) result = p.solve(method="test") self.assertEqual(result, (1, 1)) # Internal constraints. z = hstack(self.x, self.x) obj = sum_entries(z[:, 0] + z[:, 1]) p = Problem(Minimize(obj)) result = p.solve(method="test") self.assertEqual(result, (2, 0)) # Duplicates from non-linear constraints. exp = norm(self.x, 2) prob = Problem(Minimize(0), [exp <= 1, exp <= 2]) result = prob.solve(method="test") self.assertEqual(result, (0, 4))
def test_verbose(self): # From http://stackoverflow.com/questions/5136611/capture-stdout-from-a-script-in-python # setup the environment outputs = {True: [], False: []} backup = sys.stdout # #### for verbose in [True, False]: for solver in [s.ECOS, s.CVXOPT, s.SCS]: sys.stdout = StringIO() # capture output p = Problem(Minimize(self.a + self.x[0]), [self.a >= 2, self.x >= 2]) p.solve(verbose=verbose, solver=solver) if solver != s.ECOS: p = Problem(Minimize(self.a), [log(self.a) >= 2]) p.solve(verbose=verbose, solver=solver) out = sys.stdout.getvalue() # release output outputs[verbose].append(out.upper()) # #### sys.stdout.close() # close the stream sys.stdout = backup # restore original stdout for output in outputs[True]: assert len(output) > 0 for output in outputs[False]: assert len(output) == 0
def test_duplicate_constraints(self): eq = (self.x == 2) le = (self.x <= 2) obj = 0 def test(self): objective, constraints = self.canonicalize() sym_data = SymData(objective, constraints, SOLVERS[s.CVXOPT]) return (len(sym_data.constr_map[s.EQ]), len(sym_data.constr_map[s.LEQ])) Problem.register_solve("test", test) p = Problem(Minimize(obj),[eq,eq,le,le]) result = p.solve(method="test") self.assertEqual(result, (1, 1)) # Internal constraints. X = Semidef(2) obj = sum_entries(X + X) p = Problem(Minimize(obj)) result = p.solve(method="test") self.assertEqual(result, (0, 1)) # Duplicates from non-linear constraints. exp = norm(self.x, 2) prob = Problem(Minimize(0), [exp <= 1, exp <= 2]) result = prob.solve(method="test") self.assertEqual(result, (0, 4))
def test_pnorm(self): import numpy as np x = Variable(3, name='x') a = np.array([1.0, 2, 3]) # todo: add -1, .5, .3, -2.3 and testing positivity constraints for p in (1, 1.6, 1.3, 2, 1.99, 3, 3.7, np.inf): prob = Problem(Minimize(pnorm(x, p=p)), [x.T*a >= 1]) prob.solve() # formula is true for any a >= 0 with p > 1 if p == np.inf: x_true = np.ones_like(a)/sum(a) elif p == 1: # only works for the particular a = [1,2,3] x_true = np.array([0, 0, 1.0/3]) else: x_true = a**(1.0/(p-1))/a.dot(a**(1.0/(p-1))) x_alg = np.array(x.value).flatten() self.assertTrue(np.allclose(x_alg, x_true, 1e-3), 'p = {}'.format(p)) self.assertTrue(np.allclose(prob.value, np.linalg.norm(x_alg, p))) self.assertTrue(np.allclose(np.linalg.norm(x_alg, p), pnorm(x_alg, p).value))
def test_dual_variables(self): p = Problem(Minimize( norm1(self.x + self.z) ), [self.x >= [2,3], [[1,2],[3,4]]*self.z == [-1,-4], norm2(self.x + self.z) <= 100]) result = p.solve() self.assertAlmostEqual(result, 4) self.assertItemsAlmostEqual(self.x.value, [4,3]) self.assertItemsAlmostEqual(self.z.value, [-4,1]) # Dual values self.assertItemsAlmostEqual(p.constraints[0].dual_value, [0, 1]) self.assertItemsAlmostEqual(p.constraints[1].dual_value, [-1, 0.5]) self.assertAlmostEqual(p.constraints[2].dual_value, 0) T = matrix(2,(2,3)) c = matrix([3,4]) p = Problem(Minimize(1), [self.A >= T*self.C, self.A == self.B, self.C == T.T]) result = p.solve() # Dual values self.assertItemsAlmostEqual(p.constraints[0].dual_value, 4*[0]) self.assertItemsAlmostEqual(p.constraints[1].dual_value, 4*[0]) self.assertItemsAlmostEqual(p.constraints[2].dual_value, 6*[0])
def test_vstack(self): c = matrix(1, (1,5)) p = Problem(Minimize(c * vstack(self.x, self.y)), [self.x == [1,2], self.y == [3,4,5]]) result = p.solve() self.assertAlmostEqual(result, 15) c = matrix(1, (1,4)) p = Problem(Minimize(c * vstack(self.x, self.x)), [self.x == [1,2]]) result = p.solve() self.assertAlmostEqual(result, 6) c = matrix(1, (2,2)) p = Problem( Minimize( sum(vstack(self.A, self.C)) ), [self.A >= 2*c, self.C == -2]) result = p.solve() self.assertAlmostEqual(result, -4) c = matrix(1, (1,2)) p = Problem( Minimize( sum(vstack(c*self.A, c*self.B)) ), [self.A >= 2, self.B == -2]) result = p.solve() self.assertAlmostEqual(result, 0) c = matrix([1,-1]) p = Problem( Minimize( c.T * vstack(square(self.a), sqrt(self.b))), [self.a == 2, self.b == 16]) result = p.solve() self.assertAlmostEqual(result, 0)
def test_indexing(self): # Vector variables p = Problem(Maximize(self.x[0,0]), [self.x[0,0] <= 2, self.x[1,0] == 3]) result = p.solve() self.assertAlmostEqual(result, 2) self.assertItemsAlmostEqual(self.x, [2,3]) n = 10 A = matrix(range(n*n), (n,n)) x = Variable(n,n) p = Problem(Minimize(sum(x)), [x == A]) result = p.solve() answer = n*n*(n*n+1)/2 - n*n self.assertAlmostEqual(result, answer) # Matrix variables import __builtin__ p = Problem(Maximize( __builtin__.sum(self.A[i,i] + self.A[i,1-i] for i in range(2)) ), [self.A <= [[1,-2],[-3,4]]]) result = p.solve() self.assertAlmostEqual(result, 0) self.assertItemsAlmostEqual(self.A.value, [1,-2,-3,4]) # Indexing arithmetic expressions. exp = [[1,2],[3,4]]*self.z + self.x p = Problem(Minimize(exp[1,0]), [self.x == self.z, self.z == [1,2]]) result = p.solve() self.assertAlmostEqual(result, 12) self.assertItemsAlmostEqual(self.x.value, self.z.value)
def test_mul_elemwise(self): """Tests problems with mul_elemwise. """ c = [[1, -1], [2, -2]] expr = mul_elemwise(c, self.A) obj = Minimize(normInf(expr)) p = Problem(obj, [self.A == 5]) result = p.solve() self.assertAlmostEqual(result, 10) self.assertItemsAlmostEqual(expr.value, [5, -5] + [10, -10]) # Test with a sparse matrix. import cvxopt interface = intf.get_matrix_interface(cvxopt.spmatrix) c = interface.const_to_matrix([1,2]) expr = mul_elemwise(c, self.x) obj = Minimize(normInf(expr)) p = Problem(obj, [self.x == 5]) result = p.solve() self.assertAlmostEqual(result, 10) self.assertItemsAlmostEqual(expr.value, [5, 10]) # Test promotion. c = [[1, -1], [2, -2]] expr = mul_elemwise(c, self.a) obj = Minimize(normInf(expr)) p = Problem(obj, [self.a == 5]) result = p.solve() self.assertAlmostEqual(result, 10) self.assertItemsAlmostEqual(expr.value, [5, -5] + [10, -10])
def test_normInf(self): # Constant argument. p = Problem(Minimize(normInf(-2))) result = p.solve() self.assertAlmostEqual(result, 2) # Scalar arguments. p = Problem(Minimize(normInf(self.a)), [self.a >= 2]) result = p.solve() self.assertAlmostEqual(result, 2) self.assertAlmostEqual(self.a.value, 2) p = Problem(Minimize(3*normInf(self.a + 2*self.b) + self.c), [self.a >= 2, self.b <= -1, self.c == 3]) result = p.solve() self.assertAlmostEqual(result, 3) self.assertAlmostEqual(self.a.value + 2*self.b.value, 0) self.assertAlmostEqual(self.c.value, 3) # Maximize p = Problem(Maximize(-normInf(self.a)), [self.a <= -2]) result = p.solve() self.assertAlmostEqual(result, -2) self.assertAlmostEqual(self.a.value, -2) # Vector arguments. p = Problem(Minimize(normInf(self.x - self.z) + 5), [self.x >= [2,3], self.z <= [-1,-4]]) result = p.solve() self.assertAlmostEqual(result, 12) self.assertAlmostEqual(list(self.x.value)[1] - list(self.z.value)[1], 7)
def test_mul_elemwise(self): """Tests problems with mul_elemwise. """ c = [[1, -1], [2, -2]] expr = mul_elemwise(c, self.A) obj = Minimize(normInf(expr)) p = Problem(obj, [self.A == 5]) result = p.solve() self.assertAlmostEqual(result, 10) self.assertItemsAlmostEqual(expr.value, [5, -5] + [10, -10]) # Test with a sparse matrix. import cvxopt interface = intf.get_matrix_interface(cvxopt.spmatrix) c = interface.const_to_matrix([1, 2]) expr = mul_elemwise(c, self.x) obj = Minimize(normInf(expr)) p = Problem(obj, [self.x == 5]) result = p.solve() self.assertAlmostEqual(result, 10) self.assertItemsAlmostEqual(expr.value, [5, 10]) # Test promotion. c = [[1, -1], [2, -2]] expr = mul_elemwise(c, self.a) obj = Minimize(normInf(expr)) p = Problem(obj, [self.a == 5]) result = p.solve() self.assertAlmostEqual(result, 10) self.assertItemsAlmostEqual(expr.value, [5, -5] + [10, -10])
def test_pnorm(self): import numpy as np x = Variable(3, name='x') a = np.array([1.0, 2, 3]) for p in (1, 1.6, 1.2, 2, 1.99, 3, 3.7, np.inf): prob = Problem(Minimize(pnorm(x, p=p)), [x.T * a >= 1]) prob.solve() # formula is true for any a >= 0 with p > 1 if p == np.inf: x_true = np.ones_like(a) / sum(a) elif p == 1: # only works for the particular a = [1,2,3] x_true = np.array([0, 0, 1.0 / 3]) else: x_true = a**(1.0 / (p - 1)) / a.dot(a**(1.0 / (p - 1))) x_alg = np.array(x.value).flatten() self.assertTrue(np.allclose(x_alg, x_true, 1e-3)) self.assertTrue(np.allclose(prob.value, np.linalg.norm(x_alg, p))) self.assertTrue( np.allclose(np.linalg.norm(x_alg, p), pnorm(x_alg, p).value))
def test_cvxopt_errors(self): """Tests that cvxopt errors are caught as solver_error. """ # For some reason CVXOPT can't handle this problem. expr = 500 * self.a + square(self.a) prob = Problem(Minimize(expr)) prob.solve(solver=s.CVXOPT) self.assertEqual(prob.status, s.SOLVER_ERROR)
def test_power(self): x = Variable() prob = Problem( Minimize(power(x, 1.7) + power(x, -2.3) - power(x, .45))) prob.solve() x = x.value self.assertTrue(__builtins__['abs'](1.7 * x**.7 - 2.3 * x**-3.3 - .45 * x**-.55) <= 1e-3)
def test_cvxopt_errors(self): """Tests that cvxopt errors are caught as solver_error. """ # For some reason CVXOPT can't handle this problem. expr = 500*self.a + square(self.a) prob = Problem(Minimize(expr)) prob.solve(solver=s.CVXOPT) self.assertEqual(prob.status, s.SOLVER_ERROR)
def test_sdp(self): """Test a problem with semidefinite cones. """ a = sp.rand(100, 100, .1, random_state=1) a = a.todense() X = Variable(100, 100) obj = at.norm(X, "nuc") + at.norm(X - a, 'fro') p = Problem(Minimize(obj)) p.solve(solver="SCS")
def test_sdp(self): """Test a problem with semidefinite cones. """ a = sp.rand(100,100,.1, random_state=1) a = a.todense() X = Variable(100,100) obj = at.norm(X, "nuc") + at.norm(X-a,'fro') p = Problem(Minimize(obj)) p.solve(solver="SCS")
def test_slicing(self): p = Problem(Maximize(sum(self.C)), [self.C[1:3, :] <= 2, self.C[0, :] == 1]) result = p.solve() self.assertAlmostEqual(result, 10) self.assertItemsAlmostEqual(self.C, 2 * [1, 2, 2]) p = Problem(Maximize(sum(self.C[0:3:2, 1])), [self.C[1:3, :] <= 2, self.C[0, :] == 1]) result = p.solve() self.assertAlmostEqual(result, 3) self.assertItemsAlmostEqual(self.C.value[0:3:2, 1], [1, 2]) p = Problem( Maximize(sum((self.C[0:2, :] + self.A)[:, 0:2])), [ self.C[1:3, :] <= 2, self.C[0, :] == 1, (self.A + self.B)[:, 0] == 3, (self.A + self.B)[:, 1] == 2, self.B == 1, ], ) result = p.solve() self.assertAlmostEqual(result, 12) self.assertItemsAlmostEqual(self.C.value[0:2, :], [1, 2, 1, 2]) self.assertItemsAlmostEqual(self.A.value, [2, 2, 1, 1]) p = Problem( Maximize([[3], [4]] * (self.C[0:2, :] + self.A)[:, 0]), [ self.C[1:3, :] <= 2, self.C[0, :] == 1, [[1], [2]] * (self.A + self.B)[:, 0] == 3, (self.A + self.B)[:, 1] == 2, self.B == 1, 3 * self.A[:, 0] <= 3, ], ) result = p.solve() self.assertAlmostEqual(result, 12) self.assertItemsAlmostEqual(self.C.value[0:2, 0], [1, 2]) self.assertItemsAlmostEqual(self.A.value, [1, -0.5, 1, 1]) p = Problem( Minimize(norm2((self.C[0:2, :] + self.A)[:, 0])), [ self.C[1:3, :] <= 2, self.C[0, :] == 1, (self.A + self.B)[:, 0] == 3, (self.A + self.B)[:, 1] == 2, self.B == 1, ], ) result = p.solve() self.assertAlmostEqual(result, 3) self.assertItemsAlmostEqual(self.C.value[0:2, 0], [1, -2]) self.assertItemsAlmostEqual(self.A.value, [2, 2, 1, 1])
def test_sdp(self) -> None: """Test a problem with semidefinite cones. """ self.skipTest("Too slow.") a = sp.rand(100, 100, .1, random_state=1) a = a.todense() X = Variable((100, 100)) obj = at.norm(X, "nuc") + at.norm(X - a, 'fro') p = Problem(cp.Minimize(obj)) p.solve(solver="SCS")
def test_is_dcp(self): p = Problem(Minimize(normInf(self.a))) self.assertEqual(p.is_dcp(), True) p = Problem(Maximize(normInf(self.a))) self.assertEqual(p.is_dcp(), False) with self.assertRaises(Exception) as cm: p.solve() self.assertEqual(str(cm.exception), "Problem does not follow DCP rules.") p.solve(ignore_dcp=True)
def test_reshape(self): """Tests problems with reshape. """ # Test on scalars. self.assertEqual(reshape(1, 1, 1).value, 1) # Test vector to matrix. x = Variable(4) mat = matrix([[1, -1], [2, -2]]) vec = matrix([1, 2, 3, 4]) vec_mat = matrix([[1, 2], [3, 4]]) expr = reshape(x, 2, 2) obj = Minimize(sum_entries(mat * expr)) prob = Problem(obj, [x == vec]) result = prob.solve() self.assertAlmostEqual(result, sum(mat * vec_mat)) # Test on matrix to vector. c = [1, 2, 3, 4] expr = reshape(self.A, 4, 1) obj = Minimize(expr.T * c) constraints = [self.A == [[-1, -2], [3, 4]]] prob = Problem(obj, constraints) result = prob.solve() self.assertAlmostEqual(result, 20) self.assertItemsAlmostEqual(expr.value, [-1, -2, 3, 4]) self.assertItemsAlmostEqual(reshape(expr, 2, 2).value, [-1, -2, 3, 4]) # Test matrix to matrix. expr = reshape(self.C, 2, 3) mat = numpy.matrix([[1, -1], [2, -2]]) C_mat = numpy.matrix([[1, 4], [2, 5], [3, 6]]) obj = Minimize(sum_entries(mat * expr)) prob = Problem(obj, [self.C == C_mat]) result = prob.solve() reshaped = numpy.reshape(C_mat, (2, 3), 'F') self.assertAlmostEqual(result, (mat.dot(reshaped)).sum()) self.assertItemsAlmostEqual(expr.value, C_mat) # Test promoted expressions. c = matrix([[1, -1], [2, -2]]) expr = reshape(c * self.a, 1, 4) obj = Minimize(expr * [1, 2, 3, 4]) prob = Problem(obj, [self.a == 2]) result = prob.solve() self.assertAlmostEqual(result, -6) self.assertItemsAlmostEqual(expr.value, 2 * c) expr = reshape(c * self.a, 4, 1) obj = Minimize(expr.T * [1, 2, 3, 4]) prob = Problem(obj, [self.a == 2]) result = prob.solve() self.assertAlmostEqual(result, -6) self.assertItemsAlmostEqual(expr.value, 2 * c)
def test_reshape(self): """Tests problems with reshape. """ # Test on scalars. self.assertEqual(reshape(1, 1, 1).value, 1) # Test vector to matrix. x = Variable(4) mat = matrix([[1,-1], [2, -2]]) vec = matrix([1, 2, 3, 4]) vec_mat = matrix([[1, 2], [3, 4]]) expr = reshape(x, 2, 2) obj = Minimize(sum_entries(mat*expr)) prob = Problem(obj, [x == vec]) result = prob.solve() self.assertAlmostEqual(result, sum(mat*vec_mat)) # Test on matrix to vector. c = [1, 2, 3, 4] expr = reshape(self.A, 4, 1) obj = Minimize(expr.T*c) constraints = [self.A == [[-1, -2], [3, 4]]] prob = Problem(obj, constraints) result = prob.solve() self.assertAlmostEqual(result, 20) self.assertItemsAlmostEqual(expr.value, [-1, -2, 3, 4]) self.assertItemsAlmostEqual(reshape(expr, 2, 2).value, [-1, -2, 3, 4]) # Test matrix to matrix. expr = reshape(self.C, 2, 3) mat = numpy.matrix([[1,-1], [2, -2]]) C_mat = numpy.matrix([[1, 4], [2, 5], [3, 6]]) obj = Minimize(sum_entries(mat*expr)) prob = Problem(obj, [self.C == C_mat]) result = prob.solve() reshaped = numpy.reshape(C_mat, (2, 3), 'F') self.assertAlmostEqual(result, (mat.dot(reshaped)).sum()) self.assertItemsAlmostEqual(expr.value, C_mat) # Test promoted expressions. c = matrix([[1,-1], [2, -2]]) expr = reshape(c*self.a, 1, 4) obj = Minimize(expr*[1, 2, 3, 4]) prob = Problem(obj, [self.a == 2]) result = prob.solve() self.assertAlmostEqual(result, -6) self.assertItemsAlmostEqual(expr.value, 2*c) expr = reshape(c*self.a, 4, 1) obj = Minimize(expr.T*[1, 2, 3, 4]) prob = Problem(obj, [self.a == 2]) result = prob.solve() self.assertAlmostEqual(result, -6) self.assertItemsAlmostEqual(expr.value, 2*c)
def test_verbose(self): import sys # From http://stackoverflow.com/questions/5136611/capture-stdout-from-a-script-in-python # setup the environment outputs = {True: [], False: []} backup = sys.stdout # #### for verbose in [True, False]: for solver in installed_solvers(): # Don't test GLPK because there's a race # condition in setting CVXOPT solver options. if solver in ["GLPK", "GLPK_MI"]: continue # if solver == "GLPK": # # GLPK's stdout is separate from python, # # so we have to do this. # # Note: This probably breaks (badly) on Windows. # import os # import tempfile # stdout_fd = 1 # tmp_handle = tempfile.TemporaryFile(bufsize = 0) # os.dup2(tmp_handle.fileno(), stdout_fd) # else: sys.stdout = StringIO() # capture output p = Problem(Minimize(self.a + self.x[0]), [self.a >= 2, self.x >= 2]) if SOLVERS[solver].MIP_CAPABLE: p.constraints.append(Bool() == 0) p.solve(verbose=verbose, solver=solver) if SOLVERS[solver].EXP_CAPABLE: p = Problem(Minimize(self.a), [log(self.a) >= 2]) p.solve(verbose=verbose, solver=solver) # if solver == "GLPK": # # GLPK's stdout is separate from python, # # so we have to do this. # tmp_handle.seek(0) # out = tmp_handle.read() # tmp_handle.close() # else: out = sys.stdout.getvalue() # release output outputs[verbose].append((out, solver)) # #### sys.stdout.close() # close the stream sys.stdout = backup # restore original stdout for output, solver in outputs[True]: print(solver) assert len(output) > 0 for output, solver in outputs[False]: print(solver) assert len(output) == 0
def test_large_sdp(self): """Test for bug where large SDP caused integer overflow in CVXcanon. """ SHAPE = (256, 256) rows = SHAPE[0] cols = SHAPE[1] X = Variable(*SHAPE) Z = Variable(rows+cols, rows+cols) prob = Problem(Minimize(0.5*at.trace(Z)), [X[0,0] >= 1, Z[0:rows,rows:rows+cols] == X, Z >> 0, Z == Z.T]) prob.solve(solver="SCS") self.assertAlmostEqual(prob.value, 1.0)
def test_redundant_constraints(self): obj = Minimize(sum_entries(self.x)) constraints = [self.x == 2, self.x == 2, self.x.T == 2, self.x[0] == 2] p = Problem(obj, constraints) result = p.solve(solver=s.CVXOPT) self.assertAlmostEqual(result, 4) obj = Minimize(sum_entries(square(self.x))) constraints = [self.x == self.x] p = Problem(obj, constraints) result = p.solve(solver=s.CVXOPT) self.assertAlmostEqual(result, 0)
def test_large_sdp(self): """Test for bug where large PSD caused integer overflow in cvxcore. """ SHAPE = (256, 256) rows = SHAPE[0] cols = SHAPE[1] X = Variable(SHAPE) Z = Variable((rows+cols, rows+cols)) prob = Problem(Minimize(0.5*at.trace(Z)), [X[0, 0] >= 1, Z[0:rows, rows:rows+cols] == X, Z >> 0, Z == Z.T]) prob.solve(solver="SCS") self.assertAlmostEqual(prob.value, 1.0)
def test_redundant_constraints(self): obj = Minimize(sum(self.x)) constraints = [self.x == 2, self.x == 2, self.x.T == 2, self.x[0] == 2] p = Problem(obj, constraints) result = p.solve(solver=s.CVXOPT) self.assertAlmostEqual(result, 4) obj = Minimize(sum(square(self.x))) constraints = [self.x == self.x] p = Problem(obj, constraints) result = p.solve(solver=s.CVXOPT) self.assertAlmostEqual(result, 0)
def grad(self): """Gives the (sub/super)gradient of the expression w.r.t. each variable. Matrix expressions are vectorized, so the gradient is a matrix. None indicates variable values unknown or outside domain. Returns: A map of variable to SciPy CSC sparse matrix or None. """ # Subgrad of g(y) = min f_0(x,y) # s.t. f_i(x,y) <= 0, i = 1,..,p # h_i(x,y) == 0, i = 1,...,q # Given by Df_0(x^*,y) + \sum_i Df_i(x^*,y) \lambda^*_i # + \sum_i Dh_i(x^*,y) \nu^*_i # where x^*, \lambda^*_i, \nu^*_i are optimal primal/dual variables. # Add PSD constraints in same way. # Short circuit for constant. if self.is_constant(): return u.grad.constant_grad(self) old_vals = {var.id: var.value for var in self.variables()} fix_vars = [] for var in self.dont_opt_vars: if var.value is None: return u.grad.error_grad(self) else: fix_vars += [var == var.value] prob = Problem(self.args[0].objective, fix_vars + self.args[0].constraints) prob.solve(verbose=True) # Compute gradient. if prob.status in s.SOLUTION_PRESENT: sign = self.is_convex() - self.is_concave() # Form Lagrangian. lagr = self.args[0].objective.args[0] for constr in self.args[0].constraints: # TODO: better way to get constraint expressions. lagr_multiplier = self.cast_to_const(sign*constr.dual_value) prod = lagr_multiplier.T*constr.expr if prod.is_scalar(): lagr += sum(prod) else: lagr += trace(prod) grad_map = lagr.grad result = {var: grad_map[var] for var in self.dont_opt_vars} else: # Unbounded, infeasible, or solver error. result = u.grad.error_grad(self) # Restore the original values to the variables. for var in self.variables(): var.value = old_vals[var.id] return result
def _get_Theta(self, U, F): """ Function to find Theta from U and F via convex optimization in cvxpy or euclidean_proj_simplex Parameters --------- U: array-like with shape (n_nodes, n_clusters) F: nd.array with shape (n_clusters, n_clusters) with coordinates of k pretenders to be pure nodes Returns ------- Theta: nd.array with shape (n_nodes, n_clusters) where n_nodes == U.shape[0], n_clusters == U.shape[1] Requires -------- cvxpy (http://www.cvxpy.org/en/latest/) """ assert U.shape[1] == F.shape[0] == F.shape[1], \ "U.shape[1] != F.shape" n_nodes = U.shape[0] n_clusters = U.shape[1] if self.use_cvxpy: Theta = Variable(rows=n_nodes, cols=n_clusters) constraints = [ sum_entries(Theta[i, :]) == 1 for i in range(n_nodes) ] constraints += [ Theta[i, j] >= 0 for i in range(n_nodes) for j in range(n_clusters) ] obj = Minimize(norm(U - Theta * F, 'fro')) prob = Problem(obj, constraints) prob.solve() return np.array(Theta.value) else: projector = F.T.dot(np.linalg.inv(F.dot(F.T))) theta = U.dot(projector) theta_simplex_proj = np.array([ self._euclidean_proj_simplex(x) for x in theta ]) return theta_simplex_proj
def test_parameter_expressions(self): """Test that expressions with parameters are updated properly. """ x = Variable() y = Variable() x0 = Parameter() xSquared = x0 * x0 + 2 * x0 * (x - x0) # initial guess for x x0.value = 2 # make the constraint x**2 - y == 0 g = xSquared - y # set up the problem obj = abs(x - 1) prob = Problem(Minimize(obj), [g == 0]) prob.solve() x0.value = 1 prob.solve() self.assertAlmostEqual(g.value, 0) # Test multiplication. prob = Problem(Minimize(x0 * x), [x == 1]) x0.value = 2 prob.solve() x0.value = 1 prob.solve() self.assertAlmostEqual(prob.value, 1)
def test_parameter_expressions(self): """Test that expressions with parameters are updated properly. """ x = Variable() y = Variable() x0 = Parameter() xSquared = x0*x0 + 2*x0*(x - x0) # initial guess for x x0.value = 2 # make the constraint x**2 - y == 0 g = xSquared - y # set up the problem obj = abs(x - 1) prob = Problem( Minimize( obj ), [ g == 0 ] ) prob.solve() x0.value = 1 prob.solve() self.assertAlmostEqual(g.value, 0) # Test multiplication. prob = Problem( Minimize( x0*x ), [ x == 1 ] ) x0.value = 2 prob.solve() x0.value = 1 prob.solve() self.assertAlmostEqual(prob.value, 1)
def grad(self): """Gives the (sub/super)gradient of the expression w.r.t. each variable. Matrix expressions are vectorized, so the gradient is a matrix. None indicates variable values unknown or outside domain. Returns: A map of variable to SciPy CSC sparse matrix or None. """ # Subgrad of g(y) = min f_0(x,y) # s.t. f_i(x,y) <= 0, i = 1,..,p # h_i(x,y) == 0, i = 1,...,q # Given by Df_0(x^*,y) + \sum_i Df_i(x^*,y) \lambda^*_i # + \sum_i Dh_i(x^*,y) \nu^*_i # where x^*, \lambda^*_i, \nu^*_i are optimal primal/dual variables. # Add PSD constraints in same way. # Short circuit for constant. if self.is_constant(): return u.grad.constant_grad(self) old_vals = {var.id:var.value for var in self.variables()} fix_vars = [] for var in self.variables(): if var.value is None: return u.grad.error_grad(self) else: fix_vars += [var == var.value] obj_arg = self._prob.objective.args[0] prob = Problem(self.args[0].objective.copy(obj_arg), fix_vars + self._prob.constraints) prob.solve() # Compute gradient. if prob.status in s.SOLUTION_PRESENT: sign = self.is_convex() - self.is_concave() # Form Lagrangian. lagr = self._prob.objective.args[0] for constr in self._prob.constraints: # TODO: better way to get constraint expressions. lagr_multiplier = self.cast_to_const(sign*constr.dual_value) lagr += trace(lagr_multiplier.T*constr._expr) grad_map = lagr.grad result = {var:grad_map[var] for var in self.variables()} else: # Unbounded, infeasible, or solver error. result = u.grad.error_grad(self) # Restore the original values to the variables. for var in self.variables(): var.value = old_vals[var.id] return result
def test_presolve_parameters(self): """Test presolve with parameters. """ # Test with parameters. gamma = Parameter(sign="positive") x = Variable() obj = Minimize(x) prob = Problem(obj, [gamma == 1, x >= 0]) gamma.value = 0 prob.solve(solver=s.SCS) self.assertEqual(prob.status, s.INFEASIBLE) gamma.value = 1 prob.solve(solver=s.CVXOPT) self.assertEqual(prob.status, s.OPTIMAL)
def test_variable_promotion(self): p = Problem(Minimize(self.a), [self.x <= self.a, self.x == [1, 2]]) result = p.solve() self.assertAlmostEqual(result, 2) self.assertAlmostEqual(self.a.value, 2) p = Problem(Minimize(self.a), [self.A <= self.a, self.A == [[1, 2], [3, 4]]]) result = p.solve() self.assertAlmostEqual(result, 4) self.assertAlmostEqual(self.a.value, 4) # Promotion must happen before the multiplication. p = Problem(Minimize([[1], [1]] * (self.x + self.a + 1)), [self.a + self.x >= [1, 2]]) result = p.solve() self.assertAlmostEqual(result, 5)
def test_register_solve(self): Problem.register_solve("test",lambda self: 1) p = Problem(Minimize(1)) result = p.solve(method="test") self.assertEqual(result, 1) def test(self, a, b=2): return (a,b) Problem.register_solve("test", test) p = Problem(Minimize(0)) result = p.solve(1,b=3,method="test") self.assertEqual(result, (1,3)) result = p.solve(1,method="test") self.assertEqual(result, (1,2)) result = p.solve(1,method="test",b=4) self.assertEqual(result, (1,4))
def test_div(self): """Tests a problem with division. """ obj = Minimize(normInf(self.A / 5)) p = Problem(obj, [self.A >= 5]) result = p.solve() self.assertAlmostEqual(result, 1)
def test_div(self): """Tests a problem with division. """ obj = Minimize(normInf(self.A/5)) p = Problem(obj, [self.A >= 5]) result = p.solve() self.assertAlmostEqual(result, 1)
def test_variable_name_conflict(self): var = Variable(name='a') p = Problem(Maximize(self.a + var), [var == 2 + self.a, var <= 3]) result = p.solve() self.assertAlmostEqual(result, 4.0) self.assertAlmostEqual(self.a.value, 1) self.assertAlmostEqual(var.value, 3)
def test_chebyshev_center(self): # The goal is to find the largest Euclidean ball (i.e. its center and # radius) that lies in a polyhedron described by linear inequalites in this # fashion: P = {x : a_i'*x <= b_i, i=1,...,m} where x is in R^2 # Generate the input data a1 = np.matrix("2; 1") a2 = np.matrix(" 2; -1") a3 = np.matrix("-1; 2") a4 = np.matrix("-1; -2") b = np.ones([4,1]) # Create and solve the model r = Variable(name='r') x_c = Variable(2,name='x_c') obj = Maximize(r) constraints = [ #TODO have atoms compute values for constants. a1.T*x_c + np.linalg.norm(a1)*r <= b[0], a2.T*x_c + np.linalg.norm(a2)*r <= b[1], a3.T*x_c + np.linalg.norm(a3)*r <= b[2], a4.T*x_c + np.linalg.norm(a4)*r <= b[3], ] p = Problem(obj, constraints) result = p.solve() self.assertAlmostEqual(result, 0.4472) self.assertAlmostEqual(r.value, result) self.assertAlmostEqual(x_c.value, [0,0])
def test_transpose(self): p = Problem(Minimize(sum_entries(self.x)), [self.x.T >= matrix([1, 2]).T]) result = p.solve() self.assertAlmostEqual(result, 3) self.assertItemsAlmostEqual(self.x.value, [1, 2]) p = Problem(Minimize(sum_entries(self.C)), [matrix([1, 1]).T * self.C.T >= matrix([0, 1, 2]).T]) result = p.solve() value = self.C.value constraints = [ 1 * self.C[i, 0] + 1 * self.C[i, 1] >= i for i in range(3) ] p = Problem(Minimize(sum_entries(self.C)), constraints) result2 = p.solve() self.assertAlmostEqual(result, result2) self.assertItemsAlmostEqual(self.C.value, value) p = Problem(Minimize(self.A[0, 1] - self.A.T[1, 0]), [self.A == [[1, 2], [3, 4]]]) result = p.solve() self.assertAlmostEqual(result, 0) exp = (-self.x).T print exp.size p = Problem(Minimize(sum_entries(self.x)), [(-self.x).T <= 1]) result = p.solve() self.assertAlmostEqual(result, -2) c = matrix([1, -1]) p = Problem(Minimize(max_elemwise(c.T, 2, 2 + c.T)[1])) result = p.solve() self.assertAlmostEqual(result, 2) c = matrix([[1, -1, 2], [1, -1, 2]]) p = Problem(Minimize(sum_entries(max_elemwise(c, 2, 2 + c).T[:, 0]))) result = p.solve() self.assertAlmostEqual(result, 6) c = matrix([[1, -1, 2], [1, -1, 2]]) p = Problem(Minimize(sum_entries(square(c.T).T[:, 0]))) result = p.solve() self.assertAlmostEqual(result, 6) # Slice of transpose. p = Problem(Maximize(sum_entries(self.C)), [self.C.T[:, 1:3] <= 2, self.C.T[:, 0] == 1]) result = p.solve() self.assertAlmostEqual(result, 10) self.assertItemsAlmostEqual(self.C.value, 2 * [1, 2, 2])
def test_sdp_symmetry(self): # TODO should these raise exceptions? # with self.assertRaises(Exception) as cm: # lambda_max([[1,2],[3,4]]) # self.assertEqual(str(cm.exception), "lambda_max called on non-symmetric matrix.") # with self.assertRaises(Exception) as cm: # lambda_min([[1,2],[3,4]]) # self.assertEqual(str(cm.exception), "lambda_min called on non-symmetric matrix.") p = Problem(Minimize(lambda_max(self.A)), [self.A >= 2]) result = p.solve() self.assertItemsAlmostEqual(self.A.value, self.A.value.T) p = Problem(Minimize(lambda_max(self.A)), [self.A == [[1, 2], [3, 4]]]) result = p.solve() self.assertEqual(p.status, s.INFEASIBLE)
def test_sdp_symmetry(self): # TODO should these raise exceptions? # with self.assertRaises(Exception) as cm: # lambda_max([[1,2],[3,4]]) # self.assertEqual(str(cm.exception), "lambda_max called on non-symmetric matrix.") # with self.assertRaises(Exception) as cm: # lambda_min([[1,2],[3,4]]) # self.assertEqual(str(cm.exception), "lambda_min called on non-symmetric matrix.") p = Problem(Minimize(lambda_max(self.A)), [self.A >= 2]) result = p.solve() self.assertItemsAlmostEqual(self.A.value, self.A.value.T) p = Problem(Minimize(lambda_max(self.A)), [self.A == [[1,2],[3,4]]]) result = p.solve() self.assertEqual(p.status, s.INFEASIBLE)
def test_ecos_noineq(self): """Test ECOS with no inequality constraints. """ T = matrix(1, (2, 2)) p = Problem(Minimize(1), [self.A == T]) result = p.solve(solver=s.ECOS) self.assertAlmostEqual(result, 1) self.assertItemsAlmostEqual(self.A.value, T)