def Gf(u, v, alpha=1.0, beta=0.0, trans='N'):
if trans == 'N':
# v[:m] := alpha * G * u[0] + beta * v[:m]
base.gemv(G, u[0], v, alpha=alpha, beta=beta)
# v[m:] := alpha * [-u[1], -A(u[0])'; -A(u[0]), -u[2]]
# + beta * v[m:]
blas.scal(beta, v, offset=m)
v[m + I11] -= alpha * u[1][:]
v[m + I21] -= alpha * A * u[0]
v[m + I22] -= alpha * u[2][:]
else:
# v[0] := alpha * ( G.T * u[:m] - 2.0 * A.T * u[m + I21] )
# + beta v[1]
base.gemv(G, u, v[0], trans='T', alpha=alpha, beta=beta)
base.gemv(A,
u[m + I21],
v[0],
trans='T',
alpha=-2.0 * alpha,
beta=1.0)
# v[1] := -alpha * u[m + I11] + beta * v[1]
blas.scal(beta, v[1])
blas.axpy(u[m + I11], v[1], alpha=-alpha)
# v[2] := -alpha * u[m + I22] + beta * v[2]
blas.scal(beta, v[2])
blas.axpy(u[m + I22], v[2], alpha=-alpha)
def f4_no_ir(x, y, z, s):
# Solve
#
# [ P A' G' ] [ ux ] [ bx ]
# [ A 0 0 ] [ uy ] = [ by ]
# [ G 0 -W'*W ] [ W^{-1}*uz ] [ bz - W'*(lmbda o\ bs) ]
#
# us = lmbda o\ bs - uz.
#
# On entry, x, y, z, s contains bx, by, bz, bs.
# On exit they contain x, y, z, s.
# s := lmbda o\ s
# = lmbda o\ bs
misc.sinv(s, lmbda, dims)
# z := z - W'*s
# = bz - W'*(lambda o\ bs)
ws3 = matrix(np.copy(s))
misc.scale(ws3, W, trans='T')
blas.axpy(ws3, z, alpha=-1.0)
# Solve for ux, uy, uz
f3(x, y, z)
# s := s - z
# = lambda o\ bs - uz.
blas.axpy(z, s, alpha=-1.0)
def Gf(u, v, alpha = 1.0, beta = 0.0, trans = 'N'):
if trans == 'N':
# v[:m] := alpha * G * u[0] + beta * v[:m]
base.gemv(G, u[0], v, alpha = alpha, beta = beta)
# v[m:] := alpha * [-u[1], -A(u[0])'; -A(u[0]), -u[2]]
# + beta * v[m:]
blas.scal(beta, v, offset = m)
v[m + I11] -= alpha * u[1][:]
v[m + I21] -= alpha * A * u[0]
v[m + I22] -= alpha * u[2][:]
else:
# v[0] := alpha * ( G.T * u[:m] - 2.0 * A.T * u[m + I21] )
# + beta v[1]
base.gemv(G, u, v[0], trans = 'T', alpha = alpha, beta = beta)
base.gemv(A, u[m + I21], v[0], trans = 'T', alpha = -2.0*alpha,
beta = 1.0)
# v[1] := -alpha * u[m + I11] + beta * v[1]
blas.scal(beta, v[1])
blas.axpy(u[m + I11], v[1], alpha = -alpha)
# v[2] := -alpha * u[m + I22] + beta * v[2]
blas.scal(beta, v[2])
blas.axpy(u[m + I22], v[2], alpha = -alpha)
def Gf(u, v, alpha=1.0, beta=0.0, trans='N'):
# v = -alpha*u + beta * v
# u and v are vectors representing N symmetric matrices in the
# cvxopt format.
blas.scal(beta, v)
blas.axpy(u, v, alpha=-alpha)
def __isub__(self, B):
assert self.is_factor is False, "Addition of cspmatrix factors not supported"
if isinstance(B, cspmatrix):
assert self.symb == B.symb, "Symbolic factorization mismatch"
assert B.is_factor is False, "Addition of cspmatrix factors not supported"
blas.axpy(B.blkval, self.blkval, alpha=-1.0)
elif isinstance(B, spmatrix):
self._iadd_spmatrix(B, alpha=-1.0)
else:
raise TypeError
return self
def __isub__(self, B):
assert self.is_factor is False, "Addition of cspmatrix factors not supported"
if isinstance(B, cspmatrix):
assert self.symb == B.symb, "Symbolic factorization mismatch"
assert B.is_factor is False, "Addition of cspmatrix factors not supported"
blas.axpy(B.blkval, self.blkval, alpha = -1.0)
elif isinstance(B, spmatrix):
self._iadd_spmatrix(B, alpha = -1.0)
else:
raise TypeError
return self
def Fs(x, y, alpha = 1.0, beta = 0.0, trans = 'N'):
"""
y := alpha*(-diag(x)) + beta*y.
"""
if trans=='N':
# x is a vector; y is a matrix.
blas.scal(beta, y)
blas.axpy(x, y, alpha = -alpha, incy = n+1)
else:
# x is a matrix; y is a vector.
blas.scal(beta, y)
blas.axpy(x, y, alpha = -alpha, incx = n+1)
def Fs(x, y, alpha=1.0, beta=0.0, trans='N'):
"""
y := alpha*(-diag(x)) + beta*y.
"""
if trans == 'N':
# x is a vector; y is a matrix.
blas.scal(beta, y)
blas.axpy(x, y, alpha=-alpha, incy=n + 1)
else:
# x is a matrix; y is a vector.
blas.scal(beta, y)
blas.axpy(x, y, alpha=-alpha, incx=n + 1)
def Fgp(x = None, z = None):
if x is None: return mnl, matrix(0.0, (n,1))
f = matrix(0.0, (mnl+1,1))
Df = matrix(0.0, (mnl+1,n))
# y = F*x+g
blas.copy(g, y)
base.gemv(F, x, y, beta=1.0)
if z is not None: H = matrix(0.0, (n,n))
for i, start, stop in ind:
# yi := exp(yi) = exp(Fi*x+gi)
ymax = max(y[start:stop])
y[start:stop] = base.exp(y[start:stop] - ymax)
# fi = log sum yi = log sum exp(Fi*x+gi)
ysum = blas.asum(y, n=stop-start, offset=start)
f[i] = ymax + math.log(ysum)
# yi := yi / sum(yi) = exp(Fi*x+gi) / sum(exp(Fi*x+gi))
blas.scal(1.0/ysum, y, n=stop-start, offset=start)
# gradfi := Fi' * yi
# = Fi' * exp(Fi*x+gi) / sum(exp(Fi*x+gi))
base.gemv(F, y, Df, trans='T', m=stop-start, incy=mnl+1,
offsetA=start, offsetx=start, offsety=i)
if z is not None:
# Hi = Fi' * (diag(yi) - yi*yi') * Fi
# = Fisc' * Fisc
# where
# Fisc = diag(yi)^1/2 * (I - 1*yi') * Fi
# = diag(yi)^1/2 * (Fi - 1*gradfi')
Fsc[:K[i], :] = F[start:stop, :]
for k in range(start,stop):
blas.axpy(Df, Fsc, n=n, alpha=-1.0, incx=mnl+1,
incy=Fsc.size[0], offsetx=i, offsety=k-start)
blas.scal(math.sqrt(y[k]), Fsc, inc=Fsc.size[0],
offset=k-start)
# H += z[i]*Hi = z[i] * Fisc' * Fisc
blas.syrk(Fsc, H, trans='T', k=stop-start, alpha=z[i],
beta=1.0)
if z is None:
return f, Df
return f, Df, H
def G(u, v, alpha = 1.0, beta = 0.0, trans = 'N'):
"""
If trans is 'N':
v[:msq] := alpha * (A*u[0] - u[1][:]) + beta * v[:msq]
v[msq:] := -alpha * u[1][:] + beta * v[msq:].
If trans is 'T':
v[0] := alpha * A' * u[:msq] + beta * v[0]
v[1][:] := alpha * (-u[:msq] - u[msq:]) + beta * v[1][:].
"""
if trans == 'N':
blas.gemv(A, u[0], v, alpha = alpha, beta = beta)
blas.axpy(u[1], v, alpha = -alpha)
blas.scal(beta, v, offset = msq)
blas.axpy(u[1], v, alpha = -alpha, offsety = msq)
else:
misc.sgemv(A, u, v[0], dims = {'l': 0, 'q': [], 's': [m]},
alpha = alpha, beta = beta, trans = 'T')
blas.scal(beta, v[1])
blas.axpy(u, v[1], alpha = -alpha, n = msq)
blas.axpy(u, v[1], alpha = -alpha, n = msq, offsetx = msq)
def Af(u, v, alpha=1.0, beta=0.0, trans="N"):
# v := alpha * A(u) + beta * v if trans is 'N'
# v := alpha * A'(u) + beta * v if trans is 'T'
blas.scal(beta, v)
if trans == "N":
blas.axpy(u, v, alpha=alpha, n=nl / 2)
blas.axpy(u, v, alpha=-alpha, offsetx=nl / 2, n=nl / 2)
sgemv(A,
u,
v,
n=ns,
m=ms,
alpha=alpha,
beta=1.0,
trans="T",
offsetx=nl)
elif trans == "T":
blas.axpy(u, v, alpha=alpha, n=nl / 2)
blas.axpy(u, v, alpha=-alpha, offsety=nl / 2, n=nl / 2)
sgemv(A,
u,
v,
n=ns,
m=ms,
alpha=alpha,
beta=1.0,
trans="N",
offsety=nl)
def G(x, y, alpha=1.0, beta=0.0, trans='N'):
"""
If trans is 'N', x is an N x m matrix, and y is an N*m-vector.
y := alpha * x[:] + beta * y.
If trans is 'T', x is an N*m vector, and y is an N x m matrix.
y[:] := alpha * x + beta * y[:].
"""
blas.scal(beta, y)
blas.axpy(x, y, alpha)
def G(u, vvV, alpha=1.0, beta=0.0, trans="N"):
"""
v := alpha*[I, -I; -I, -I] * u + beta * v (trans = 'N' or 'T')
"""
blas.scal(beta, vvV)
blas.axpy(u, vvV, n=iC, alpha=alpha)
blas.axpy(u, vvV, n=iC, alpha=-alpha, offsetx=iC)
blas.axpy(u, vvV, n=iC, alpha=-alpha, offsety=iC)
blas.axpy(u, vvV, n=iC, alpha=-alpha, offsetx=iC, offsety=iC)
def G(u, vvV, alpha=1.0, beta=0.0, trans='N'):
"""
v := alpha*[I, -I; -I, -I] * u + beta * v (trans = 'N' or 'T')
"""
blas.scal(beta, vvV)
blas.axpy(u, vvV, n=iC, alpha=alpha)
blas.axpy(u, vvV, n=iC, alpha=-alpha, offsetx=iC)
blas.axpy(u, vvV, n=iC, alpha=-alpha, offsety=iC)
blas.axpy(u, vvV, n=iC, alpha=-alpha, offsetx=iC, offsety=iC)
def pairwise_diff(x, y, n):
'''Compute pairwise difference x[:,i] - x[:,j] and store in y[:,k],
where k is the index of (i,j) in the array (0,0), (0,1), ...,
(1,1), ..., (k-1,k-1). y[:,(i,i)] = x[:,i]
'''
k = 0
r = x.size[0]
for i in xrange(n):
#y[:,k] = x[:,i]
blas.copy(x, y, n=r, offsetx=i * r, offsety=k * r)
k += 1
for j in xrange(i + 1, n):
#y[:,k] = x[:,i] - x[:,j]
blas.copy(x, y, n=r, offsetx=i * r, offsety=k * r)
blas.axpy(x, y, alpha=-1, n=r, offsetx=j * r, offsety=k * r)
k += 1
def G(u, v, alpha = 1.0, beta = 0.0, trans = 'N'):
"""
v := alpha*[I, -I; -I, -I] * u + beta * v (trans = 'N' or 'T')
"""
blas.scal(beta, v)
blas.axpy(u, v, n = n, alpha = alpha)
blas.axpy(u, v, n = n, alpha = -alpha, offsetx = n)
blas.axpy(u, v, n = n, alpha = -alpha, offsety = n)
blas.axpy(u, v, n = n, alpha = -alpha, offsetx = n, offsety = n)
def G(u, v, alpha=1.0, beta=0.0, trans='N'):
"""
v := alpha*[I, -I; -I, -I] * u + beta * v (trans = 'N' or 'T')
"""
blas.scal(beta, v)
blas.axpy(u, v, n=n, alpha=alpha)
blas.axpy(u, v, n=n, alpha=-alpha, offsetx=n)
blas.axpy(u, v, n=n, alpha=-alpha, offsety=n)
blas.axpy(u, v, n=n, alpha=-alpha, offsetx=n, offsety=n)
def f(x, y, z):
# z := mat(z)
# = mat(bz)
z.size = N, m
# x := x + D .* z
# = bx + mat(bz) ./ d.^2
x += mul(D, z)
# y := y - sum_k (Q + Dk)^-1 * X[:,k]
# = by - sum_k (Q + Dk)^-1 * (bxk + Dk * bzk)
for k in range(m):
blas.symv(H[k], x[:, k], y, alpha=-1.0, beta=1.0)
# y := H^-1 * y
# = -uy
lapack.potrs(S, y)
# x[:,k] := H[k] * (x[:,k] + y)
# = (Q + Dk)^-1 * (bxk + bzk ./ d.^2 + y)
# = ux[:,k]
w = matrix(0.0, (N, 1))
for k in range(m):
# x[:,k] := x[:,k] + y
blas.axpy(y, x, offsety=N * k, n=N)
# w := H[k] * x[:,k]
# = (Q + Dk)^-1 * (bxk + bzk ./ d.^2 + y)
blas.symv(H[k], x, w, offsetx=N * k)
# x[:,k] := w
# = ux[:,k]
blas.copy(w, x, offsety=N * k)
# y := -y
# = uy
blas.scal(-1.0, y)
# z := (x - z) ./ d
blas.axpy(x, z, -1.0)
blas.tbsv(W['d'], z, n=m * N, k=0, ldA=1)
blas.scal(-1.0, z)
z.size = N * m, 1
def f4(x, y, z, s):
if refinement:
wx = matrix(np.copy(x))
wy = matrix(np.copy(y))
wz = matrix(np.copy(z))
ws = matrix(np.copy(s))
f4_no_ir(x, y, z, s)
for i in range(refinement):
wx2 = matrix(np.copy(wx))
wy2 = matrix(np.copy(wy))
wz2 = matrix(np.copy(wz))
ws2 = matrix(np.copy(ws))
res(x, y, z, s, wx2, wy2, wz2, ws2, W, lmbda)
f4_no_ir(wx2, wy2, wz2, ws2)
y += wx2
y += wy2
blas.axpy(wz2, z)
blas.axpy(ws2, s)
def res(ux, uy, uz, us, vx, vy, vz, vs, W, lmbda):
# Evaluates residual in Newton equations:
#
# [ vx ] [ vx ] [ 0 ] [ P A' G' ] [ ux ]
# [ vy ] := [ vy ] - [ 0 ] - [ A 0 0 ] * [ uy ]
# [ vz ] [ vz ] [ W'*us ] [ G 0 0 ] [ W^{-1}*uz ]
#
# vs := vs - lmbda o (uz + us).
# vx := vx - P*ux - A'*uy - G'*W^{-1}*uz
fP(ux, vx, alpha=-1.0, beta=1.0)
fA(uy, vx, alpha=-1.0, beta=1.0, trans='T')
blas.copy(uz, wz3)
misc.scale(wz3, W, inverse='I')
fG(wz3, vx, alpha=-1.0, beta=1.0, trans='T')
# vy := vy - A*ux
fA(ux, vy, alpha=-1.0, beta=1.0)
# vz := vz - G*ux - W'*us
fG(ux, vz, alpha=-1.0, beta=1.0)
blas.copy(us, ws3)
misc.scale(ws3, W, trans='T')
blas.axpy(ws3, vz, alpha=-1.0)
# vs := vs - lmbda o (uz + us)
blas.copy(us, ws3)
blas.axpy(uz, ws3)
misc.sprod(ws3, lmbda, dims, diag='D')
blas.axpy(ws3, vs, alpha=-1.0)
def G(x, y, alpha=1.0, beta=0.0, trans='N'):
"""
Implements the linear operator
[ -DX E -d -I ]
[ 0 0 0 -I ]
[ 0 -e_1' 0 0 ]
G = [ -P_1' 0 0 0 ]
[ . . . . ]
[ 0 -e_k' 0 0 ]
[ -P_k' 0 0 0 ]
and its adjoint G'.
"""
if trans == 'N':
tmp = +y[:m]
# y[:m] = alpha*(-DXw + Et - d*b - v) + beta*y[:m]
base.gemv(E, x[n:n + k], tmp, alpha=alpha, beta=beta)
blas.axpy(x[n + k + 1:], tmp, alpha=-alpha)
blas.axpy(d, tmp, alpha=-alpha * x[n + k])
y[:m] = tmp
base.gemv(X, x[:n], tmp, alpha=alpha, beta=0.0)
tmp = mul(d, tmp)
y[:m] -= tmp
# y[m:2*m] = -v
y[m:2 * m] = -alpha * x[n + k + 1:] + beta * y[m:2 * m]
# SOC 1,...,k
for i in range(k):
l = 2 * m + i * (n + 1)
y[l] = -alpha * x[n + i] + beta * y[l]
y[l + 1:l + 1 +
n] = -alpha * P[i] * x[:n] + beta * y[l + 1:l + 1 + n]
else:
tmp1 = mul(d, x[:m])
tmp2 = y[:n]
blas.gemv(X, tmp1, tmp2, trans='T', alpha=-alpha, beta=beta)
for i in range(k):
l = 2 * m + 1 + i * (n + 1)
blas.gemv(P[i],
x[l:l + n],
tmp2,
trans='T',
alpha=-alpha,
beta=1.0)
y[:n] = tmp2
tmp2 = y[n:n + k]
base.gemv(E, x[:m], tmp2, trans='T', alpha=alpha, beta=beta)
blas.axpy(x[2 * m:2 * m + k * (1 + n):n + 1], tmp2, alpha=-alpha)
y[n:n + k] = tmp2
y[n + k] = -alpha * blas.dot(d, x[:m]) + beta * y[n + k]
y[n + k +
1:] = -alpha * (x[:m] + x[m:2 * m]) + beta * y[n + k + 1:]
def solve(x, y, z):
# Solve
#
# [ H A' GG'*W^{-1} ] [ ux ] [ bx ]
# [ A 0 0 ] * [ uy [ = [ by ]
# [ W^{-T}*GG 0 -I ] [ W*uz ] [ W^{-T}*bz ]
#
# and return ux, uy, W*uz.
#
# On entry, x, y, z contain bx, by, bz. On exit, they contain
# the solution ux, uy, W*uz.
blas.scal(0.0, sltn)
blas.copy(x, u)
blas.copy(y, u, offsety = n)
scale(z, W, trans = 'T', inverse = 'I')
pack(z, u, dims, mnl, offsety = n + p)
blas.copy(u, r)
# Iterative refinement algorithm:
# Init: sltn = 0, r_0 = [bx; by; W^{-T}*bz]
# 1. u_k = Ktilde^-1 * r_k
# 2. sltn += u_k
# 3. r_k+1 = r - K*sltn
# Repeat until exceed MAX_ITER iterations or ||r|| <= ERROR_BOUND
iteration = 0
resid_norm = 1
while iteration <= MAX_ITER and resid_norm > ERROR_BOUND:
lapack.sytrs(Ktilde, ipiv, u)
blas.axpy(u, sltn, alpha = 1.0)
blas.copy(r, u)
blas.symv(K, sltn, u, alpha = -1.0, beta = 1.0)
resid_norm = math.sqrt(blas.dot(u, u))
iteration += 1
blas.copy(sltn, x, n = n)
blas.copy(sltn, y, offsetx = n, n = p)
unpack(sltn, z, dims, mnl, offsetx = n + p)
def G(x, y, alpha = 1.0, beta = 0.0, trans = 'N'):
"""
Implements the linear operator
[ -DX E -d -I ]
[ 0 0 0 -I ]
[ 0 -e_1' 0 0 ]
G = [ -P_1' 0 0 0 ]
[ . . . . ]
[ 0 -e_k' 0 0 ]
[ -P_k' 0 0 0 ]
and its adjoint G'.
"""
if trans == 'N':
tmp = +y[:m]
# y[:m] = alpha*(-DXw + Et - d*b - v) + beta*y[:m]
base.gemv(E, x[n:n+k], tmp, alpha = alpha, beta = beta)
blas.axpy(x[n+k+1:], tmp, alpha = -alpha)
blas.axpy(d, tmp, alpha = -alpha*x[n+k])
y[:m] = tmp
base.gemv(X, x[:n], tmp, alpha = alpha, beta = 0.0)
tmp = mul(d,tmp)
y[:m] -= tmp
# y[m:2*m] = -v
y[m:2*m] = -alpha * x[n+k+1:] + beta * y[m:2*m]
# SOC 1,...,k
for i in range(k):
l = 2*m+i*(n+1)
y[l] = -alpha * x[n+i] + beta * y[l]
y[l+1:l+1+n] = -alpha * P[i] * x[:n] + beta * y[l+1:l+1+n];
else:
tmp1 = mul(d,x[:m])
tmp2 = y[:n]
blas.gemv(X, tmp1, tmp2, trans = 'T', alpha = -alpha, beta = beta)
for i in range(k):
l = 2*m+1+i*(n+1)
blas.gemv(P[i], x[l:l+n], tmp2, trans = 'T', alpha = -alpha, beta = 1.0)
y[:n] = tmp2
tmp2 = y[n:n+k]
base.gemv(E, x[:m], tmp2, trans = 'T', alpha = alpha, beta = beta)
blas.axpy(x[2*m:2*m+k*(1+n):n+1], tmp2, alpha = -alpha)
y[n:n+k] = tmp2
y[n+k] = -alpha * blas.dot(d,x[:m]) + beta * y[n+k]
y[n+k+1:] = -alpha * (x[:m] + x[m:2*m]) + beta * y[n+k+1:]
def G(u, v, alpha=1.0, beta=0.0, trans='N'):
"""
If trans is 'N':
v[:msq] := alpha * (A*u[0] - u[1][:]) + beta * v[:msq]
v[msq:] := -alpha * u[1][:] + beta * v[msq:].
If trans is 'T':
v[0] := alpha * A' * u[:msq] + beta * v[0]
v[1][:] := alpha * (-u[:msq] - u[msq:]) + beta * v[1][:].
"""
if trans == 'N':
blas.gemv(A, u[0], v, alpha=alpha, beta=beta)
blas.axpy(u[1], v, alpha=-alpha)
blas.scal(beta, v, offset=msq)
blas.axpy(u[1], v, alpha=-alpha, offsety=msq)
else:
misc.sgemv(A,
u,
v[0],
dims={
'l': 0,
'q': [],
's': [m]
},
alpha=alpha,
beta=beta,
trans='T')
blas.scal(beta, v[1])
blas.axpy(u, v[1], alpha=-alpha, n=msq)
blas.axpy(u, v[1], alpha=-alpha, n=msq, offsetx=msq)
def P(u, v, alpha=1.0, beta=0.0):
# v := alpha * rho * u + beta * v
blas.scal(beta, v)
blas.axpy(u, v, alpha=alpha * rho, offsetx=nl, offsety=nl)
def solve(x, y, z):
"""
Returns solution of
rho * ux + A'(uy) - r^-T * uz * r^-1 = bx
A(ux) = by
-ux - r * uz * r' = bz.
On entry, x = bx, y = by, z = bz.
On exit, x = ux, y = uy, z = uz.
"""
# bz is a copy of z in the format of x
blas.copy(z, bz)
blas.axpy(bz, x, alpha=rho, offsetx=nl, offsety=nl)
# x := Gamma .* (u' * x * u)
# = Gamma .* (u' * (bx + rho * bz) * u)
cngrnc(U, x, trans='T', offsetx=nl)
blas.tbmv(Gamma, x, n=ns2, k=0, ldA=1, offsetx=nl)
blas.tbmv(+W['d'], x, n=nl, k=0, ldA=1)
# y := y - As(x)
# := by - As( Gamma .* u' * (bx + rho * bz) * u)
misc.pack(x, xp, dims)
blas.gemv(Aspkd, xp, y, trans = 'T',alpha = -1.0, beta = 1.0, \
m = ns*(ns+1)/2, n = ms,offsetx = nl)
#y = y - mul(+W['d'][:nl/2],xp[:nl/2])+ mul(+W['d'][nl/2:nl],xp[nl/2:nl])
blas.tbmv(+W['d'], xp, n=nl, k=0, ldA=1)
blas.axpy(xp, y, alpha=-1, n=ms)
blas.axpy(xp, y, alpha=1, n=ms, offsetx=nl / 2)
# y := -y - A(bz)
# = -by - A(bz) + As(Gamma .* (u' * (bx + rho * bz) * u)
Af(bz, y, alpha=-1.0, beta=-1.0)
# y := H^-1 * y
# = H^-1 ( -by - A(bz) + As(Gamma.* u'*(bx + rho*bz)*u) )
# = uy
blas.trsv(H, y)
blas.trsv(H, y, trans='T')
# bz = Vt' * vz * Vt
# = uz where
# vz := Gamma .* ( As'(uy) - x )
# = Gamma .* ( As'(uy) - Gamma .* (u'*(bx + rho *bz)*u) )
# = Gamma.^2 .* ( u' * (A'(uy) - bx - rho * bz) * u ).
misc.pack(x, xp, dims)
blas.scal(-1.0, xp)
blas.gemv(Aspkd,
y,
xp,
alpha=1.0,
beta=1.0,
m=ns * (ns + 1) / 2,
n=ms,
offsety=nl)
#xp[:nl/2] = xp[:nl/2] + mul(+W['d'][:nl/2],y)
#xp[nl/2:nl] = xp[nl/2:nl] - mul(+W['d'][nl/2:nl],y)
blas.copy(y, tmp)
blas.tbmv(+W['d'], tmp, n=nl / 2, k=0, ldA=1)
blas.axpy(tmp, xp, n=nl / 2)
blas.copy(y, tmp)
blas.tbmv(+W['d'], tmp, n=nl / 2, k=0, ldA=1, offsetA=nl / 2)
blas.axpy(tmp, xp, alpha=-1, n=nl / 2, offsety=nl / 2)
# bz[j] is xp unpacked and multiplied with Gamma
blas.copy(xp, bz) #,n = nl)
misc.unpack(xp, bz, dims)
blas.tbmv(Gamma, bz, n=ns2, k=0, ldA=1, offsetx=nl)
# bz = Vt' * bz * Vt
# = uz
cngrnc(Vt, bz, trans='T', offsetx=nl)
symmetrize(bz, ns, offset=nl)
# x = -bz - r * uz * r'
# z contains r.h.s. bz; copy to x
#so far, z = bzc (untouched)
blas.copy(z, x)
blas.copy(bz, z)
cngrnc(W['r'][0], bz, offsetx=nl)
blas.tbmv(W['d'], bz, n=nl, k=0, ldA=1)
blas.axpy(bz, x)
blas.scal(-1.0, x)
def proxqp_clique(c, A, b, z, rho):
"""
Solves the conic QP
min. < c, x > + (rho/2) || x - z ||^2
s.t. A(x) = b
x >= 0
and its dual
max. -< b, y > - 1/(2*rho) * || c + A'(y) - rho * z - s ||^2
s.t. s >= 0.
for a single dense clique.
If the problem has block-arrow correlative sparsity, then the previous
function
X = proxqp(c,A,b,z,rho,**kwargs)
is equivalent to
for k in xrange(ncliques):
X[k] = proxqp_clique(c[k],A[k][k],b[k],z[k],rho,**kwargs)
and each call can be implemented in parallel.
Input arguments.
c is a 'd' matrix of size n_k**2 x 1
A is a 'd' matrix. with size n_k**2 times m_k. Each of its columns
represents a symmetric matrix of order n_k in unpacked column-major
order. The term A ( x ) in the primal constraint is given by
A(x) = A' * vec(x).
The adjoint A'( y ) in the dual constraint is given by
A'(y) = mat( A * y ).
b is a 'd' matrix of size m_k x 1.
z is a 'd' matrix of size n_k**2 x 1
rho is a positive scalar.
Output arguments.
sol : Solution dictionary for quadratic optimization problem.
primal : objective for optimization problem without prox term (trace C*X)
"""
ns2, ms = A.size
ns = int(sqrt(ns2))
dims = {'l': 0, 'q': [], 's': [ns]}
q = +c
blas.axpy(z, q, alpha=-rho)
symmetrize(q, ns, offset=0)
q = q[:]
h = matrix(0.0, (ns2, 1))
bz = +q
xp = +q
def P(u, v, alpha=1.0, beta=0.0):
# v := alpha * rho * u + beta * v
#if not (beta==0.0):
blas.scal(beta, v)
blas.axpy(u, v, alpha=alpha * rho)
def xdot(x, y):
misc.trisc(x, {'l': 0, 'q': [], 's': [ns]})
adot = blas.dot(x, y)
misc.triusc(x, {'l': 0, 'q': [], 's': [ns]})
return adot
def Gf(u, v, alpha=1.0, beta=0.0, trans='N'):
# v = -alpha*u + beta * v
# u and v are vectors representing N symmetric matrices in the
# cvxopt format.
blas.scal(beta, v)
blas.axpy(u, v, alpha=-alpha)
def Af(u, v, alpha=1.0, beta=0.0, trans="N"):
# v := alpha * A(u) + beta * v if trans is 'N'
# v := alpha * A'(u) + beta * v if trans is 'T'
blas.scal(beta, v)
if trans == "N":
sgemv(A,
u,
v,
n=ns,
m=ms,
alpha=alpha,
beta=1.0,
trans="T",
offsetx=0)
elif trans == "T":
sgemv(A,
u,
v,
n=ns,
m=ms,
alpha=alpha,
beta=1.0,
trans="N",
offsetx=0)
U = matrix(0.0, (ns, ns))
Vt = matrix(0.0, (ns, ns))
sv = matrix(0.0, (ns, 1))
Gamma = matrix(0.0, (ns, ns))
if type(A) is spmatrix:
VecAIndex = +A[:].I
Aspkd = matrix(0.0, ((ns + 1) * ns / 2, ms))
As = matrix(A)
def F(W):
# SVD R[j] = U[j] * diag(sig[j]) * Vt[j]
lapack.gesvd(+W['r'][0], sv, jobu='A', jobvt='A', U=U, Vt=Vt)
# Vt[j] := diag(sig[j])^-1 * Vt[j]
for k in xrange(ns):
blas.tbsv(sv, Vt, n=ns, k=0, ldA=1, offsetx=k * ns)
# Gamma[j] is an ns[j] x ns[j] symmetric matrix
#
# (sig[j] * sig[j]') ./ sqrt(1 + rho * (sig[j] * sig[j]').^2)
# S = sig[j] * sig[j]'
S = matrix(0.0, (ns, ns))
blas.syrk(sv, S)
Gamma = div(S, sqrt(1.0 + rho * S**2))
symmetrize(Gamma, ns)
# As represents the scaled mapping
#
# As(x) = A(u * (Gamma .* x) * u')
# As'(y) = Gamma .* (u' * A'(y) * u)
#
# stored in a similar format as A, except that we use packed
# storage for the columns of As[i][j].
if type(A) is spmatrix:
blas.scal(0.0, As)
try:
As[VecAIndex] = +A['s'][VecAIndex]
except:
As[VecAIndex] = +A[VecAIndex]
else:
blas.copy(A, As)
# As[i][j][:,k] = diag( diag(Gamma[j]))*As[i][j][:,k]
# As[i][j][l,:] = Gamma[j][l,l]*As[i][j][l,:]
for k in xrange(ms):
cngrnc(U, As, trans='T', offsetx=k * (ns2))
blas.tbmv(Gamma, As, n=ns2, k=0, ldA=1, offsetx=k * (ns2))
misc.pack(As, Aspkd, {'l': 0, 'q': [], 's': [ns] * ms})
# H is an m times m block matrix with i, k block
#
# Hik = sum_j As[i,j]' * As[k,j]
#
# of size ms[i] x ms[k]. Hik = 0 if As[i,j] or As[k,j]
# are zero for all j
H = matrix(0.0, (ms, ms))
blas.syrk(Aspkd, H, trans='T', beta=1.0, k=ns * (ns + 1) / 2)
lapack.potrf(H)
def solve(x, y, z):
"""
Returns solution of
rho * ux + A'(uy) - r^-T * uz * r^-1 = bx
A(ux) = by
-ux - r * uz * r' = bz.
On entry, x = bx, y = by, z = bz.
On exit, x = ux, y = uy, z = uz.
"""
# bz is a copy of z in the format of x
blas.copy(z, bz)
blas.axpy(bz, x, alpha=rho)
# x := Gamma .* (u' * x * u)
# = Gamma .* (u' * (bx + rho * bz) * u)
cngrnc(U, x, trans='T', offsetx=0)
blas.tbmv(Gamma, x, n=ns2, k=0, ldA=1, offsetx=0)
# y := y - As(x)
# := by - As( Gamma .* u' * (bx + rho * bz) * u)
#blas.copy(x,xp)
#pack_ip(xp,n = ns,m=1,nl=nl)
misc.pack(x, xp, {'l': 0, 'q': [], 's': [ns]})
blas.gemv(Aspkd, xp, y, trans = 'T',alpha = -1.0, beta = 1.0, \
m = ns*(ns+1)/2, n = ms,offsetx = 0)
# y := -y - A(bz)
# = -by - A(bz) + As(Gamma .* (u' * (bx + rho * bz) * u)
Af(bz, y, alpha=-1.0, beta=-1.0)
# y := H^-1 * y
# = H^-1 ( -by - A(bz) + As(Gamma.* u'*(bx + rho*bz)*u) )
# = uy
blas.trsv(H, y)
blas.trsv(H, y, trans='T')
# bz = Vt' * vz * Vt
# = uz where
# vz := Gamma .* ( As'(uy) - x )
# = Gamma .* ( As'(uy) - Gamma .* (u'*(bx + rho *bz)*u) )
# = Gamma.^2 .* ( u' * (A'(uy) - bx - rho * bz) * u ).
#blas.copy(x,xp)
#pack_ip(xp,n=ns,m=1,nl=nl)
misc.pack(x, xp, {'l': 0, 'q': [], 's': [ns]})
blas.scal(-1.0, xp)
blas.gemv(Aspkd,
y,
xp,
alpha=1.0,
beta=1.0,
m=ns * (ns + 1) / 2,
n=ms,
offsety=0)
# bz[j] is xp unpacked and multiplied with Gamma
misc.unpack(xp, bz, {'l': 0, 'q': [], 's': [ns]})
blas.tbmv(Gamma, bz, n=ns2, k=0, ldA=1, offsetx=0)
# bz = Vt' * bz * Vt
# = uz
cngrnc(Vt, bz, trans='T', offsetx=0)
symmetrize(bz, ns, offset=0)
# x = -bz - r * uz * r'
# z contains r.h.s. bz; copy to x
blas.copy(z, x)
blas.copy(bz, z)
cngrnc(W['r'][0], bz, offsetx=0)
blas.axpy(bz, x)
blas.scal(-1.0, x)
return solve
#solvers.options['show_progress'] = True
sol = solvers.coneqp(P, q, Gf, h, dims, Af, b, None, F, xdot=xdot)
primal = blas.dot(c, sol['s'])
return sol, primal
def kkt_solver(x, y, z):
if (TEST_KKT):
x0 = matrix(0., x.size)
y0 = matrix(0., y.size)
z0 = matrix(0., z.size)
x0[:] = x[:]
y0[:] = y[:]
z0[:] = z[:]
# Get default solver solutions.
xp = matrix(0., x.size)
yp = matrix(0., y.size)
zp = matrix(0., z.size)
xp[:] = x[:]
yp[:] = y[:]
zp[:] = z[:]
default_solver(xp, yp, zp)
offset = K * (K + 1) / 2
for i in xrange(K):
symmetrize_matrix(zp, K + 1, offset)
offset += (K + 1) * (K + 1)
# pab = x[:K*(K+1)/2] # p_{ab} 1<=a<=b<=K
# pis = x[K*(K+1)/2:] # \pi_i 1<=i<=K
# z_{ab} := d_{ab}^{-1} z_{ab}
# \mat{z}_i = r_i^{-1} \mat{z}_i r_i^{-t}
misc.scale(z, W, trans='T', inverse='I')
l = z[:]
# l_{ab} := d_{ab}^{-2} z_{ab}
# \mat{z}_i := r_i^{-t}r_i^{-1} \mat{z}_i r_i^{-t} r_i^{-1}
misc.scale(l, W, trans='N', inverse='I')
# The RHS of equations
#
# d_{ab}^{-2}n_{ab} + vec(V_{ab})^t . vec( \sum_i R_i* F R_i*)
# + \sum_i vec(V_{ab})^t . vec( g_i g_i^t) u_i + y
# = -d_{ab}^{-2} l_{ab} + ( p_{ab} - vec(V_{ab})^t . vec(\sum_i L_i*)
#
###
# Lsum := \sum_i L_i
moffset = K * (K + 1) / 2
Lsum = np.sum(np.array(l[moffset:]).reshape((K, (K + 1) * (K + 1))),
axis=0)
Lsum = matrix(Lsum, (K + 1, K + 1))
Ls = Lsum[:K, :K]
x[:K * (K + 1) / 2] -= l[:K * (K + 1) / 2]
dL = matrix(0., (K * (K + 1) / 2, 1))
ab = 0
for a in xrange(K):
dL[ab] = Ls[a, a]
ab += 1
for b in xrange(a + 1, K):
dL[ab] = Ls[a, a] + Ls[b, b] - 2 * Ls[b, a]
ab += 1
x[:K * (K + 1) / 2] -= cvxopt.mul(si2ab, dL)
# The RHS of equations
# g_i^t F g_i + R_{i,K+1,K+1}^2 u_i = pi - L_{i,K+1,K+1}
x[K * (K + 1) / 2:] -= l[K * (K + 1) / 2 + (K + 1) * (K + 1) -
1::(K + 1) * (K + 1)]
# x := B^{-1} Cv
lapack.sytrs(Bm, ipiv, x)
# lapack.potrs( Bm, x)
# y := (oz'.B^{-1}.Cv[:-1] - y)/(oz'.B^{-1}.oz)
y[0] = (blas.dotu(oz, x) - y[0]) / blas.dotu(oz, iB1)
# x := B^{-1} Cv - B^{-1}.oz y
blas.axpy(iB1, x, -y[0])
# Solve for -n_{ab} - d_{ab}^2 z_{ab} = l_{ab}
# We need to return scaled d*z.
# z := d_{ab} d_{ab}^{-2}(n_{ab} + l_{ab})
# = d_{ab}^{-1}n_{ab} + d_{ab}^{-1}l_{ab}
z[:K * (K + 1) / 2] += cvxopt.mul(dis, x[:K * (K + 1) / 2])
z[:K * (K + 1) / 2] *= -1.
# Solve for \mat{z}_i = -R_i (\mat{l}_i + diag(F, u_i)) R_i
# = -L_i - R_i diag(F, u_i) R_i
# We return
# r_i^t \mat{z}_i r_i = -r_i^{-1} (\mat{l}_i + diag(F, u_i)) r_i^{-t}
ui = x[-K:]
nab = tri2symm(x, K)
F = Fisher_matrix(si2, nab)
offset = K * (K + 1) / 2
for i in xrange(K):
start, end = i * (K + 1) * (K + 1), (i + 1) * (K + 1) * (K + 1)
Fu = matrix(0.0, (K + 1, K + 1))
Fu[:K, :K] = F
Fu[K, K] = ui[i]
Fu = matrix(Fu, ((K + 1) * (K + 1), 1))
# Fu := -r_i^{-1} diag( F, u_i) r_i^{-t}
cngrnc(rtis[i], Fu, K + 1, alpha=-1.)
# Fu := -r_i^{-1} (\mat{l}_i + diag( F, u_i )) r_i^{-t}
blas.axpy(z[offset + start:offset + end], Fu, alpha=-1.)
z[offset + start:offset + end] = Fu
if (TEST_KKT):
offset = K * (K + 1) / 2
for i in xrange(K):
symmetrize_matrix(z, K + 1, offset)
offset += (K + 1) * (K + 1)
dz = np.max(np.abs(z - zp))
dx = np.max(np.abs(x - xp))
dy = np.max(np.abs(y - yp))
tol = 1e-5
if dx > tol:
print 'dx='
print dx
print x
print xp
if dy > tol:
print 'dy='
print dy
print y
print yp
if dz > tol:
print 'dz='
print dz
print z
print zp
if dx > tol or dy > tol or dz > tol:
for i, (r, rti) in enumerate(zip(ris, rtis)):
print 'r[%d]=' % i
print r
print 'rti[%d]=' % i
print rti
print 'rti.T*r='
print rti.T * r
for i, d in enumerate(ds):
print 'd[%d]=%g' % (i, d)
print 'x0, y0, z0='
print x0
print y0
print z0
print Bm0
def f(x,y,z):
# residuals
rwt = x[:n+k]
rb = x[n+k]
rv = x[n+k+1:n+k+1+m]
iw_rl1 = mul(W['di'][:m],z[:m])
iw_rl2 = mul(W['di'][m:2*m],z[m:2*m])
ri = [z[2*m+i*(n+1):2*m+(i+1)*(n+1)] for i in range(k)]
# compute 'derived' residuals
# rbwt = rwt + sum(Ai'*inv(Wi)^2*ri) + [-X'*D; E']*inv(Wl1)^2*rl1
rbwt = +rwt
for i in range(k):
tmp = +ri[i]
qscal(tmp,W['beta'][i],W['v'][i],inv=True)
qscal(tmp,W['beta'][i],W['v'][i],inv=True)
rbwt[n+i] -= tmp[0]
blas.gemv(P[i], tmp[1:], rbwt, trans = 'T', alpha = -1.0, beta = 1.0)
tmp = mul(W['di'][:m],iw_rl1)
tmp2 = matrix(0.0,(k,1))
base.gemv(E,tmp,tmp2,trans='T')
rbwt[n:] += tmp2
tmp = mul(d,tmp) # tmp = D*inv(Wl1)^2*rl1
blas.gemv(X,tmp,rbwt,trans='T', alpha = -1.0, beta = 1.0)
# rbb = rb - d'*inv(Wl1)^2*rl1
rbb = rb - sum(tmp)
# rbv = rv - inv(Wl2)*rl2 - inv(Wl1)^2*rl1
rbv = rv - mul(W['di'][m:2*m],iw_rl2) - mul(W['di'][:m],iw_rl1)
# [rtw;rtt] = rbwt + [-X'*D; E']*inv(Wl1)^2*inv(Db)*rbv
tmp = mul(W['di'][:m]**2, mul(dbi,rbv))
rtt = +rbwt[n:]
base.gemv(E, tmp, rtt, trans = 'T', alpha = 1.0, beta = 1.0)
rtw = +rbwt[:n]
tmp = mul(d,tmp)
blas.gemv(X, tmp, rtw, trans = 'T', alpha = -1.0, beta = 1.0)
# rtb = rbb - d'*inv(Wl1)^2*inv(Db)*rbv
rtb = rbb - sum(tmp)
# solve M*[dw;db] = [rtw - Bb*inv(D2)*rtt; rtb + lt'*inv(D2)*rtt]
tmp = mul(d2i,rtt)
tmp2 = matrix(0.0,(n,1))
blas.gemv(Bb,tmp,tmp2)
dwdb = matrix([rtw - tmp2,rtb + blas.dot(mul(d2i,lt),rtt)])
lapack.potrs(M,dwdb)
# compute dt = inv(D2)*(rtt - Bb'*dw + lt*db)
tmp2 = matrix(0.0,(k,1))
blas.gemv(Bb, dwdb[:n], tmp2, trans='T')
dt = mul(d2i, rtt - tmp2 + lt*dwdb[-1])
# compute dv = inv(Db)*(rbv + inv(Wl1)^2*(E*dt - D*X*dw - d*db))
dv = matrix(0.0,(m,1))
blas.gemv(X,dwdb[:n],dv,alpha = -1.0)
dv = mul(d,dv) - d*dwdb[-1]
base.gemv(E, dt, dv, beta = 1.0)
tmp = +dv # tmp = E*dt - D*X*dw - d*db
dv = mul(dbi, rbv + mul(W['di'][:m]**2,dv))
# compute wdz1 = inv(Wl1)*(E*dt - D*X*dw - d*db - dv - rl1)
wdz1 = mul(W['di'][:m], tmp - dv) - iw_rl1
# compute wdz2 = - inv(Wl2)*(dv + rl2)
wdz2 = - mul(W['di'][m:2*m],dv) - iw_rl2
# compute wdzi = inv(Wi)*([-ei'*dt; -Pi*dw] - ri)
wdzi = []
tmp = matrix(0.0,(n,1))
for i in range(k):
blas.gemv(P[i],dwdb[:n],tmp, alpha = -1.0, beta = 0.0)
tmp1 = matrix([-dt[i],tmp])
blas.axpy(ri[i],tmp1,alpha = -1.0)
qscal(tmp1,W['beta'][i],W['v'][i],inv=True)
wdzi.append(tmp1)
# solution
x[:n] = dwdb[:n]
x[n:n+k] = dt
x[n+k] = dwdb[-1]
x[n+k+1:] = dv
z[:m] = wdz1
z[m:2*m] = wdz2
for i in range(k):
z[2*m+i*(n+1):2*m+(i+1)*(n+1)] = wdzi[i]
def f(x, y, z):
"""
1. Compute
uy = D^-1 * (I + Y * S^-1 * Y') * D^-1 *
( -by + sum_k (Dk^2 - Dk^2 * X * Hk^-1 * X' * Dk^2)
* ( bxk + Dk^-2 *bzk ) )
2. For k = 1, ..., m:
uxk = (Dk^2 - Dk^2 * X * Hk^-1 * X' * Dk^2) *
(-uy + bxk + Dk^-2 * bzk)
3. Solve for uz
d .* uz = ( ux - mat(bz) ) ./ d.
Return ux, uy, d .* uz.
"""
###
utime0, stime0 = cputime()
###
# xk := Dk^2 * xk + zk
# = Dk^2 * bxk + bzk
blas.tbmv(dsq, x, n=N * m, k=0, ldA=1)
blas.axpy(z, x)
# y := -y + sum_k ( I - Dk^2 * X * Hk^-1 * X' ) * xk
# = -y + x*ones - sum_k Dk^2 * X * Hk^-1 * X' * xk
# y := -y + x*ones
blas.gemv(x, ones, y, alpha=1.0, beta=-1.0)
# wnm = X' * x (wnm interpreted as an n x m matrix)
blas.gemm(X, x, wnm, m=n, k=N, n=m, transA='T', ldB=N, ldC=n)
# wnm[:,k] = Hk \ wnm[:,k] (for wnm as an n x m matrix)
for k in range(m):
lapack.potrs(H[k], wnm, offsetB=k * n)
for k in range(m):
# wN = X * wnm[:,k]
blas.gemv(X, wnm, wN, offsetx=n * k)
# wN = Dk^2 * wN
blas.tbmv(dsq[:, k], wN, n=N, k=0, ldA=1)
# y := y - wN
blas.axpy(wN, y, -1.0)
# y = D^-1 * (I + Y * S^-1 * Y') * D^-1 * y
#
# Y = [Y1 ... Ym ], Yk = D^-1 * Dk^2 * X * Lk^-T.
# y := D^-1 * y
blas.tbsv(D, y, n=N, k=0, ldA=1)
# wnm = Y' * y (interpreted as an Nm vector)
# = [ L1^-1 * X' * D1^2 * D^-1 * y;
# L2^-1 * X' * D2^2 * D^-1 * y;
# ...
# Lm^-1 * X' * Dm^2 * D^-1 * y ]
for k in range(m):
# wN = D^-1 * Dk^2 * y
blas.copy(y, wN)
blas.tbmv(dsq, wN, n=N, k=0, ldA=1, offsetA=k * N)
blas.tbsv(D, wN, n=N, k=0, ldA=1)
# wnm[:,k] = X' * wN
blas.gemv(X, wN, wnm, trans='T', offsety=k * n)
# wnm[:,k] = Lk^-1 * wnm[:,k]
blas.trsv(H[k], wnm, offsetx=k * n)
# wnm := S^-1 * wnm (an mn-vector)
lapack.potrs(S, wnm)
# y := y + Y * wnm
# = y + D^-1 * [ D1^2 * X * L1^-T ... D2^k * X * Lk^-T]
# * wnm
for k in range(m):
# wnm[:,k] = Lk^-T * wnm[:,k]
blas.trsv(H[k], wnm, trans='T', offsetx=k * n)
# wN = X * wnm[:,k]
blas.gemv(X, wnm, wN, offsetx=k * n)
# wN = D^-1 * Dk^2 * wN
blas.tbmv(dsq, wN, n=N, k=0, ldA=1, offsetA=k * N)
blas.tbsv(D, wN, n=N, k=0, ldA=1)
# y += wN
blas.axpy(wN, y)
# y := D^-1 * y
blas.tbsv(D, y, n=N, k=0, ldA=1)
# For k = 1, ..., m:
#
# xk = (I - Dk^2 * X * Hk^-1 * X') * (-Dk^2 * y + xk)
# x = x - [ D1^2 * y ... Dm^2 * y] (as an N x m matrix)
for k in range(m):
blas.copy(y, wN)
blas.tbmv(dsq, wN, n=N, k=0, ldA=1, offsetA=k * N)
blas.axpy(wN, x, -1.0, offsety=k * N)
# wnm = X' * x (as an n x m matrix)
blas.gemm(X, x, wnm, transA='T', m=n, n=m, k=N, ldB=N, ldC=n)
# wnm[:,k] = Hk^-1 * wnm[:,k]
for k in range(m):
lapack.potrs(H[k], wnm, offsetB=n * k)
for k in range(m):
# wN = X * wnm[:,k]
blas.gemv(X, wnm, wN, offsetx=k * n)
# wN = Dk^2 * wN
blas.tbmv(dsq, wN, n=N, k=0, ldA=1, offsetA=k * N)
# x[:,k] := x[:,k] - wN
blas.axpy(wN, x, -1.0, n=N, offsety=k * N)
# z := ( x - z ) ./ d
blas.axpy(x, z, -1.0)
blas.scal(-1.0, z)
blas.tbsv(d, z, n=N * m, k=0, ldA=1)
###
utime, stime = cputime()
print("Solve: utime = %.2f, stime = %.2f" \
%(utime-utime0, stime-stime0))
def solve(x, y, z):
"""
1. Solve for usx[0]:
Asc'(Asc(usx[0]))
= bx0 + Asc'( ( bsz0 - bsz1 + S * bsx[1] * S ) ./ sqrtG)
= bx0 + Asc'( ( bsz0 + S * ( bsx[1] - bssz1) S )
./ sqrtG)
where bsx[1] = U^-1 * bx[1] * U^-T, bsz0 = U' * bz0 * U,
bsz1 = U' * bz1 * U, bssz1 = S^-1 * bsz1 * S^-1
2. Solve for usx[1]:
usx[1] + S * usx[1] * S
= S * ( As(usx[0]) + bsx[1] - bsz0 ) * S - bsz1
usx[1]
= ( S * (As(usx[0]) + bsx[1] - bsz0) * S - bsz1) ./ Gamma
= -bsz0 + (S * As(usx[0]) * S) ./ Gamma
+ (bsz0 - bsz1 + S * bsx[1] * S ) . / Gamma
= -bsz0 + (S * As(usx[0]) * S) ./ Gamma
+ (bsz0 + S * ( bsx[1] - bssz1 ) * S ) . / Gamma
Unscale ux[1] = Uti * usx[1] * Uti'
3. Compute usz0, usz1
r0' * uz0 * r0 = r0^-1 * ( A(ux[0]) - ux[1] - bz0 ) * r0^-T
r1' * uz1 * r1 = r1^-1 * ( -ux[1] - bz1 ) * r1^-T
"""
# z0 := U' * z0 * U
# = bsz0
__cngrnc(U, z, trans='T')
# z1 := Us' * bz1 * Us
# = S^-1 * U' * bz1 * U * S^-1
# = S^-1 * bsz1 * S^-1
__cngrnc(Us, z, trans='T', offsetx=msq)
# x[1] := Uti' * x[1] * Uti
# = bsx[1]
__cngrnc(Uti, x[1], trans='T')
# x[1] := x[1] - z[msq:]
# = bsx[1] - S^-1 * bsz1 * S^-1
blas.axpy(z, x[1], alpha=-1.0, offsetx=msq)
# x1 = (S * x[1] * S + z[:msq] ) ./ sqrtG
# = (S * ( bsx[1] - S^-1 * bsz1 * S^-1) * S + bsz0 ) ./ sqrtG
# = (S * bsx[1] * S - bsz1 + bsz0 ) ./ sqrtG
# in packed storage
blas.copy(x[1], x1)
blas.tbmv(S, x1, n=msq, k=0, ldA=1)
blas.axpy(z, x1, n=msq)
blas.tbsv(sqrtG, x1, n=msq, k=0, ldA=1)
misc.pack2(x1, {'l': 0, 'q': [], 's': [m]})
# x[0] := x[0] + Asc'*x1
# = bx0 + Asc'( ( bsz0 - bsz1 + S * bsx[1] * S ) ./ sqrtG)
# = bx0 + As'( ( bz0 - bz1 + S * bx[1] * S ) ./ Gamma )
blas.gemv(Asc, x1, x[0], m=mpckd, trans='T', beta=1.0)
# x[0] := H^-1 * x[0]
# = ux[0]
lapack.potrs(H, x[0])
# x1 = Asc(x[0]) .* sqrtG (unpacked)
# = As(x[0])
blas.gemv(Asc, x[0], tmp, m=mpckd)
misc.unpack(tmp, x1, {'l': 0, 'q': [], 's': [m]})
blas.tbmv(sqrtG, x1, n=msq, k=0, ldA=1)
# usx[1] = (x1 + (x[1] - z[:msq])) ./ sqrtG**2
# = (As(ux[0]) + bsx[1] - bsz0 - S^-1 * bsz1 * S^-1)
# ./ Gamma
# x[1] := x[1] - z[:msq]
# = bsx[1] - bsz0 - S^-1 * bsz1 * S^-1
blas.axpy(z, x[1], -1.0, n=msq)
# x[1] := x[1] + x1
# = As(ux) + bsx[1] - bsz0 - S^-1 * bsz1 * S^-1
blas.axpy(x1, x[1])
# x[1] := x[1] / Gammma
# = (As(ux) + bsx[1] - bsz0 + S^-1 * bsz1 * S^-1 ) / Gamma
# = S^-1 * usx[1] * S^-1
blas.tbsv(Gamma, x[1], n=msq, k=0, ldA=1)
# z[msq:] := r1' * U * (-z[msq:] - x[1]) * U * r1
# := -r1' * U * S^-1 * (bsz1 + ux[1]) * S^-1 * U * r1
# := -r1' * uz1 * r1
blas.axpy(x[1], z, n=msq, offsety=msq)
blas.scal(-1.0, z, offset=msq)
__cngrnc(U, z, offsetx=msq)
__cngrnc(W['r'][1], z, trans='T', offsetx=msq)
# x[1] := S * x[1] * S
# = usx1
blas.tbmv(S, x[1], n=msq, k=0, ldA=1)
# z[:msq] = r0' * U' * ( x1 - x[1] - z[:msq] ) * U * r0
# = r0' * U' * ( As(ux) - usx1 - bsz0 ) * U * r0
# = r0' * U' * usz0 * U * r0
# = r0' * uz0 * r0
blas.axpy(x1, z, -1.0, n=msq)
blas.scal(-1.0, z, n=msq)
blas.axpy(x[1], z, -1.0, n=msq)
__cngrnc(U, z)
__cngrnc(W['r'][0], z, trans='T')
# x[1] := Uti * x[1] * Uti'
# = ux[1]
__cngrnc(Uti, x[1])
def xaxpy(u, v, alpha = 1.0):
blas.axpy(u[0], v[0], alpha)
blas.axpy(u[1], v[1], alpha)
blas.axpy(u[2], v[2], alpha)
def solve(A, b, C, L, dims, proxqp=None, sigma=1.0, rho=1.0, **kwargs):
"""
Solves the SDP
min. < c, x >
s.t. A(x) = b
x >= 0
and its dual
max. -< b, y >
s.t. s >= 0.
c + A'(y) = s
Input arguments.
A is an N x M sparse matrix where N = sum_i ns[i]**2 and M = sum_j ms[j]
and ns and ms are the SDP variable sizes and constraint block lengths respectively.
The expression A(x) = b can be written as A.T*xtilde = b, where
xtilde is a stacked vector of vectorized versions of xi.
b is a stacked vector containing constraint vectors of
size m_i x 1.
C is a stacked vector containing vectorized 'd' matrices
c_k of size n_k**2 x 1, representing symmetric matrices.
L is an N X P sparse matrix, where L.T*X = 0 represents the consistency
constraints. If an index k appears in different cliques i,j, and
in converted form are indexed by it, jt, then L[it,l] = 1,
L[jt,l] = -1 for some l.
dims is a dictionary containing conic dimensions.
dims['l'] contains number of linear variables under nonnegativity constrant
dims['q'] contains a list of quadratic cone orders (not implemented!)
dims['s'] contains a list of semidefinite cone matrix orders
proxqp is either a function pointer to a prox implementation, or, if
the problem has block-diagonal correlative sparsity, a pointer
to the prox implementation of a single clique. The choices are:
proxqp_general : solves prox for general sparsity pattern
proxqp_clique : solves prox for a single dense clique with
only semidefinite variables.
proxqp_clique_SNL : solves prox for sensor network localization
problem
sigma is a nonnegative constant (step size)
rho is a nonnegative constaint between 0 and 2 (overrelaxation parameter)
In addition, the following paramters are optional:
maxiter : maximum number of iterations (default 100)
reltol : relative tolerance (default 0.01).
If rp < reltol and rd < reltol and iteration < maxiter,
solver breaks and returns current value.
adaptive : boolean toggle on whether adaptive step size should be
used. (default False)
mu, tau, tauscale : parameters for adaptive step size (see paper)
multiprocess : number of parallel processes (default 1).
if multiprocess = 1, no parallelization is used.
blockdiagonal : boolean toggle on whether problem has block diagonal
correlative sparsity. Note that even if the problem
does have block-diagonal correlative sparsity, if
this parameter is set to False, then general mode
is used. (default False)
verbose : toggle printout (default True)
log_cputime : toggle whether cputime should be logged.
The output is returned in a dictionary with the following files:
x : primal variable in stacked form (X = [x0, ..., x_{N-1}]) where
xk is the vectorized form of the nk x nk submatrix variable.
y, z : iterates in Spingarn's method
cputime, walltime : total cputime and walltime, respectively, spent in
main loop. If log_cputime is False, then cputime is
returned as 0.
primal, rprimal, rdual : evolution of primal optimal value, primal
residual, and dual residual (resp.)
sigma : evolution of step size sigma (changes if adaptive step size is used.)
"""
solvers.options['show_progress'] = False
maxiter = kwargs.get('maxiter', 100)
reltol = kwargs.get('reltol', 0.01)
adaptive = kwargs.get('adaptive', False)
mu = kwargs.get('mu', 2.0)
tau = kwargs.get('tau', 1.5)
multiprocess = kwargs.get('multiprocess', 1)
tauscale = kwargs.get('tauscale', 0.9)
blockdiagonal = kwargs.get('blockdiagonal', False)
verbose = kwargs.get('verbose', True)
log_cputime = kwargs.get('log_cputime', True)
if log_cputime:
try:
import psutil
except (ImportError):
assert False, "Python package psutil required to log cputime. Package can be downloaded at http://code.google.com/p/psutil/"
#format variables
nl, ns = dims['l'], dims['s']
C = C[nl:]
L = L[nl:, :]
As, bs = [], []
cons = []
offset = 0
for k in xrange(len(ns)):
Atmp = sparse(A[nl + offset:nl + offset + ns[k]**2, :])
J = list(set(list(Atmp.J)))
Atmp = Atmp[:, J]
if len(sparse(Atmp).V) == Atmp[:].size[0]: Atmp = matrix(Atmp)
else: Atmp = sparse(Atmp)
As.append(Atmp)
bs.append(b[J])
cons.append(J)
offset += ns[k]**2
if blockdiagonal:
if sum([len(c) for c in cons]) > len(b):
print "Problem does not have block-diagonal correlative sparsity. Switching to general mode."
blockdiagonal = False
#If not block-diagonal correlative sprasity, represent A as a list of lists:
# A[i][j] is a matrix (or spmatrix) if ith clique involves jth constraint block
#Otherwise, A is a list of matrices, where A[i] involves the ith clique and
#ith constraint block only.
if not blockdiagonal:
while sum([len(c) for c in cons]) > len(b):
tobreak = False
for i in xrange(len(cons)):
for j in xrange(i):
ci, cj = set(cons[i]), set(cons[j])
s1 = ci.intersection(cj)
if len(s1) > 0:
s2 = ci.difference(cj)
s3 = cj.difference(ci)
cons.append(list(s1))
if len(s2) > 0:
s2 = list(s2)
if not (s2 in cons): cons.append(s2)
if len(s3) > 0:
s3 = list(s3)
if not (s3 in cons): cons.append(s3)
cons.pop(i)
cons.pop(j)
tobreak = True
break
if tobreak: break
As, bs = [], []
for i in xrange(len(cons)):
J = cons[i]
bs.append(b[J])
Acol = []
offset = 0
for k in xrange(len(ns)):
Atmp = sparse(A[nl + offset:nl + offset + ns[k]**2, J])
if len(Atmp.V) == 0:
Acol.append(0)
elif len(Atmp.V) == Atmp[:].size[0]:
Acol.append(matrix(Atmp))
else:
Acol.append(Atmp)
offset += ns[k]**2
As.append(Acol)
ms = [len(i) for i in bs]
bs = matrix(bs)
meq = L.size[1]
if (not blockdiagonal) and multiprocess > 1:
print "Multiprocessing mode can only be used if correlative sparsity is block diagonal. Switching to sequential mode."
multiprocess = 1
assert rho > 0 and rho < 2, 'Overrelaxaton parameter (rho) must be (strictly) between 0 and 2'
# create routine for projecting on { x | L*x = 0 }
#{ x | L*x = 0 } -> P = I - L*(L.T*L)i *L.T
LTL = spmatrix([], [], [], (meq, meq))
offset = 0
for k in ns:
Lk = L[offset:offset + k**2, :]
base.syrk(Lk, LTL, trans='T', beta=1.0)
offset += k**2
LTLi = cholmod.symbolic(LTL, amd.order(LTL))
cholmod.numeric(LTL, LTLi)
#y = y - L*LTLi*L.T*y
nssq = sum(matrix([nsk**2 for nsk in ns]))
def proj(y, ip=True):
if not ip: y = +y
tmp = matrix(0.0, size=(meq, 1))
ypre = +y
base.gemv(L,y,tmp,trans='T',\
m = nssq, n = meq, beta = 1)
cholmod.solve(LTLi, tmp)
base.gemv(L,tmp,y,beta=1.0,alpha=-1.0,trans='N',\
m = nssq, n = meq)
if not ip: return y
time_to_solve = 0
#initialize variables
X = C * 0.0
Y = +X
Z = +X
dualS = +X
dualy = +b
PXZ = +X
proxargs = {
'C': C,
'A': As,
'b': bs,
'Z': Z,
'X': X,
'sigma': sigma,
'dualS': dualS,
'dualy': dualy,
'ns': ns,
'ms': ms,
'multiprocess': multiprocess
}
if blockdiagonal: proxqp = proxqp_blockdiagonal(proxargs, proxqp)
else: proxqp = proxqp_general
if log_cputime: utime = psutil.cpu_times()[0]
wtime = time.time()
primal = []
rpvec, rdvec = [], []
sigmavec = []
for it in xrange(maxiter):
pv, gap = proxqp(proxargs)
blas.copy(Z, Y)
blas.axpy(X, Y, alpha=-2.0)
proj(Y, ip=True)
#PXZ = sigma*(X-Z)
blas.copy(X, PXZ)
blas.scal(sigma, PXZ)
blas.axpy(Z, PXZ, alpha=-sigma)
#z = z + rho*(y-x)
blas.axpy(X, Y, alpha=1.0)
blas.axpy(Y, Z, alpha=-rho)
xzn = blas.nrm2(PXZ)
xn = blas.nrm2(X)
xyn = blas.nrm2(Y)
proj(PXZ, ip=True)
rdual = blas.nrm2(PXZ)
rpri = sqrt(abs(xyn**2 - rdual**2)) / sigma
if log_cputime: cputime = psutil.cpu_times()[0] - utime
else: cputime = 0
walltime = time.time() - wtime
if rpri / max(xn, 1.0) < reltol and rdual / max(1.0, xzn) < reltol:
break
rpvec.append(rpri / max(xn, 1.0))
rdvec.append(rdual / max(1.0, xzn))
primal.append(pv)
if adaptive:
if (rdual / xzn * mu < rpri / xn):
sigmanew = sigma * tau
elif (rpri / xn * mu < rdual / xzn):
sigmanew = sigma / tau
else:
sigmanew = sigma
if it % 10 == 0 and it > 0 and tau > 1.0:
tauscale *= 0.9
tau = 1 + (tau - 1) * tauscale
sigma = max(min(sigmanew, 10.0), 0.1)
sigmavec.append(sigma)
if verbose:
if log_cputime:
print "%d: primal = %e, gap = %e, (rp,rd) = (%e,%e), sigma = %f, (cputime,walltime) = (%f, %f)" % (
it, pv, gap, rpri / max(xn, 1.0), rdual / max(1.0, xzn),
sigma, cputime, walltime)
else:
print "%d: primal = %e, gap = %e, (rp,rd) = (%e,%e), sigma = %f, walltime = %f" % (
it, pv, gap, rpri / max(xn, 1.0), rdual / max(1.0, xzn),
sigma, walltime)
sol = {}
sol['x'] = X
sol['y'] = Y
sol['z'] = Z
sol['cputime'] = cputime
sol['walltime'] = walltime
sol['primal'] = primal
sol['rprimal'] = rpvec
sol['rdual'] = rdvec
sol['sigma'] = sigmavec
return sol
def solve(x, y, z):
"""
Returns solution of
rho * ux + A'(uy) - r^-T * uz * r^-1 = bx
A(ux) = by
-ux - r * uz * r' = bz.
On entry, x = bx, y = by, z = bz.
On exit, x = ux, y = uy, z = uz.
"""
# bz is a copy of z in the format of x
blas.copy(z, bz)
blas.axpy(bz, x, alpha=rho)
# x := Gamma .* (u' * x * u)
# = Gamma .* (u' * (bx + rho * bz) * u)
cngrnc(U, x, trans='T', offsetx=0)
blas.tbmv(Gamma, x, n=ns2, k=0, ldA=1, offsetx=0)
# y := y - As(x)
# := by - As( Gamma .* u' * (bx + rho * bz) * u)
#blas.copy(x,xp)
#pack_ip(xp,n = ns,m=1,nl=nl)
misc.pack(x, xp, {'l': 0, 'q': [], 's': [ns]})
blas.gemv(Aspkd, xp, y, trans = 'T',alpha = -1.0, beta = 1.0, \
m = ns*(ns+1)/2, n = ms,offsetx = 0)
# y := -y - A(bz)
# = -by - A(bz) + As(Gamma .* (u' * (bx + rho * bz) * u)
Af(bz, y, alpha=-1.0, beta=-1.0)
# y := H^-1 * y
# = H^-1 ( -by - A(bz) + As(Gamma.* u'*(bx + rho*bz)*u) )
# = uy
blas.trsv(H, y)
blas.trsv(H, y, trans='T')
# bz = Vt' * vz * Vt
# = uz where
# vz := Gamma .* ( As'(uy) - x )
# = Gamma .* ( As'(uy) - Gamma .* (u'*(bx + rho *bz)*u) )
# = Gamma.^2 .* ( u' * (A'(uy) - bx - rho * bz) * u ).
#blas.copy(x,xp)
#pack_ip(xp,n=ns,m=1,nl=nl)
misc.pack(x, xp, {'l': 0, 'q': [], 's': [ns]})
blas.scal(-1.0, xp)
blas.gemv(Aspkd,
y,
xp,
alpha=1.0,
beta=1.0,
m=ns * (ns + 1) / 2,
n=ms,
offsety=0)
# bz[j] is xp unpacked and multiplied with Gamma
misc.unpack(xp, bz, {'l': 0, 'q': [], 's': [ns]})
blas.tbmv(Gamma, bz, n=ns2, k=0, ldA=1, offsetx=0)
# bz = Vt' * bz * Vt
# = uz
cngrnc(Vt, bz, trans='T', offsetx=0)
symmetrize(bz, ns, offset=0)
# x = -bz - r * uz * r'
# z contains r.h.s. bz; copy to x
blas.copy(z, x)
blas.copy(bz, z)
cngrnc(W['r'][0], bz, offsetx=0)
blas.axpy(bz, x)
blas.scal(-1.0, x)
def solve(x, y, z):
"""
1. Solve for usx[0]:
Asc'(Asc(usx[0]))
= bx0 + Asc'( ( bsz0 - bsz1 + S * bsx[1] * S ) ./ sqrtG)
= bx0 + Asc'( ( bsz0 + S * ( bsx[1] - bssz1) S )
./ sqrtG)
where bsx[1] = U^-1 * bx[1] * U^-T, bsz0 = U' * bz0 * U,
bsz1 = U' * bz1 * U, bssz1 = S^-1 * bsz1 * S^-1
2. Solve for usx[1]:
usx[1] + S * usx[1] * S
= S * ( As(usx[0]) + bsx[1] - bsz0 ) * S - bsz1
usx[1]
= ( S * (As(usx[0]) + bsx[1] - bsz0) * S - bsz1) ./ Gamma
= -bsz0 + (S * As(usx[0]) * S) ./ Gamma
+ (bsz0 - bsz1 + S * bsx[1] * S ) . / Gamma
= -bsz0 + (S * As(usx[0]) * S) ./ Gamma
+ (bsz0 + S * ( bsx[1] - bssz1 ) * S ) . / Gamma
Unscale ux[1] = Uti * usx[1] * Uti'
3. Compute usz0, usz1
r0' * uz0 * r0 = r0^-1 * ( A(ux[0]) - ux[1] - bz0 ) * r0^-T
r1' * uz1 * r1 = r1^-1 * ( -ux[1] - bz1 ) * r1^-T
"""
# z0 := U' * z0 * U
# = bsz0
__cngrnc(U, z, trans = 'T')
# z1 := Us' * bz1 * Us
# = S^-1 * U' * bz1 * U * S^-1
# = S^-1 * bsz1 * S^-1
__cngrnc(Us, z, trans = 'T', offsetx = msq)
# x[1] := Uti' * x[1] * Uti
# = bsx[1]
__cngrnc(Uti, x[1], trans = 'T')
# x[1] := x[1] - z[msq:]
# = bsx[1] - S^-1 * bsz1 * S^-1
blas.axpy(z, x[1], alpha = -1.0, offsetx = msq)
# x1 = (S * x[1] * S + z[:msq] ) ./ sqrtG
# = (S * ( bsx[1] - S^-1 * bsz1 * S^-1) * S + bsz0 ) ./ sqrtG
# = (S * bsx[1] * S - bsz1 + bsz0 ) ./ sqrtG
# in packed storage
blas.copy(x[1], x1)
blas.tbmv(S, x1, n = msq, k = 0, ldA = 1)
blas.axpy(z, x1, n = msq)
blas.tbsv(sqrtG, x1, n = msq, k = 0, ldA = 1)
misc.pack2(x1, {'l': 0, 'q': [], 's': [m]})
# x[0] := x[0] + Asc'*x1
# = bx0 + Asc'( ( bsz0 - bsz1 + S * bsx[1] * S ) ./ sqrtG)
# = bx0 + As'( ( bz0 - bz1 + S * bx[1] * S ) ./ Gamma )
blas.gemv(Asc, x1, x[0], m = mpckd, trans = 'T', beta = 1.0)
# x[0] := H^-1 * x[0]
# = ux[0]
lapack.potrs(H, x[0])
# x1 = Asc(x[0]) .* sqrtG (unpacked)
# = As(x[0])
blas.gemv(Asc, x[0], tmp, m = mpckd)
misc.unpack(tmp, x1, {'l': 0, 'q': [], 's': [m]})
blas.tbmv(sqrtG, x1, n = msq, k = 0, ldA = 1)
# usx[1] = (x1 + (x[1] - z[:msq])) ./ sqrtG**2
# = (As(ux[0]) + bsx[1] - bsz0 - S^-1 * bsz1 * S^-1)
# ./ Gamma
# x[1] := x[1] - z[:msq]
# = bsx[1] - bsz0 - S^-1 * bsz1 * S^-1
blas.axpy(z, x[1], -1.0, n = msq)
# x[1] := x[1] + x1
# = As(ux) + bsx[1] - bsz0 - S^-1 * bsz1 * S^-1
blas.axpy(x1, x[1])
# x[1] := x[1] / Gammma
# = (As(ux) + bsx[1] - bsz0 + S^-1 * bsz1 * S^-1 ) / Gamma
# = S^-1 * usx[1] * S^-1
blas.tbsv(Gamma, x[1], n = msq, k = 0, ldA = 1)
# z[msq:] := r1' * U * (-z[msq:] - x[1]) * U * r1
# := -r1' * U * S^-1 * (bsz1 + ux[1]) * S^-1 * U * r1
# := -r1' * uz1 * r1
blas.axpy(x[1], z, n = msq, offsety = msq)
blas.scal(-1.0, z, offset = msq)
__cngrnc(U, z, offsetx = msq)
__cngrnc(W['r'][1], z, trans = 'T', offsetx = msq)
# x[1] := S * x[1] * S
# = usx1
blas.tbmv(S, x[1], n = msq, k = 0, ldA = 1)
# z[:msq] = r0' * U' * ( x1 - x[1] - z[:msq] ) * U * r0
# = r0' * U' * ( As(ux) - usx1 - bsz0 ) * U * r0
# = r0' * U' * usz0 * U * r0
# = r0' * uz0 * r0
blas.axpy(x1, z, -1.0, n = msq)
blas.scal(-1.0, z, n = msq)
blas.axpy(x[1], z, -1.0, n = msq)
__cngrnc(U, z)
__cngrnc(W['r'][0], z, trans = 'T')
# x[1] := Uti * x[1] * Uti'
# = ux[1]
__cngrnc(Uti, x[1])
def qp(P, q, G=None, h=None, A=None, b=None):
"""
Solves a pair of primal and dual convex quadratic cone programs
minimize (1/2)*x'*P*x + q'*x
subject to G*x + s = h
A*x = b
s >= 0
maximize -(1/2)*(q + G'*z + A'*y)' * pinv(P) * (q + G'*z + A'*y)
- h'*z - b'*y
subject to q + G'*z + A'*y in range(P)
z >= 0.
The inequalities are with respect to a cone C defined as the Cartesian
product of N + M + 1 cones:
C = C_0 x C_1 x .... x C_N x C_{N+1} x ... x C_{N+M}.
The first cone C_0 is the nonnegative orthant of dimension ml.
The next N cones are 2nd order cones of dimension mq[0], ..., mq[N-1].
The second order cone of dimension m is defined as
{ (u0, u1) in R x R^{m-1} | u0 >= ||u1||_2 }.
The next M cones are positive semidefinite cones of order ms[0], ...,
ms[M-1] >= 0.
Input arguments (basic usage).
P is a dense or sparse 'd' matrix of size (n,n) with the lower
triangular part of the Hessian of the objective stored in the
lower triangle. Must be positive semidefinite.
q is a dense 'd' matrix of size (n,1).
dims is a dictionary with the dimensions of the components of C.
It has three fields.
- dims['l'] = ml, the dimension of the nonnegative orthant C_0.
(ml >= 0.)
- dims['q'] = mq = [ mq[0], mq[1], ..., mq[N-1] ], a list of N
integers with the dimensions of the second order cones
C_1, ..., C_N. (N >= 0 and mq[k] >= 1.)
- dims['s'] = ms = [ ms[0], ms[1], ..., ms[M-1] ], a list of M
integers with the orders of the semidefinite cones
C_{N+1}, ..., C_{N+M}. (M >= 0 and ms[k] >= 0.)
The default value of dims = {'l': G.size[0], 'q': [], 's': []}.
G is a dense or sparse 'd' matrix of size (K,n), where
K = ml + mq[0] + ... + mq[N-1] + ms[0]**2 + ... + ms[M-1]**2.
Each column of G describes a vector
v = ( v_0, v_1, ..., v_N, vec(v_{N+1}), ..., vec(v_{N+M}) )
in V = R^ml x R^mq[0] x ... x R^mq[N-1] x S^ms[0] x ... x S^ms[M-1]
stored as a column vector
[ v_0; v_1; ...; v_N; vec(v_{N+1}); ...; vec(v_{N+M}) ].
Here, if u is a symmetric matrix of order m, then vec(u) is the
matrix u stored in column major order as a vector of length m**2.
We use BLAS unpacked 'L' storage, i.e., the entries in vec(u)
corresponding to the strictly upper triangular entries of u are
not referenced.
h is a dense 'd' matrix of size (K,1), representing a vector in V,
in the same format as the columns of G.
A is a dense or sparse 'd' matrix of size (p,n). The default
value is a sparse 'd' matrix of size (0,n).
b is a dense 'd' matrix of size (p,1). The default value is a
dense 'd' matrix of size (0,1).
It is assumed that rank(A) = p and rank([P; A; G]) = n.
The other arguments are normally not needed. They make it possible
to exploit certain types of structure, as described below.
Output arguments.
Returns a dictionary with keys 'status', 'x', 's', 'z', 'y',
'primal objective', 'dual objective', 'gap', 'relative gap',
'primal infeasibility', 'dual infeasibility', 'primal slack',
'dual slack', 'iterations'.
The 'status' field has values 'optimal' or 'unknown'. 'iterations'
is the number of iterations taken.
If the status is 'optimal', 'x', 's', 'y', 'z' are an approximate
solution of the primal and dual optimality conditions
G*x + s = h, A*x = b
P*x + G'*z + A'*y + q = 0
s >= 0, z >= 0
s'*z = 0.
If the status is 'unknown', 'x', 'y', 's', 'z' are the last
iterates before termination. These satisfy s > 0 and z > 0,
but are not necessarily feasible.
The values of the other fields are defined as follows.
- 'primal objective': the primal objective (1/2)*x'*P*x + q'*x.
- 'dual objective': the dual objective
L(x,y,z) = (1/2)*x'*P*x + q'*x + z'*(G*x - h) + y'*(A*x-b).
- 'gap': the duality gap s'*z.
- 'relative gap': the relative gap, defined as
gap / -primal objective
if the primal objective is negative,
gap / dual objective
if the dual objective is positive, and None otherwise.
- 'primal infeasibility': the residual in the primal constraints,
defined as the maximum of the residual in the inequalities
|| G*x + s + h || / max(1, ||h||)
and the residual in the equalities
|| A*x - b || / max(1, ||b||).
- 'dual infeasibility': the residual in the dual constraints,
defined as
|| P*x + G'*z + A'*y + q || / max(1, ||q||).
- 'primal slack': the smallest primal slack, sup {t | s >= t*e },
where
e = ( e_0, e_1, ..., e_N, e_{N+1}, ..., e_{M+N} )
is the identity vector in C. e_0 is an ml-vector of ones,
e_k, k = 1,..., N, is the unit vector (1,0,...,0) of length
mq[k], and e_k = vec(I) where I is the identity matrix of order
ms[k].
- 'dual slack': the smallest dual slack, sup {t | z >= t*e }.
If the exit status is 'optimal', then the primal and dual
infeasibilities are guaranteed to be less than
Termination with status 'unknown' indicates that the algorithm
failed to find a solution that satisfies the specified tolerances.
In some cases, the returned solution may be fairly accurate. If
the primal and dual infeasibilities, the gap, and the relative gap
are small, then x, y, s, z are close to optimal.
Advanced usage.
Three mechanisms are provided to express problem structure.
1. The user can provide a customized routine for solving linear
equations (`KKT systems')
[ P A' G' ] [ ux ] [ bx ]
[ A 0 0 ] [ uy ] = [ by ].
[ G 0 -W'*W ] [ uz ] [ bz ]
W is a scaling matrix, a block diagonal mapping
W*u = ( W0*u_0, ..., W_{N+M}*u_{N+M} )
defined as follows.
- For the 'l' block (W_0):
W_0 = diag(d),
with d a positive vector of length ml.
- For the 'q' blocks (W_{k+1}, k = 0, ..., N-1):
W_{k+1} = beta_k * ( 2 * v_k * v_k' - J )
where beta_k is a positive scalar, v_k is a vector in R^mq[k]
with v_k[0] > 0 and v_k'*J*v_k = 1, and J = [1, 0; 0, -I].
- For the 's' blocks (W_{k+N}, k = 0, ..., M-1):
W_k * u = vec(r_k' * mat(u) * r_k)
where r_k is a nonsingular matrix of order ms[k], and mat(x) is
the inverse of the vec operation.
The optional argument kktsolver is a Python function that will be
called as g = kktsolver(W). W is a dictionary that contains
the parameters of the scaling:
- W['d'] is a positive 'd' matrix of size (ml,1).
- W['di'] is a positive 'd' matrix with the elementwise inverse of
W['d'].
- W['beta'] is a list [ beta_0, ..., beta_{N-1} ]
- W['v'] is a list [ v_0, ..., v_{N-1} ]
- W['r'] is a list [ r_0, ..., r_{M-1} ]
- W['rti'] is a list [ rti_0, ..., rti_{M-1} ], with rti_k the
inverse of the transpose of r_k.
The call g = kktsolver(W) should return a function g that solves
the KKT system by g(x, y, z). On entry, x, y, z contain the
righthand side bx, by, bz. On exit, they contain the solution,
with uz scaled, the argument z contains W*uz. In other words,
on exit x, y, z are the solution of
[ P A' G'*W^{-1} ] [ ux ] [ bx ]
[ A 0 0 ] [ uy ] = [ by ].
[ G 0 -W' ] [ uz ] [ bz ]
2. The linear operators P*u, G*u and A*u can be specified
by providing Python functions instead of matrices. This can only
be done in combination with 1. above, i.e., it requires the
kktsolver argument.
If P is a function, the call P(u, v, alpha, beta) should evaluate
the matrix-vectors product
v := alpha * P * u + beta * v.
The arguments u and v are required. The other arguments have
default values alpha = 1.0, beta = 0.0.
If G is a function, the call G(u, v, alpha, beta, trans) should
evaluate the matrix-vector products
v := alpha * G * u + beta * v if trans is 'N'
v := alpha * G' * u + beta * v if trans is 'T'.
The arguments u and v are required. The other arguments have
default values alpha = 1.0, beta = 0.0, trans = 'N'.
If A is a function, the call A(u, v, alpha, beta, trans) should
evaluate the matrix-vectors products
v := alpha * A * u + beta * v if trans is 'N'
v := alpha * A' * u + beta * v if trans is 'T'.
The arguments u and v are required. The other arguments
have default values alpha = 1.0, beta = 0.0, trans = 'N'.
If X is the vector space of primal variables x, then:
If this option is used, the argument q must be in the same format
as x, the argument P must be a Python function, the arguments A
and G must be Python functions or None, and the argument
kktsolver is required.
If Y is the vector space of primal variables y:
If this option is used, the argument b must be in the same format
as y, the argument A must be a Python function or None, and the
argument kktsolver is required.
"""
from cvxopt import base, blas, misc
from cvxopt.base import matrix, spmatrix
dims = None
kktsolver = 'chol2'
# Argument error checking depends on level of customization.
customkkt = not isinstance(kktsolver, str)
matrixP = isinstance(P, (matrix, spmatrix))
matrixG = isinstance(G, (matrix, spmatrix))
matrixA = isinstance(A, (matrix, spmatrix))
if (not matrixP or (not matrixG and G is not None) or
(not matrixA and A is not None)) and not customkkt:
raise ValueError("use of function valued P, G, A requires a "
"user-provided kktsolver")
if False and (matrixA or not customkkt):
raise ValueError("use of non vector type for y requires "
"function valued A and user-provided kktsolver")
if (not isinstance(q, matrix) or q.typecode != 'd' or q.size[1] != 1):
raise TypeError("'q' must be a 'd' matrix with one column")
if matrixP:
if P.typecode != 'd' or P.size != (q.size[0], q.size[0]):
raise TypeError("'P' must be a 'd' matrix of size (%d, %d)"
% (q.size[0], q.size[0]))
def fP(x, y, alpha=1.0, beta=0.0):
base.symv(P, x, y, alpha=alpha, beta=beta)
else:
fP = P
if h is None:
h = matrix(0.0, (0, 1))
if not isinstance(h, matrix) or h.typecode != 'd' or h.size[1] != 1:
raise TypeError("'h' must be a 'd' matrix with one column")
if not dims:
dims = {'l': h.size[0], 'q': [], 's': []}
if not isinstance(dims['l'], (int, long)) or dims['l'] < 0:
raise TypeError("'dims['l']' must be a nonnegative integer")
if [k for k in dims['q'] if not isinstance(k, (int, long)) or k < 1]:
raise TypeError("'dims['q']' must be a list of positive integers")
if [k for k in dims['s'] if not isinstance(k, (int, long)) or k < 0]:
raise TypeError("'dims['s']' must be a list of nonnegative "
"integers")
if dims['q'] or dims['s']:
refinement = 1
else:
refinement = 0
cdim = dims['l'] + sum(dims['q']) + sum([k ** 2 for k in dims['s']])
if h.size[0] != cdim:
raise TypeError("'h' must be a 'd' matrix of size (%d,1)" % cdim)
# Data for kth 'q' constraint are found in rows indq[k]:indq[k+1] of G.
indq = [dims['l']]
for k in dims['q']:
indq = indq + [indq[-1] + k]
# Data for kth 's' constraint are found in rows inds[k]:inds[k+1] of G.
inds = [indq[-1]]
for k in dims['s']:
inds = inds + [inds[-1] + k ** 2]
if G is None:
G = spmatrix([], [], [], (0, q.size[0]))
matrixG = True
if matrixG:
if G.typecode != 'd' or G.size != (cdim, q.size[0]):
raise TypeError("'G' must be a 'd' matrix of size (%d, %d)"
% (cdim, q.size[0]))
def fG(x, y, trans='N', alpha=1.0, beta=0.0):
misc.sgemv(G, x, y, dims, trans=trans, alpha=alpha,
beta=beta)
else:
fG = G
if A is None:
A = spmatrix([], [], [], (0, q.size[0]))
matrixA = True
if matrixA:
if A.typecode != 'd' or A.size[1] != q.size[0]:
raise TypeError("'A' must be a 'd' matrix with %d columns"
% q.size[0])
def fA(x, y, trans='N', alpha=1.0, beta=0.0):
base.gemv(A, x, y, trans=trans, alpha=alpha, beta=beta)
else:
fA = A
if b is None:
b = matrix(0.0, (0, 1))
if not isinstance(b, matrix) or b.typecode != 'd' or b.size[1] != 1:
raise TypeError("'b' must be a 'd' matrix with one column")
if matrixA and b.size[0] != A.size[0]:
raise TypeError("'b' must have length %d" % A.size[0])
ws3, wz3 = matrix(0.0, (cdim, 1)), matrix(0.0, (cdim, 1))
def res(ux, uy, uz, us, vx, vy, vz, vs, W, lmbda):
# Evaluates residual in Newton equations:
#
# [ vx ] [ vx ] [ 0 ] [ P A' G' ] [ ux ]
# [ vy ] := [ vy ] - [ 0 ] - [ A 0 0 ] * [ uy ]
# [ vz ] [ vz ] [ W'*us ] [ G 0 0 ] [ W^{-1}*uz ]
#
# vs := vs - lmbda o (uz + us).
# vx := vx - P*ux - A'*uy - G'*W^{-1}*uz
fP(ux, vx, alpha=-1.0, beta=1.0)
fA(uy, vx, alpha=-1.0, beta=1.0, trans='T')
blas.copy(uz, wz3)
misc.scale(wz3, W, inverse='I')
fG(wz3, vx, alpha=-1.0, beta=1.0, trans='T')
# vy := vy - A*ux
fA(ux, vy, alpha=-1.0, beta=1.0)
# vz := vz - G*ux - W'*us
fG(ux, vz, alpha=-1.0, beta=1.0)
blas.copy(us, ws3)
misc.scale(ws3, W, trans='T')
blas.axpy(ws3, vz, alpha=-1.0)
# vs := vs - lmbda o (uz + us)
blas.copy(us, ws3)
blas.axpy(uz, ws3)
misc.sprod(ws3, lmbda, dims, diag='D')
blas.axpy(ws3, vs, alpha=-1.0)
# kktsolver(W) returns a routine for solving
#
# [ P A' G'*W^{-1} ] [ ux ] [ bx ]
# [ A 0 0 ] [ uy ] = [ by ].
# [ G 0 -W' ] [ uz ] [ bz ]
factor = kkt_chol2(G, dims, A)
def kktsolver(W):
return factor(W, P)
resx0 = max(1.0, math.sqrt(np.dot(q.T, q)))
resy0 = max(1.0, math.sqrt(np.dot(b.T, b)))
resz0 = max(1.0, misc.snrm2(h, dims))
if cdim == 0:
return solve_only_equalities_qp(kktsolver, fP, fA, resx0, resy0, dims)
x, y = matrix(q), matrix(b)
s, z = matrix(0.0, (cdim, 1)), matrix(0.0, (cdim, 1))
# Factor
#
# [ P A' G' ]
# [ A 0 0 ].
# [ G 0 -I ]
W = {}
W['d'] = matrix(1.0, (dims['l'], 1))
W['di'] = matrix(1.0, (dims['l'], 1))
W['v'] = [matrix(0.0, (m, 1)) for m in dims['q']]
W['beta'] = len(dims['q']) * [1.0]
for v in W['v']:
v[0] = 1.0
W['r'] = [matrix(0.0, (m, m)) for m in dims['s']]
W['rti'] = [matrix(0.0, (m, m)) for m in dims['s']]
for r in W['r']:
r[::r.size[0] + 1] = 1.0
for rti in W['rti']:
rti[::rti.size[0] + 1] = 1.0
try:
f = kktsolver(W)
except ArithmeticError:
raise ValueError("Rank(A) < p or Rank([P; A; G]) < n")
# Solve
#
# [ P A' G' ] [ x ] [ -q ]
# [ A 0 0 ] * [ y ] = [ b ].
# [ G 0 -I ] [ z ] [ h ]
x = matrix(np.copy(q))
x *= -1.0
y = matrix(np.copy(b))
z = matrix(np.copy(h))
try:
f(x, y, z)
except ArithmeticError:
raise ValueError("Rank(A) < p or Rank([P; G; A]) < n")
s = matrix(np.copy(z))
blas.scal(-1.0, s)
nrms = misc.snrm2(s, dims)
ts = misc.max_step(s, dims)
if ts >= -1e-8 * max(nrms, 1.0):
a = 1.0 + ts
s[:dims['l']] += a
s[indq[:-1]] += a
ind = dims['l'] + sum(dims['q'])
for m in dims['s']:
s[ind: ind + m * m: m + 1] += a
ind += m ** 2
nrmz = misc.snrm2(z, dims)
tz = misc.max_step(z, dims)
if tz >= -1e-8 * max(nrmz, 1.0):
a = 1.0 + tz
z[:dims['l']] += a
z[indq[:-1]] += a
ind = dims['l'] + sum(dims['q'])
for m in dims['s']:
z[ind: ind + m * m: m + 1] += a
ind += m ** 2
rx, ry, rz = matrix(q), matrix(b), matrix(0.0, (cdim, 1))
dx, dy = matrix(x), matrix(y)
dz, ds = matrix(0.0, (cdim, 1)), matrix(0.0, (cdim, 1))
lmbda = matrix(0.0, (dims['l'] + sum(dims['q']) + sum(dims['s']), 1))
lmbdasq = matrix(0.0, (dims['l'] + sum(dims['q']) + sum(dims['s']), 1))
sigs = matrix(0.0, (sum(dims['s']), 1))
sigz = matrix(0.0, (sum(dims['s']), 1))
if show_progress:
print("% 10s% 12s% 10s% 8s% 7s" % ("pcost", "dcost", "gap", "pres",
"dres"))
gap = misc.sdot(s, z, dims)
for iters in range(MAXITERS + 1):
# f0 = (1/2)*x'*P*x + q'*x + r and rx = P*x + q + A'*y + G'*z.
rx = matrix(np.copy(q))
fP(x, rx, beta=1.0)
f0 = 0.5 * (np.dot(x.T, rx) + np.dot(x.T, q))
fA(y, rx, beta=1.0, trans='T')
fG(z, rx, beta=1.0, trans='T')
resx = math.sqrt(np.dot(rx.T, rx))
# ry = A*x - b
ry = matrix(np.copy(b))
fA(x, ry, alpha=1.0, beta=-1.0)
resy = math.sqrt(np.dot(ry.T, ry))
# rz = s + G*x - h
rz = matrix(np.copy(s))
blas.axpy(h, rz, alpha=-1.0)
fG(x, rz, beta=1.0)
resz = misc.snrm2(rz, dims)
# Statistics for stopping criteria.
# pcost = (1/2)*x'*P*x + q'*x
# dcost = (1/2)*x'*P*x + q'*x + y'*(A*x-b) + z'*(G*x-h)
# = (1/2)*x'*P*x + q'*x + y'*(A*x-b) + z'*(G*x-h+s) - z'*s
# = (1/2)*x'*P*x + q'*x + y'*ry + z'*rz - gap
pcost = f0
dcost = f0 + np.dot(y.T, ry) + misc.sdot(z, rz, dims) - gap
if pcost < 0.0:
relgap = gap / -pcost
elif dcost > 0.0:
relgap = gap / dcost
else:
relgap = None
pres = max(resy / resy0, resz / resz0)
dres = resx / resx0
if show_progress:
print("%2d: % 8.4e % 8.4e % 4.0e% 7.0e% 7.0e"
% (iters, pcost, dcost, gap, pres, dres))
if (pres <= FEASTOL and dres <= FEASTOL and (gap <= ABSTOL or
(relgap is not None and relgap <= RELTOL))) or \
iters == MAXITERS:
ind = dims['l'] + sum(dims['q'])
for m in dims['s']:
misc.symm(s, m, ind)
misc.symm(z, m, ind)
ind += m ** 2
ts = misc.max_step(s, dims)
tz = misc.max_step(z, dims)
if iters == MAXITERS:
if show_progress:
print("Terminated (maximum number of iterations "
"reached).")
status = 'unknown'
else:
if show_progress:
print("Optimal solution found.")
status = 'optimal'
return {'x': x, 'y': y, 's': s, 'z': z, 'status': status,
'gap': gap, 'relative gap': relgap,
'primal objective': pcost, 'dual objective': dcost,
'primal infeasibility': pres,
'dual infeasibility': dres, 'primal slack': -ts,
'dual slack': -tz, 'iterations': iters}
# Compute initial scaling W and scaled iterates:
#
# W * z = W^{-T} * s = lambda.
#
# lmbdasq = lambda o lambda.
if iters == 0:
W = misc.compute_scaling(s, z, lmbda, dims)
misc.ssqr(lmbdasq, lmbda, dims)
# f3(x, y, z) solves
#
# [ P A' G' ] [ ux ] [ bx ]
# [ A 0 0 ] [ uy ] = [ by ].
# [ G 0 -W'*W ] [ W^{-1}*uz ] [ bz ]
#
# On entry, x, y, z containg bx, by, bz.
# On exit, they contain ux, uy, uz.
try:
f3 = kktsolver(W)
except ArithmeticError:
if iters == 0:
raise ValueError("Rank(A) < p or Rank([P; A; G]) < n")
else:
ind = dims['l'] + sum(dims['q'])
for m in dims['s']:
misc.symm(s, m, ind)
misc.symm(z, m, ind)
ind += m ** 2
ts = misc.max_step(s, dims)
tz = misc.max_step(z, dims)
if show_progress:
print("Terminated (singular KKT matrix).")
return {'x': x, 'y': y, 's': s, 'z': z,
'status': 'unknown', 'gap': gap,
'relative gap': relgap, 'primal objective': pcost,
'dual objective': dcost, 'primal infeasibility': pres,
'dual infeasibility': dres, 'primal slack': -ts,
'dual slack': -tz, 'iterations': iters}
# f4_no_ir(x, y, z, s) solves
#
# [ 0 ] [ P A' G' ] [ ux ] [ bx ]
# [ 0 ] + [ A 0 0 ] * [ uy ] = [ by ]
# [ W'*us ] [ G 0 0 ] [ W^{-1}*uz ] [ bz ]
#
# lmbda o (uz + us) = bs.
#
# On entry, x, y, z, s contain bx, by, bz, bs.
# On exit, they contain ux, uy, uz, us.
def f4_no_ir(x, y, z, s):
# Solve
#
# [ P A' G' ] [ ux ] [ bx ]
# [ A 0 0 ] [ uy ] = [ by ]
# [ G 0 -W'*W ] [ W^{-1}*uz ] [ bz - W'*(lmbda o\ bs) ]
#
# us = lmbda o\ bs - uz.
#
# On entry, x, y, z, s contains bx, by, bz, bs.
# On exit they contain x, y, z, s.
# s := lmbda o\ s
# = lmbda o\ bs
misc.sinv(s, lmbda, dims)
# z := z - W'*s
# = bz - W'*(lambda o\ bs)
ws3 = matrix(np.copy(s))
misc.scale(ws3, W, trans='T')
blas.axpy(ws3, z, alpha=-1.0)
# Solve for ux, uy, uz
f3(x, y, z)
# s := s - z
# = lambda o\ bs - uz.
blas.axpy(z, s, alpha=-1.0)
# f4(x, y, z, s) solves the same system as f4_no_ir, but applies
# iterative refinement.
if iters == 0:
if refinement:
wx, wy = matrix(q), matrix(b)
wz, ws = matrix(0.0, (cdim, 1)), matrix(0.0, (cdim, 1))
if refinement:
wx2, wy2 = matrix(q), matrix(b)
wz2, ws2 = matrix(0.0, (cdim, 1)), matrix(0.0, (cdim, 1))
def f4(x, y, z, s):
if refinement:
wx = matrix(np.copy(x))
wy = matrix(np.copy(y))
wz = matrix(np.copy(z))
ws = matrix(np.copy(s))
f4_no_ir(x, y, z, s)
for i in range(refinement):
wx2 = matrix(np.copy(wx))
wy2 = matrix(np.copy(wy))
wz2 = matrix(np.copy(wz))
ws2 = matrix(np.copy(ws))
res(x, y, z, s, wx2, wy2, wz2, ws2, W, lmbda)
f4_no_ir(wx2, wy2, wz2, ws2)
y += wx2
y += wy2
blas.axpy(wz2, z)
blas.axpy(ws2, s)
mu = gap / (dims['l'] + len(dims['q']) + sum(dims['s']))
sigma, eta = 0.0, 0.0
for i in [0, 1]:
# Solve
#
# [ 0 ] [ P A' G' ] [ dx ]
# [ 0 ] + [ A 0 0 ] * [ dy ] = -(1 - eta) * r
# [ W'*ds ] [ G 0 0 ] [ W^{-1}*dz ]
#
# lmbda o (dz + ds) = -lmbda o lmbda + sigma*mu*e (i=0)
# lmbda o (dz + ds) = -lmbda o lmbda - dsa o dza
# + sigma*mu*e (i=1) where dsa, dza
# are the solution for i=0.
# ds = -lmbdasq + sigma * mu * e (if i is 0)
# = -lmbdasq - dsa o dza + sigma * mu * e (if i is 1),
# where ds, dz are solution for i is 0.
blas.scal(0.0, ds)
if i == 1:
blas.axpy(ws3, ds, alpha=-1.0)
blas.axpy(lmbdasq, ds, n=dims['l'] + sum(dims['q']),
alpha=-1.0)
ds[:dims['l']] += sigma * mu
ind = dims['l']
for m in dims['q']:
ds[ind] += sigma * mu
ind += m
ind2 = ind
for m in dims['s']:
blas.axpy(lmbdasq, ds, n=m, offsetx=ind2, offsety=ind, incy=m + 1, alpha=-1.0)
ds[ind: ind + m * m: m + 1] += sigma * mu
ind += m * m
ind2 += m
# (dx, dy, dz) := -(1 - eta) * (rx, ry, rz)
dx *= 0.0
dx += (-1.0 + eta) * rx
dy *= 0.0
dy += (-1.0 + eta) * ry
blas.scal(0.0, dz)
blas.axpy(rz, dz, alpha=-1.0 + eta)
try:
f4(dx, dy, dz, ds)
except ArithmeticError:
if iters == 0:
raise ValueError("Rank(A) < p or Rank([P; A; G]) < n")
else:
ind = dims['l'] + sum(dims['q'])
for m in dims['s']:
misc.symm(s, m, ind)
misc.symm(z, m, ind)
ind += m ** 2
ts = misc.max_step(s, dims)
tz = misc.max_step(z, dims)
if show_progress:
print("Terminated (singular KKT matrix).")
return {'x': x, 'y': y, 's': s, 'z': z,
'status': 'unknown', 'gap': gap,
'relative gap': relgap, 'primal objective': pcost,
'dual objective': dcost,
'primal infeasibility': pres,
'dual infeasibility': dres, 'primal slack': -ts,
'dual slack': -tz, 'iterations': iters}
dsdz = misc.sdot(ds, dz, dims)
# Save ds o dz for Mehrotra correction
if i == 0:
ws3 = matrix(np.copy(ds))
misc.sprod(ws3, dz, dims)
# Maximum steps to boundary.
#
# If i is 1, also compute eigenvalue decomposition of the
# 's' blocks in ds,dz. The eigenvectors Qs, Qz are stored in
# dsk, dzk. The eigenvalues are stored in sigs, sigz.
misc.scale2(lmbda, ds, dims)
misc.scale2(lmbda, dz, dims)
if i == 0:
ts = misc.max_step(ds, dims)
tz = misc.max_step(dz, dims)
else:
ts = misc.max_step(ds, dims, sigma=sigs)
tz = misc.max_step(dz, dims, sigma=sigz)
t = max([0.0, ts, tz])
if t == 0:
step = 1.0
else:
if i == 0:
step = min(1.0, 1.0 / t)
else:
step = min(1.0, STEP / t)
if i == 0:
sigma = min(1.0, max(0.0,
1.0 - step + dsdz / gap * step ** 2)) ** EXPON
eta = 0.0
x += step * dx
y += step * dy
# We will now replace the 'l' and 'q' blocks of ds and dz with
# the updated iterates in the current scaling.
# We also replace the 's' blocks of ds and dz with the factors
# Ls, Lz in a factorization Ls*Ls', Lz*Lz' of the updated variables
# in the current scaling.
# ds := e + step*ds for nonlinear, 'l' and 'q' blocks.
# dz := e + step*dz for nonlinear, 'l' and 'q' blocks.
blas.scal(step, ds, n=dims['l'] + sum(dims['q']))
blas.scal(step, dz, n=dims['l'] + sum(dims['q']))
ind = dims['l']
ds[:ind] += 1.0
dz[:ind] += 1.0
for m in dims['q']:
ds[ind] += 1.0
dz[ind] += 1.0
ind += m
# ds := H(lambda)^{-1/2} * ds and dz := H(lambda)^{-1/2} * dz.
#
# This replaced the 'l' and 'q' components of ds and dz with the
# updated iterates in the current scaling.
# The 's' components of ds and dz are replaced with
#
# diag(lmbda_k)^{1/2} * Qs * diag(lmbda_k)^{1/2}
# diag(lmbda_k)^{1/2} * Qz * diag(lmbda_k)^{1/2}
#
misc.scale2(lmbda, ds, dims, inverse='I')
misc.scale2(lmbda, dz, dims, inverse='I')
# sigs := ( e + step*sigs ) ./ lambda for 's' blocks.
# sigz := ( e + step*sigz ) ./ lmabda for 's' blocks.
blas.scal(step, sigs)
blas.scal(step, sigz)
sigs += 1.0
sigz += 1.0
blas.tbsv(lmbda, sigs, n=sum(dims['s']), k=0, ldA=1, offsetA=dims['l'] + sum(dims['q']))
blas.tbsv(lmbda, sigz, n=sum(dims['s']), k=0, ldA=1, offsetA=dims['l'] + sum(dims['q']))
# dsk := Ls = dsk * sqrt(sigs).
# dzk := Lz = dzk * sqrt(sigz).
ind2, ind3 = dims['l'] + sum(dims['q']), 0
for k in range(len(dims['s'])):
m = dims['s'][k]
for i in range(m):
blas.scal(math.sqrt(sigs[ind3 + i]), ds, offset=ind2 + m * i,
n=m)
blas.scal(math.sqrt(sigz[ind3 + i]), dz, offset=ind2 + m * i,
n=m)
ind2 += m * m
ind3 += m
# Update lambda and scaling.
misc.update_scaling(W, lmbda, ds, dz)
# Unscale s, z (unscaled variables are used only to compute
# feasibility residuals).
blas.copy(lmbda, s, n=dims['l'] + sum(dims['q']))
ind = dims['l'] + sum(dims['q'])
ind2 = ind
for m in dims['s']:
blas.scal(0.0, s, offset=ind2)
blas.copy(lmbda, s, offsetx=ind, offsety=ind2, n=m,
incy=m + 1)
ind += m
ind2 += m * m
misc.scale(s, W, trans='T')
blas.copy(lmbda, z, n=dims['l'] + sum(dims['q']))
ind = dims['l'] + sum(dims['q'])
ind2 = ind
for m in dims['s']:
blas.scal(0.0, z, offset=ind2)
blas.copy(lmbda, z, offsetx=ind, offsety=ind2, n=m,
incy=m + 1)
ind += m
ind2 += m * m
misc.scale(z, W, inverse='I')
gap = blas.dot(lmbda, lmbda)
def F(W):
# SVD R[j] = U[j] * diag(sig[j]) * Vt[j]
lapack.gesvd(+W['r'][0], sv, jobu='A', jobvt='A', U=U, Vt=Vt)
W2 = mul(+W['d'], +W['d'])
# Vt[j] := diag(sig[j])^-1 * Vt[j]
for k in xrange(ns):
blas.tbsv(sv, Vt, n=ns, k=0, ldA=1, offsetx=k * ns)
# Gamma[j] is an ns[j] x ns[j] symmetric matrix
# (sig[j] * sig[j]') ./ sqrt(1 + rho * (sig[j] * sig[j]').^2)
# S = sig[j] * sig[j]'
S = matrix(0.0, (ns, ns))
blas.syrk(sv, S)
Gamma = div(S, sqrt(1.0 + rho * S**2))
symmetrize(Gamma, ns)
# As represents the scaled mapping
#
# As(x) = A(u * (Gamma .* x) * u')
# As'(y) = Gamma .* (u' * A'(y) * u)
#
# stored in a similar format as A, except that we use packed
# storage for the columns of As[i][j].
if type(A) is spmatrix:
blas.scal(0.0, As)
As[VecAIndex] = +A[VecAIndex]
else:
blas.copy(A, As)
# As[i][j][:,k] = diag( diag(Gamma[j]))*As[i][j][:,k]
# As[i][j][l,:] = Gamma[j][l,l]*As[i][j][l,:]
for k in xrange(ms):
cngrnc(U, As, trans='T', offsetx=k * (ns2))
blas.tbmv(Gamma, As, n=ns2, k=0, ldA=1, offsetx=k * (ns2))
misc.pack(As, Aspkd, {'l': 0, 'q': [], 's': [ns] * ms})
# H is an m times m block matrix with i, k block
#
# Hik = sum_j As[i,j]' * As[k,j]
#
# of size ms[i] x ms[k]. Hik = 0 if As[i,j] or As[k,j]
# are zero for all j
H = matrix(0.0, (ms, ms))
blas.syrk(Aspkd, H, trans='T', beta=1.0, k=ns * (ns + 1) / 2)
#H = H + spmatrix(W2[:nl/2] + W2[nl/2:] ,range(nl/2),range(nl/2))
blas.axpy(W2, H, n=ms, incy=ms + 1, alpha=1.0)
blas.axpy(W2, H, offsetx=ms, n=ms, incy=ms + 1, alpha=1.0)
lapack.potrf(H)
def solve(x, y, z):
"""
Returns solution of
rho * ux + A'(uy) - r^-T * uz * r^-1 = bx
A(ux) = by
-ux - r * uz * r' = bz.
On entry, x = bx, y = by, z = bz.
On exit, x = ux, y = uy, z = uz.
"""
# bz is a copy of z in the format of x
blas.copy(z, bz)
blas.axpy(bz, x, alpha=rho, offsetx=nl, offsety=nl)
# x := Gamma .* (u' * x * u)
# = Gamma .* (u' * (bx + rho * bz) * u)
cngrnc(U, x, trans='T', offsetx=nl)
blas.tbmv(Gamma, x, n=ns2, k=0, ldA=1, offsetx=nl)
blas.tbmv(+W['d'], x, n=nl, k=0, ldA=1)
# y := y - As(x)
# := by - As( Gamma .* u' * (bx + rho * bz) * u)
misc.pack(x, xp, dims)
blas.gemv(Aspkd, xp, y, trans = 'T',alpha = -1.0, beta = 1.0, \
m = ns*(ns+1)/2, n = ms,offsetx = nl)
#y = y - mul(+W['d'][:nl/2],xp[:nl/2])+ mul(+W['d'][nl/2:nl],xp[nl/2:nl])
blas.tbmv(+W['d'], xp, n=nl, k=0, ldA=1)
blas.axpy(xp, y, alpha=-1, n=ms)
blas.axpy(xp, y, alpha=1, n=ms, offsetx=nl / 2)
# y := -y - A(bz)
# = -by - A(bz) + As(Gamma .* (u' * (bx + rho * bz) * u)
Af(bz, y, alpha=-1.0, beta=-1.0)
# y := H^-1 * y
# = H^-1 ( -by - A(bz) + As(Gamma.* u'*(bx + rho*bz)*u) )
# = uy
blas.trsv(H, y)
blas.trsv(H, y, trans='T')
# bz = Vt' * vz * Vt
# = uz where
# vz := Gamma .* ( As'(uy) - x )
# = Gamma .* ( As'(uy) - Gamma .* (u'*(bx + rho *bz)*u) )
# = Gamma.^2 .* ( u' * (A'(uy) - bx - rho * bz) * u ).
misc.pack(x, xp, dims)
blas.scal(-1.0, xp)
blas.gemv(Aspkd,
y,
xp,
alpha=1.0,
beta=1.0,
m=ns * (ns + 1) / 2,
n=ms,
offsety=nl)
#xp[:nl/2] = xp[:nl/2] + mul(+W['d'][:nl/2],y)
#xp[nl/2:nl] = xp[nl/2:nl] - mul(+W['d'][nl/2:nl],y)
blas.copy(y, tmp)
blas.tbmv(+W['d'], tmp, n=nl / 2, k=0, ldA=1)
blas.axpy(tmp, xp, n=nl / 2)
blas.copy(y, tmp)
blas.tbmv(+W['d'], tmp, n=nl / 2, k=0, ldA=1, offsetA=nl / 2)
blas.axpy(tmp, xp, alpha=-1, n=nl / 2, offsety=nl / 2)
# bz[j] is xp unpacked and multiplied with Gamma
blas.copy(xp, bz) #,n = nl)
misc.unpack(xp, bz, dims)
blas.tbmv(Gamma, bz, n=ns2, k=0, ldA=1, offsetx=nl)
# bz = Vt' * bz * Vt
# = uz
cngrnc(Vt, bz, trans='T', offsetx=nl)
symmetrize(bz, ns, offset=nl)
# x = -bz - r * uz * r'
# z contains r.h.s. bz; copy to x
#so far, z = bzc (untouched)
blas.copy(z, x)
blas.copy(bz, z)
cngrnc(W['r'][0], bz, offsetx=nl)
blas.tbmv(W['d'], bz, n=nl, k=0, ldA=1)
blas.axpy(bz, x)
blas.scal(-1.0, x)
return solve
def f(x, y, z):
# residuals
rwt = x[:n + k]
rb = x[n + k]
rv = x[n + k + 1:n + k + 1 + m]
iw_rl1 = mul(W['di'][:m], z[:m])
iw_rl2 = mul(W['di'][m:2 * m], z[m:2 * m])
ri = [
z[2 * m + i * (n + 1):2 * m + (i + 1) * (n + 1)]
for i in range(k)
]
# compute 'derived' residuals
# rbwt = rwt + sum(Ai'*inv(Wi)^2*ri) + [-X'*D; E']*inv(Wl1)^2*rl1
rbwt = +rwt
for i in range(k):
tmp = +ri[i]
qscal(tmp, W['beta'][i], W['v'][i], inv=True)
qscal(tmp, W['beta'][i], W['v'][i], inv=True)
rbwt[n + i] -= tmp[0]
blas.gemv(P[i], tmp[1:], rbwt, trans='T', alpha=-1.0, beta=1.0)
tmp = mul(W['di'][:m], iw_rl1)
tmp2 = matrix(0.0, (k, 1))
base.gemv(E, tmp, tmp2, trans='T')
rbwt[n:] += tmp2
tmp = mul(d, tmp) # tmp = D*inv(Wl1)^2*rl1
blas.gemv(X, tmp, rbwt, trans='T', alpha=-1.0, beta=1.0)
# rbb = rb - d'*inv(Wl1)^2*rl1
rbb = rb - sum(tmp)
# rbv = rv - inv(Wl2)*rl2 - inv(Wl1)^2*rl1
rbv = rv - mul(W['di'][m:2 * m], iw_rl2) - mul(W['di'][:m], iw_rl1)
# [rtw;rtt] = rbwt + [-X'*D; E']*inv(Wl1)^2*inv(Db)*rbv
tmp = mul(W['di'][:m]**2, mul(dbi, rbv))
rtt = +rbwt[n:]
base.gemv(E, tmp, rtt, trans='T', alpha=1.0, beta=1.0)
rtw = +rbwt[:n]
tmp = mul(d, tmp)
blas.gemv(X, tmp, rtw, trans='T', alpha=-1.0, beta=1.0)
# rtb = rbb - d'*inv(Wl1)^2*inv(Db)*rbv
rtb = rbb - sum(tmp)
# solve M*[dw;db] = [rtw - Bb*inv(D2)*rtt; rtb + lt'*inv(D2)*rtt]
tmp = mul(d2i, rtt)
tmp2 = matrix(0.0, (n, 1))
blas.gemv(Bb, tmp, tmp2)
dwdb = matrix([rtw - tmp2, rtb + blas.dot(mul(d2i, lt), rtt)])
lapack.potrs(M, dwdb)
# compute dt = inv(D2)*(rtt - Bb'*dw + lt*db)
tmp2 = matrix(0.0, (k, 1))
blas.gemv(Bb, dwdb[:n], tmp2, trans='T')
dt = mul(d2i, rtt - tmp2 + lt * dwdb[-1])
# compute dv = inv(Db)*(rbv + inv(Wl1)^2*(E*dt - D*X*dw - d*db))
dv = matrix(0.0, (m, 1))
blas.gemv(X, dwdb[:n], dv, alpha=-1.0)
dv = mul(d, dv) - d * dwdb[-1]
base.gemv(E, dt, dv, beta=1.0)
tmp = +dv # tmp = E*dt - D*X*dw - d*db
dv = mul(dbi, rbv + mul(W['di'][:m]**2, dv))
# compute wdz1 = inv(Wl1)*(E*dt - D*X*dw - d*db - dv - rl1)
wdz1 = mul(W['di'][:m], tmp - dv) - iw_rl1
# compute wdz2 = - inv(Wl2)*(dv + rl2)
wdz2 = -mul(W['di'][m:2 * m], dv) - iw_rl2
# compute wdzi = inv(Wi)*([-ei'*dt; -Pi*dw] - ri)
wdzi = []
tmp = matrix(0.0, (n, 1))
for i in range(k):
blas.gemv(P[i], dwdb[:n], tmp, alpha=-1.0, beta=0.0)
tmp1 = matrix([-dt[i], tmp])
blas.axpy(ri[i], tmp1, alpha=-1.0)
qscal(tmp1, W['beta'][i], W['v'][i], inv=True)
wdzi.append(tmp1)
# solution
x[:n] = dwdb[:n]
x[n:n + k] = dt
x[n + k] = dwdb[-1]
x[n + k + 1:] = dv
z[:m] = wdz1
z[m:2 * m] = wdz2
for i in range(k):
z[2 * m + i * (n + 1):2 * m + (i + 1) * (n + 1)] = wdzi[i]
def xaxpy(u, v, alpha=1.0):
blas.axpy(u[0], v[0], alpha)
blas.axpy(u[1], v[1], alpha)
def P(u, v, alpha=1.0, beta=0.0):
# v := alpha * rho * u + beta * v
#if not (beta==0.0):
blas.scal(beta, v)
blas.axpy(u, v, alpha=alpha * rho)
def Gf(u, v, alpha=1.0, beta=0.0, trans='N'):
# v = -alpha*u + beta * v
blas.scal(beta, v)
blas.axpy(u, v, alpha=-alpha)
def kkt(W):
"""
KKT solver for
Q * ux + uy * 1_m' + mat(uz) = bx
ux * 1_m = by
ux - d.^2 .* mat(uz) = mat(bz).
ux and bx are N x m matrices.
uy and by are N-vectors.
uz and bz are N*m-vectors. mat(uz) is the N x m matrix that
satisfies mat(uz)[:] = uz.
d = mat(W['d']) a positive N x m matrix.
If we eliminate uz from the last equation using
mat(uz) = (ux - mat(bz)) ./ d.^2
we get two equations in ux, uy:
Q * ux + ux ./ d.^2 + uy * 1_m' = bx + mat(bz) ./ d.^2
ux * 1_m = by.
From the 1st equation
uxk = -(Q + Dk)^-1 * uy + (Q + Dk)^-1 * (bxk + Dk * bzk)
where uxk is column k of ux, Dk = diag(d[:,k].^-2), and bzk is
column k of mat(bz). Substituting this in the second equation
gives an equation for uy.
1. Solve for uy
sum_k (Q + Dk)^-1 * uy =
sum_k (Q + Dk)^-1 * (bxk + Dk * bzk) - by.
2. Solve for ux (column by column)
Q * ux + ux ./ d.^2 = bx + mat(bz) ./ d.^2 - uy * 1_m'.
3. Solve for uz
mat(uz) = ( ux - mat(bz) ) ./ d.^2.
Return ux, uy, d .* uz.
"""
# D = d.^-2
D = matrix(W['di']**2, (N, m))
blas.scal(0.0, S)
for k in range(m):
# Hk := Q + Dk
blas.copy(Q, H[k])
H[k][::N + 1] += D[:, k]
# Hk := Hk^-1
# = (Q + Dk)^-1
lapack.potrf(H[k])
lapack.potri(H[k])
# S := S + Hk
# = S + (Q + Dk)^-1
blas.axpy(H[k], S)
# Factor S = sum_k (Q + Dk)^-1
lapack.potrf(S)
def f(x, y, z):
# z := mat(z)
# = mat(bz)
z.size = N, m
# x := x + D .* z
# = bx + mat(bz) ./ d.^2
x += mul(D, z)
# y := y - sum_k (Q + Dk)^-1 * X[:,k]
# = by - sum_k (Q + Dk)^-1 * (bxk + Dk * bzk)
for k in range(m):
blas.symv(H[k], x[:, k], y, alpha=-1.0, beta=1.0)
# y := H^-1 * y
# = -uy
lapack.potrs(S, y)
# x[:,k] := H[k] * (x[:,k] + y)
# = (Q + Dk)^-1 * (bxk + bzk ./ d.^2 + y)
# = ux[:,k]
w = matrix(0.0, (N, 1))
for k in range(m):
# x[:,k] := x[:,k] + y
blas.axpy(y, x, offsety=N * k, n=N)
# w := H[k] * x[:,k]
# = (Q + Dk)^-1 * (bxk + bzk ./ d.^2 + y)
blas.symv(H[k], x, w, offsetx=N * k)
# x[:,k] := w
# = ux[:,k]
blas.copy(w, x, offsety=N * k)
# y := -y
# = uy
blas.scal(-1.0, y)
# z := (x - z) ./ d
blas.axpy(x, z, -1.0)
blas.tbsv(W['d'], z, n=m * N, k=0, ldA=1)
blas.scal(-1.0, z)
z.size = N * m, 1
return f