/*
Returns the Nesterov-Todd scaling W at points s and z, and stores the
scaled variable in lmbda.
W * z = W^{-T} * s = lmbda.
W is a MatrixSet with entries:
- W['dnl']: positive vector
- W['dnli']: componentwise inverse of W['dnl']
- W['d']: positive vector
- W['di']: componentwise inverse of W['d']
- W['v']: lists of 2nd order cone vectors with unit hyperbolic norms
- W['beta']: list of positive numbers
- W['r']: list of square matrices
- W['rti']: list of square matrices. rti[k] is the inverse transpose
of r[k].
*/
func computeScaling(s, z, lmbda *matrix.FloatMatrix, dims *sets.DimensionSet, mnl int) (W *sets.FloatMatrixSet, err error) {
/*DEBUGGED*/
err = nil
W = sets.NewFloatSet("dnl", "dnli", "d", "di", "v", "beta", "r", "rti")
// For the nonlinear block:
//
// W['dnl'] = sqrt( s[:mnl] ./ z[:mnl] )
// W['dnli'] = sqrt( z[:mnl] ./ s[:mnl] )
// lambda[:mnl] = sqrt( s[:mnl] .* z[:mnl] )
var stmp, ztmp, lmd *matrix.FloatMatrix
if mnl > 0 {
stmp = matrix.FloatVector(s.FloatArray()[:mnl])
ztmp = matrix.FloatVector(z.FloatArray()[:mnl])
//dnl := stmp.Div(ztmp)
//dnl.Apply(dnl, math.Sqrt)
dnl := matrix.Sqrt(matrix.Div(stmp, ztmp))
//dnli := dnl.Copy()
//dnli.Apply(dnli, func(a float64)float64 { return 1.0/a })
dnli := matrix.Inv(dnl)
W.Set("dnl", dnl)
W.Set("dnli", dnli)
//lmd = stmp.Mul(ztmp)
//lmd.Apply(lmd, math.Sqrt)
lmd = matrix.Sqrt(matrix.Mul(stmp, ztmp))
lmbda.SetIndexesFromArray(lmd.FloatArray(), matrix.MakeIndexSet(0, mnl, 1)...)
} else {
// set for empty matrices
//W.Set("dnl", matrix.FloatZeros(0, 1))
//W.Set("dnli", matrix.FloatZeros(0, 1))
mnl = 0
}
// For the 'l' block:
//
// W['d'] = sqrt( sk ./ zk )
// W['di'] = sqrt( zk ./ sk )
// lambdak = sqrt( sk .* zk )
//
// where sk and zk are the first dims['l'] entries of s and z.
// lambda_k is stored in the first dims['l'] positions of lmbda.
m := dims.At("l")[0]
//td := s.FloatArray()
stmp = matrix.FloatVector(s.FloatArray()[mnl : mnl+m])
//zd := z.FloatArray()
ztmp = matrix.FloatVector(z.FloatArray()[mnl : mnl+m])
//fmt.Printf(".Sqrt()=\n%v\n", matrix.Div(stmp, ztmp).Sqrt().ToString("%.17f"))
//d := stmp.Div(ztmp)
//d.Apply(d, math.Sqrt)
d := matrix.Div(stmp, ztmp).Sqrt()
//di := d.Copy()
//di.Apply(di, func(a float64)float64 { return 1.0/a })
di := matrix.Inv(d)
//fmt.Printf("d:\n%v\n", d)
//fmt.Printf("di:\n%v\n", di)
W.Set("d", d)
W.Set("di", di)
//lmd = stmp.Mul(ztmp)
//lmd.Apply(lmd, math.Sqrt)
lmd = matrix.Mul(stmp, ztmp).Sqrt()
// lmd has indexes mnl:mnl+m and length of m
lmbda.SetIndexesFromArray(lmd.FloatArray(), matrix.MakeIndexSet(mnl, mnl+m, 1)...)
//fmt.Printf("after l:\n%v\n", lmbda)
/*
For the 'q' blocks, compute lists 'v', 'beta'.
The vector v[k] has unit hyperbolic norm:
(sqrt( v[k]' * J * v[k] ) = 1 with J = [1, 0; 0, -I]).
beta[k] is a positive scalar.
The hyperbolic Householder matrix H = 2*v[k]*v[k]' - J
defined by v[k] satisfies
(beta[k] * H) * zk = (beta[k] * H) \ sk = lambda_k
where sk = s[indq[k]:indq[k+1]], zk = z[indq[k]:indq[k+1]].
lambda_k is stored in lmbda[indq[k]:indq[k+1]].
*/
ind := mnl + dims.At("l")[0]
var beta *matrix.FloatMatrix
for _, k := range dims.At("q") {
W.Append("v", matrix.FloatZeros(k, 1))
}
beta = matrix.FloatZeros(len(dims.At("q")), 1)
W.Set("beta", beta)
vset := W.At("v")
for k, m := range dims.At("q") {
v := vset[k]
// a = sqrt( sk' * J * sk ) where J = [1, 0; 0, -I]
aa := jnrm2(s, m, ind)
// b = sqrt( zk' * J * zk )
bb := jnrm2(z, m, ind)
// beta[k] = ( a / b )**1/2
beta.SetIndex(k, math.Sqrt(aa/bb))
// c = sqrt( (sk/a)' * (zk/b) + 1 ) / sqrt(2)
c0 := blas.DotFloat(s, z, &la_.IOpt{"n", m},
&la_.IOpt{"offsetx", ind}, &la_.IOpt{"offsety", ind})
cc := math.Sqrt((c0/aa/bb + 1.0) / 2.0)
// vk = 1/(2*c) * ( (sk/a) + J * (zk/b) )
blas.CopyFloat(z, v, &la_.IOpt{"offsetx", ind}, &la_.IOpt{"n", m})
blas.ScalFloat(v, -1.0/bb)
v.SetIndex(0, -1.0*v.GetIndex(0))
blas.AxpyFloat(s, v, 1.0/aa, &la_.IOpt{"offsetx", ind}, &la_.IOpt{"n", m})
blas.ScalFloat(v, 1.0/2.0/cc)
// v[k] = 1/sqrt(2*(vk0 + 1)) * ( vk + e ), e = [1; 0]
v.SetIndex(0, v.GetIndex(0)+1.0)
blas.ScalFloat(v, (1.0 / math.Sqrt(2.0*v.GetIndex(0))))
/*
To get the scaled variable lambda_k
d = sk0/a + zk0/b + 2*c
lambda_k = [ c;
(c + zk0/b)/d * sk1/a + (c + sk0/a)/d * zk1/b ]
lambda_k *= sqrt(a * b)
*/
lmbda.SetIndex(ind, cc)
dd := 2*cc + s.GetIndex(ind)/aa + z.GetIndex(ind)/bb
blas.CopyFloat(s, lmbda, &la_.IOpt{"offsetx", ind + 1}, &la_.IOpt{"offsety", ind + 1},
&la_.IOpt{"n", m - 1})
zz := (cc + z.GetIndex(ind)/bb) / dd / aa
ss := (cc + s.GetIndex(ind)/aa) / dd / bb
blas.ScalFloat(lmbda, zz, &la_.IOpt{"offset", ind + 1}, &la_.IOpt{"n", m - 1})
blas.AxpyFloat(z, lmbda, ss, &la_.IOpt{"offsetx", ind + 1},
&la_.IOpt{"offsety", ind + 1}, &la_.IOpt{"n", m - 1})
blas.ScalFloat(lmbda, math.Sqrt(aa*bb), &la_.IOpt{"offset", ind}, &la_.IOpt{"n", m})
ind += m
//fmt.Printf("after q[%d]:\n%v\n", k, lmbda)
}
/*
For the 's' blocks: compute two lists 'r' and 'rti'.
r[k]' * sk^{-1} * r[k] = diag(lambda_k)^{-1}
r[k]' * zk * r[k] = diag(lambda_k)
where sk and zk are the entries inds[k] : inds[k+1] of
s and z, reshaped into symmetric matrices.
rti[k] is the inverse of r[k]', so
rti[k]' * sk * rti[k] = diag(lambda_k)^{-1}
rti[k]' * zk^{-1} * rti[k] = diag(lambda_k).
The vectors lambda_k are stored in
lmbda[ dims['l'] + sum(dims['q']) : -1 ]
*/
for _, k := range dims.At("s") {
W.Append("r", matrix.FloatZeros(k, k))
W.Append("rti", matrix.FloatZeros(k, k))
}
maxs := maxdim(dims.At("s"))
work := matrix.FloatZeros(maxs*maxs, 1)
Ls := matrix.FloatZeros(maxs*maxs, 1)
Lz := matrix.FloatZeros(maxs*maxs, 1)
ind2 := ind
for k, m := range dims.At("s") {
r := W.At("r")[k]
rti := W.At("rti")[k]
// Factor sk = Ls*Ls'; store Ls in ds[inds[k]:inds[k+1]].
blas.CopyFloat(s, Ls, &la_.IOpt{"offsetx", ind2}, &la_.IOpt{"n", m * m})
lapack.PotrfFloat(Ls, &la_.IOpt{"n", m}, &la_.IOpt{"lda", m})
// Factor zs[k] = Lz*Lz'; store Lz in dz[inds[k]:inds[k+1]].
blas.CopyFloat(z, Lz, &la_.IOpt{"offsetx", ind2}, &la_.IOpt{"n", m * m})
lapack.PotrfFloat(Lz, &la_.IOpt{"n", m}, &la_.IOpt{"lda", m})
// SVD Lz'*Ls = U*diag(lambda_k)*V'. Keep U in work.
for i := 0; i < m; i++ {
blas.ScalFloat(Ls, 0.0, &la_.IOpt{"offset", i * m}, &la_.IOpt{"n", i})
}
blas.CopyFloat(Ls, work, &la_.IOpt{"n", m * m})
blas.TrmmFloat(Lz, work, 1.0, la_.OptTransA, &la_.IOpt{"lda", m}, &la_.IOpt{"ldb", m},
&la_.IOpt{"n", m}, &la_.IOpt{"m", m})
lapack.GesvdFloat(work, lmbda, nil, nil,
la_.OptJobuO, &la_.IOpt{"lda", m}, &la_.IOpt{"offsetS", ind},
&la_.IOpt{"n", m}, &la_.IOpt{"m", m})
// r = Lz^{-T} * U
blas.CopyFloat(work, r, &la_.IOpt{"n", m * m})
blas.TrsmFloat(Lz, r, 1.0, la_.OptTransA,
&la_.IOpt{"lda", m}, &la_.IOpt{"n", m}, &la_.IOpt{"m", m})
// rti = Lz * U
blas.CopyFloat(work, rti, &la_.IOpt{"n", m * m})
blas.TrmmFloat(Lz, rti, 1.0,
&la_.IOpt{"lda", m}, &la_.IOpt{"n", m}, &la_.IOpt{"m", m})
// r := r * diag(sqrt(lambda_k))
// rti := rti * diag(1 ./ sqrt(lambda_k))
for i := 0; i < m; i++ {
a := math.Sqrt(lmbda.GetIndex(ind + i))
blas.ScalFloat(r, a, &la_.IOpt{"offset", m * i}, &la_.IOpt{"n", m})
blas.ScalFloat(rti, 1.0/a, &la_.IOpt{"offset", m * i}, &la_.IOpt{"n", m})
}
ind += m
ind2 += m * m
}
return
}
func mcsdp(w *matrix.FloatMatrix) (*Solution, error) {
//
// Returns solution x, z to
//
// (primal) minimize sum(x)
// subject to w + diag(x) >= 0
//
// (dual) maximize -tr(w*z)
// subject to diag(z) = 1
// z >= 0.
//
n := w.Rows()
G := &matrixFs{n}
cngrnc := func(r, x *matrix.FloatMatrix, alpha float64) (err error) {
// Congruence transformation
//
// x := alpha * r'*x*r.
//
// r and x are square matrices.
//
err = nil
// tx = matrix(x, (n,n)) is copying and reshaping
// scale diagonal of x by 1/2, (x is (n,n))
tx := x.Copy()
matrix.Reshape(tx, n, n)
tx.Diag().Scale(0.5)
// a := tril(x)*r
// (python: a = +r is really making a copy of r)
a := r.Copy()
err = blas.TrmmFloat(tx, a, 1.0, linalg.OptLeft)
// x := alpha*(a*r' + r*a')
err = blas.Syr2kFloat(r, a, tx, alpha, 0.0, linalg.OptTrans)
// x[:] = tx[:]
tx.CopyTo(x)
return
}
Fkkt := func(W *sets.FloatMatrixSet) (KKTFunc, error) {
// Solve
// -diag(z) = bx
// -diag(x) - inv(rti*rti') * z * inv(rti*rti') = bs
//
// On entry, x and z contain bx and bs.
// On exit, they contain the solution, with z scaled
// (inv(rti)'*z*inv(rti) is returned instead of z).
//
// We first solve
//
// ((rti*rti') .* (rti*rti')) * x = bx - diag(t*bs*t)
//
// and take z = -rti' * (diag(x) + bs) * rti.
var err error = nil
rti := W.At("rti")[0]
// t = rti*rti' as a nonsymmetric matrix.
t := matrix.FloatZeros(n, n)
err = blas.GemmFloat(rti, rti, t, 1.0, 0.0, linalg.OptTransB)
if err != nil {
return nil, err
}
// Cholesky factorization of tsq = t.*t.
tsq := matrix.Mul(t, t)
err = lapack.Potrf(tsq)
if err != nil {
return nil, err
}
f := func(x, y, z *matrix.FloatMatrix) (err error) {
// tbst := t * zs * t = t * bs * t
tbst := z.Copy()
matrix.Reshape(tbst, n, n)
cngrnc(t, tbst, 1.0)
// x := x - diag(tbst) = bx - diag(rti*rti' * bs * rti*rti')
diag := tbst.Diag().Transpose()
x.Minus(diag)
// x := (t.*t)^{-1} * x = (t.*t)^{-1} * (bx - diag(t*bs*t))
err = lapack.Potrs(tsq, x)
// z := z + diag(x) = bs + diag(x)
// z, x are really column vectors here
z.AddIndexes(matrix.MakeIndexSet(0, n*n, n+1), x.FloatArray())
// z := -rti' * z * rti = -rti' * (diag(x) + bs) * rti
cngrnc(rti, z, -1.0)
return nil
}
return f, nil
}
c := matrix.FloatWithValue(n, 1, 1.0)
// initial feasible x: x = 1.0 - min(lmbda(w))
lmbda := matrix.FloatZeros(n, 1)
wp := w.Copy()
lapack.Syevx(wp, lmbda, nil, 0.0, nil, []int{1, 1}, linalg.OptRangeInt)
x0 := matrix.FloatZeros(n, 1).Add(-lmbda.GetAt(0, 0) + 1.0)
s0 := w.Copy()
s0.Diag().Plus(x0.Transpose())
matrix.Reshape(s0, n*n, 1)
// initial feasible z is identity
z0 := matrix.FloatIdentity(n)
matrix.Reshape(z0, n*n, 1)
dims := sets.DSetNew("l", "q", "s")
dims.Set("s", []int{n})
primalstart := sets.FloatSetNew("x", "s")
dualstart := sets.FloatSetNew("z")
primalstart.Set("x", x0)
primalstart.Set("s", s0)
dualstart.Set("z", z0)
var solopts SolverOptions
solopts.MaxIter = 30
solopts.ShowProgress = false
h := w.Copy()
matrix.Reshape(h, h.NumElements(), 1)
return ConeLpCustomMatrix(c, G, h, nil, nil, dims, Fkkt, &solopts, primalstart, dualstart)
}
// Computes analytic center of A*x <= b with A m by n of rank n.
// We assume that b > 0 and the feasible set is bounded.
func acent(A, b *matrix.FloatMatrix, niters int) (x *matrix.FloatMatrix, ntdecrs []float64, err error) {
err = nil
if niters <= 0 {
niters = MAXITERS
}
ntdecrs = make([]float64, 0, niters)
if A.Rows() != b.Rows() {
return nil, nil, errors.New("A.Rows() != b.Rows()")
}
m, n := A.Size()
x = matrix.FloatZeros(n, 1)
H := matrix.FloatZeros(n, n)
// Helper m*n matrix
Dmn := matrix.FloatZeros(m, n)
for i := 0; i < niters; i++ {
// Gradient is g = A^T * (1.0/(b - A*x)). d = 1.0/(b - A*x)
// d is m*1 matrix, g is n*1 matrix
d := matrix.Minus(b, matrix.Times(A, x)).Inv()
g := matrix.Times(A.Transpose(), d)
// Hessian is H = A^T * diag(1./(b-A*x))^2 * A.
// in the original python code expression d[:,n*[0]] creates
// a m*n matrix where each column is copy of column 0.
// We do it here manually.
for i := 0; i < n; i++ {
Dmn.SetColumn(i, d)
}
// Function mul creates element wise product of matrices.
Asc := matrix.Mul(Dmn, A)
blas.SyrkFloat(Asc, H, 1.0, 0.0, linalg.OptTrans)
// Newton step is v = H^-1 * g.
v := matrix.Scale(g, -1.0)
PosvFloat(H, v)
// Directional derivative and Newton decrement.
lam := blas.DotFloat(g, v)
ntdecrs = append(ntdecrs, math.Sqrt(-lam))
if ntdecrs[len(ntdecrs)-1] < TOL {
return x, ntdecrs, err
}
// Backtracking line search.
// y = d .* A*v
y := matrix.Mul(d, matrix.Times(A, v))
step := 1.0
for 1-step*y.Max() < 0 {
step *= BETA
}
search:
for {
// t = -step*y + 1 [e.g. t = 1 - step*y]
t := matrix.Scale(y, -step).Add(1.0)
// ts = sum(log(1-step*y))
ts := t.Log().Sum()
if -ts < ALPHA*step*lam {
break search
}
step *= BETA
}
v.Scale(step)
x.Plus(v)
}
// no solution !!
err = errors.New(fmt.Sprintf("Iteration %d exhausted\n", niters))
return x, ntdecrs, err
}