def test_l1(self): setseed(100) m, n = 500, 250 P = normal(m, n) q = normal(m, 1) u1, st1 = l1(P, q) u2, st2 = l1blas(P, q) self.assertTrue(st1 == 'optimal') self.assertTrue(st2 == 'optimal') self.assertAlmostEqualLists(list(u1), list(u2), places=3)
def test_l1regls(self): setseed(100) m, n = 250, 500 A = normal(m, n) b = normal(m, 1) x, st = l1regls(A, b) self.assertTrue(st == 'optimal') # Check optimality conditions (list should be empty, e.g., False) self.assertFalse([ t for t in zip(A.T * (A * x - b), x) if abs(t[1]) > 1e-6 and abs(t[0]) > 1.0 ])
def test_case3(self): m, n = 500, 100 setseed(100) A = normal(m, n) b = normal(m) x1 = variable(n) lp1 = op(max(abs(A * x1 - b))) lp1.solve() self.assertTrue(lp1.status == 'optimal') x2 = variable(n) lp2 = op(sum(abs(A * x2 - b))) lp2.solve() self.assertTrue(lp2.status == 'optimal') x3 = variable(n) lp3 = op( sum(max(0, abs(A * x3 - b) - 0.75, 2 * abs(A * x3 - b) - 2.25))) lp3.solve() self.assertTrue(lp3.status == 'optimal')
def set_up_matrix(self, build_B=False): from kvxopt import normal # Types of tranpose systems: # 'N', solves A*X = B. # 'T', solves A^T*X = B. # 'C', solves A^H*X = B. if self._complex: self._trans = ['N', 'T', 'C'] else: self._trans = ['N', 'T'] self._A = self.read_mtx() if self._complex: self._A = +self._A + self._A * 1j if build_B: self.b = normal(self._A.size[0], self._columns_B) if self._complex: self.b = +self.b * 1j
def F(x=None, z=None): if x is None: return 0, matrix(0.0, (n, 1)) y = A * x - b w = sqrt(rho + y**2) f = sum(w) Df = div(y, w).T * A if z is None: return f, Df H = A.T * spdiag(z[0] * rho * (w**-3)) * A return f, Df, H return solvers.cp(F)['x'] setseed() m, n = 500, 100 A = normal(m, n) b = normal(m, 1) xh = robls(A, b, 0.1) try: import pylab except ImportError: pass else: # Least-squares solution. pylab.subplot(211) xls = +b lapack.gels(+A, xls) rls = A * xls[:n] - b pylab.hist(list(rls), m // 5)
def test_basic_no_gsl(self): import sys sys.modules['gsl'] = None import kvxopt kvxopt.normal(4, 8) kvxopt.uniform(4, 8)
# The robust LP example of section 10.5 (Examples). from kvxopt import normal, uniform from kvxopt.modeling import variable, dot, op, sum from kvxopt.blas import nrm2 m, n = 500, 100 A = normal(m, n) b = uniform(m) c = normal(n) x = variable(n) op(dot(c, x), A * x + sum(abs(x)) <= b).solve() x2 = variable(n) y = variable(n) op(dot(c, x2), [A * x2 + sum(y) <= b, -y <= x2, x2 <= y]).solve() print("\nDifference between two solutions %e" % nrm2(x.value - x2.value))
step = 1.0 while 1-step*max(y) < 0: step *= BETA while True: if -sum(log(1-step*y)) < ALPHA*step*lam: break step *= BETA x += step*v # Generate an analytic centering problem # # -b1 <= Ar*x <= b2 # # with random mxn Ar and random b1, b2. m, n = 500, 500 Ar = normal(m,n); A = matrix([Ar, -Ar]) b = uniform(2*m,1) x, ntdecrs = acent(A, b) try: import pylab except ImportError: pass else: pylab.semilogy(range(len(ntdecrs)), ntdecrs, 'o', range(len(ntdecrs)), ntdecrs, '-') pylab.xlabel('Iteration number') pylab.ylabel('Newton decrement') pylab.show()
S = matrix(0.0, (m, m)) v = matrix(0.0, (m, 1)) def Fkkt(x, z, W): ds = (2.0 * div(1 + x**2, (1 - x**2)**2))**-0.5 Asc = A * spdiag(ds) blas.syrk(Asc, S) S[::m + 1] += 1.0 lapack.potrf(S) a = z[0] def g(x, y, z): x[:] = mul(x, ds) / a blas.gemv(Asc, x, v) lapack.potrs(S, v) blas.gemv(Asc, v, x, alpha=-1.0, beta=1.0, trans='T') x[:] = mul(x, ds) return g return solvers.cp(F, kktsolver=Fkkt)['x'] m, n = 200, 2000 setseed() A = normal(m, n) x = uniform(n, 1) b = A * x x = l2ac(A, b)
def F(x=None, z=None): if x is None: return 0, matrix(1.0, (n, 1)) if min(x) <= 0.0: return None f = -sum(log(x)) Df = -(x**-1).T if z is None: return matrix(f), Df H = spdiag(z[0] * x**-2) return f, Df, H return solvers.cp(F, A=A, b=b)['x'] # Randomly generate a feasible problem m, n = 50, 500 y = normal(m, 1) # Random A with A'*y > 0. s = uniform(n, 1) A = normal(m, n) r = s - A.T * y # A = A - (1/y'*y) * y*r' blas.ger(y, r, A, alpha=1.0 / blas.dot(y, y)) # Random feasible x > 0. x = uniform(n, 1) b = A * x x = acent(A, b)
x[:n] -= mul( div(d1**2 - d2**2, d1**2 + d2**2), x[n:]) lapack.potrs(S, x) # Solve for x[n:]: # # (d1**-2 + d2**-2) * x[n:] = x[n:] + (d1**-2 - d2**-2)*x[:n] x[n:] += mul( d1**-2 - d2**-2, x[:n]) x[n:] = div( x[n:], d1**-2 + d2**-2) # z := z + W^-T * G*x z[:n] += div( x[:n] - x[n:2*n], d1) z[n:2*n] += div( -x[:n] - x[n:2*n], d2) z[2*n:] += As*x[:n] return f dims = {'l': 2*n, 'q': [m+1], 's': []} sol = solvers.conelp(c, G, h, dims, kktsolver = Fkkt) if sol['status'] == 'optimal': return sol['x'][:n], sol['z'][-m:] else: return None, None setseed() m, n = 100, 100 A, b = normal(m,n), normal(m,1) x, z = qcl1(A, b) if x is None: print("infeasible")
c = matrix(1.0, (n, 1)) # Initial feasible x: x = 1.0 - min(lambda(w)). lmbda = matrix(0.0, (n, 1)) lapack.syevx(+w, lmbda, range='I', il=1, iu=1) x0 = matrix(-lmbda[0] + 1.0, (n, 1)) s0 = +w s0[::n + 1] += x0 # Initial feasible z is identity. z0 = matrix(0.0, (n, n)) z0[::n + 1] = 1.0 dims = {'l': 0, 'q': [], 's': [n]} sol = solvers.conelp(c, Fs, w[:], dims, kktsolver=Fkkt, primalstart={ 'x': x0, 's': s0[:] }, dualstart={'z': z0[:]}) return sol['x'], matrix(sol['z'], (n, n)) n = 100 w = normal(n, n) x, z = mcsdp(w)