// 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) (*matrix.FloatMatrix, []float64) {
if niters <= 0 {
niters = MAXITERS
}
ntdecrs := make([]float64, 0, niters)
if A.Rows() != b.Rows() {
return nil, nil
}
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 := g.Copy().Scale(-1.0)
lapack.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 {
fmt.Printf("last Newton decrement < TOL(%v)\n", TOL)
return x, ntdecrs
}
// Backtracking line search.
// y = d .* A*v
y := d.Mul(A.Times(v))
step := 1.0
for 1-step*y.Max() < 0 {
step *= BETA
}
search:
for {
// t = -step*y
t := y.Copy().Scale(-step)
// t = (1 + t) [e.g. t = 1 - step*y]
t.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 = x.Plus(v)
}
// no solution !!
fmt.Printf("Iteration %d exhausted\n", niters)
return x, ntdecrs
}
func main() {
m := 6
Vdata := [][]float64{
[]float64{1.0, -1.0, -2.0, -2.0, 0.0, 1.5, 1.0},
[]float64{1.0, 2.0, 1.0, -1.0, -2.0, -1.0, 1.0}}
V := matrix.FloatMatrixFromTable(Vdata, matrix.RowOrder)
// V[1, :m] - V[1,1:]
a0 := matrix.Minus(V.GetSubMatrix(1, 0, 1, m), V.GetSubMatrix(1, 1, 1))
// V[0, :m] - V[0,1:]
a1 := matrix.Minus(V.GetSubMatrix(0, 0, 1, m), V.GetSubMatrix(0, 1, 1))
A0, _ := matrix.FloatMatrixStacked(matrix.StackDown, a0.Scale(-1.0), a1)
A0 = A0.Transpose()
b0 := matrix.Mul(A0, V.GetSubMatrix(0, 0, 2, m).Transpose())
b0 = matrix.Times(b0, matrix.FloatWithValue(2, 1, 1.0))
A := make([]*matrix.FloatMatrix, 0)
b := make([]*matrix.FloatMatrix, 0)
A = append(A, A0)
b = append(b, b0)
// List of symbols
C := make([]*matrix.FloatMatrix, 0)
C = append(C, matrix.FloatZeros(2, 1))
var row *matrix.FloatMatrix = nil
for k := 0; k < m; k++ {
row = A0.GetRow(k, row)
nrm := blas.Nrm2Float(row)
row.Scale(2.0 * b0.GetIndex(k) / (nrm * nrm))
C = append(C, row.Transpose())
}
// Voronoi set around C[1]
A1 := matrix.FloatZeros(3, 2)
A1.SetSubMatrix(0, 0, A0.GetSubMatrix(0, 0, 1).Scale(-1.0))
A1.SetSubMatrix(1, 0, matrix.Minus(C[m], C[1]).Transpose())
A1.SetSubMatrix(2, 0, matrix.Minus(C[2], C[1]).Transpose())
b1 := matrix.FloatZeros(3, 1)
b1.SetIndex(0, -b0.GetIndex(0))
v := matrix.Times(A1.GetRow(1, nil), matrix.Plus(C[m], C[1])).Float() * 0.5
b1.SetIndex(1, v)
v = matrix.Times(A1.GetRow(2, nil), matrix.Plus(C[2], C[1])).Float() * 0.5
b1.SetIndex(2, v)
A = append(A, A1)
b = append(b, b1)
// Voronoi set around C[2] ... C[5]
for k := 2; k < 6; k++ {
A1 = matrix.FloatZeros(3, 2)
A1.SetSubMatrix(0, 0, A0.GetSubMatrix(k-1, 0, 1).Scale(-1.0))
A1.SetSubMatrix(1, 0, matrix.Minus(C[k-1], C[k]).Transpose())
A1.SetSubMatrix(2, 0, matrix.Minus(C[k+1], C[k]).Transpose())
b1 = matrix.FloatZeros(3, 1)
b1.SetIndex(0, -b0.GetIndex(k-1))
v := matrix.Times(A1.GetRow(1, nil), matrix.Plus(C[k-1], C[k])).Float() * 0.5
b1.SetIndex(1, v)
v = matrix.Times(A1.GetRow(2, nil), matrix.Plus(C[k+1], C[k])).Float() * 0.5
b1.SetIndex(2, v)
A = append(A, A1)
b = append(b, b1)
}
// Voronoi set around C[6]
A1 = matrix.FloatZeros(3, 2)
A1.SetSubMatrix(0, 0, A0.GetSubMatrix(5, 0, 1).Scale(-1.0))
A1.SetSubMatrix(1, 0, matrix.Minus(C[1], C[6]).Transpose())
A1.SetSubMatrix(2, 0, matrix.Minus(C[5], C[6]).Transpose())
b1 = matrix.FloatZeros(3, 1)
b1.SetIndex(0, -b0.GetIndex(5))
v = matrix.Times(A1.GetRow(1, nil), matrix.Plus(C[1], C[6])).Float() * 0.5
b1.SetIndex(1, v)
v = matrix.Times(A1.GetRow(2, nil), matrix.Plus(C[5], C[6])).Float() * 0.5
b1.SetIndex(2, v)
A = append(A, A1)
b = append(b, b1)
P := matrix.FloatIdentity(2)
q := matrix.FloatZeros(2, 1)
solopts := &cvx.SolverOptions{ShowProgress: false, MaxIter: 30}
ovals := make([]float64, 0)
for k := 1; k < 7; k++ {
sol, err := cvx.Qp(P, q, A[k], b[k], nil, nil, solopts, nil)
_ = err
x := sol.Result.At("x")[0]
ovals = append(ovals, math.Pow(blas.Nrm2Float(x), 2.0))
}
optvals := matrix.FloatVector(ovals)
//fmt.Printf("optvals=\n%v\n", optvals)
rangeFunc := func(n int) []float64 {
r := make([]float64, 0)
for i := 0; i < n; i++ {
r = append(r, float64(i))
}
return r
}
nopts := 200
sigmas := matrix.FloatVector(rangeFunc(nopts))
sigmas.Scale((0.5 - 0.2) / float64(nopts)).Add(0.2)
bndsVal := func(sigma float64) float64 {
// 1.0 - sum(exp( -optvals/(2*sigma**2)))
return 1.0 - matrix.Exp(matrix.Scale(optvals, -1.0/(2*sigma*sigma))).Sum()
}
bnds := matrix.FloatZeros(sigmas.NumElements(), 1)
for j, v := range sigmas.FloatArray() {
bnds.SetIndex(j, bndsVal(v))
}
plotData("plot.png", sigmas.FloatArray(), bnds.FloatArray())
}
