// The product x := y o y. The 's' components of y are diagonal and
// only the diagonals of x and y are stored.
func ssqr(x, y *matrix.FloatMatrix, dims *sets.DimensionSet, mnl int) (err error) {
/*DEBUGGED*/
blas.Copy(y, x)
ind := mnl + dims.At("l")[0]
err = blas.Tbmv(y, x, &la_.IOpt{"n", ind}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1})
if err != nil {
return
}
for _, m := range dims.At("q") {
v := blas.Nrm2Float(y, &la_.IOpt{"n", m}, &la_.IOpt{"offset", ind})
x.SetIndex(ind, v*v)
blas.ScalFloat(x, 2.0*y.GetIndex(ind), &la_.IOpt{"n", m - 1}, &la_.IOpt{"offset", ind + 1})
ind += m
}
err = blas.Tbmv(y, x, &la_.IOpt{"n", dims.Sum("s")}, &la_.IOpt{"k", 0},
&la_.IOpt{"lda", 1}, &la_.IOpt{"offseta", ind}, &la_.IOpt{"offsetx", ind})
return
}
/*
Evaluates
x := H(lambda^{1/2}) * x (inverse is 'N')
x := H(lambda^{-1/2}) * x (inverse is 'I').
H is the Hessian of the logarithmic barrier.
*/
func scale2(lmbda, x *matrix.FloatMatrix, dims *sets.DimensionSet, mnl int, inverse bool) (err error) {
err = nil
//var minor int = 0
//if ! checkpnt.MinorEmpty() {
// minor = checkpnt.MinorTop()
//}
//fmt.Printf("\n%d.%04d scale2 x=\n%v\nlmbda=\n%v\n", checkpnt.Major(), minor,
// x.ToString("%.17f"), lmbda.ToString("%.17f"))
//if ! checkpnt.MinorEmpty() {
// checkpnt.Check("000scale2", minor)
//}
// For the nonlinear and 'l' blocks,
//
// xk := xk ./ l (inverse is 'N')
// xk := xk .* l (inverse is 'I')
//
// where l is lmbda[:mnl+dims['l']].
ind := mnl + dims.Sum("l")
if !inverse {
blas.TbsvFloat(lmbda, x, &la_.IOpt{"n", ind}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1})
} else {
blas.TbmvFloat(lmbda, x, &la_.IOpt{"n", ind}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1})
}
//if ! checkpnt.MinorEmpty() {
// checkpnt.Check("010scale2", minor)
//}
// For 'q' blocks, if inverse is 'N',
//
// xk := 1/a * [ l'*J*xk;
// xk[1:] - (xk[0] + l'*J*xk) / (l[0] + 1) * l[1:] ].
//
// If inverse is 'I',
//
// xk := a * [ l'*xk;
// xk[1:] + (xk[0] + l'*xk) / (l[0] + 1) * l[1:] ].
//
// a = sqrt(lambda_k' * J * lambda_k), l = lambda_k / a.
for _, m := range dims.At("q") {
var lx, a, c, x0 float64
a = jnrm2(lmbda, m, ind) //&la_.IOpt{"n", m}, &la_.IOpt{"offset", ind})
if !inverse {
lx = jdot(lmbda, x, m, ind, ind) //&la_.IOpt{"n", m}, &la_.IOpt{"offsetx", ind},
//&la_.IOpt{"offsety", ind})
lx /= a
} else {
lx = blas.DotFloat(lmbda, x, &la_.IOpt{"n", m}, &la_.IOpt{"offsetx", ind},
&la_.IOpt{"offsety", ind})
lx /= a
}
x0 = x.GetIndex(ind)
x.SetIndex(ind, lx)
c = (lx + x0) / (lmbda.GetIndex(ind)/a + 1.0) / a
if !inverse {
c *= -1.0
}
blas.AxpyFloat(lmbda, x, c, &la_.IOpt{"n", m - 1}, &la_.IOpt{"offsetx", ind + 1},
&la_.IOpt{"offsety", ind + 1})
if !inverse {
a = 1.0 / a
}
blas.ScalFloat(x, a, &la_.IOpt{"offset", ind}, &la_.IOpt{"n", m})
ind += m
}
//if ! checkpnt.MinorEmpty() {
// checkpnt.Check("020scale2", minor)
//}
// For the 's' blocks, if inverse is 'N',
//
// xk := vec( diag(l)^{-1/2} * mat(xk) * diag(k)^{-1/2}).
//
// If inverse is true,
//
// xk := vec( diag(l)^{1/2} * mat(xk) * diag(k)^{1/2}).
//
// where l is kth block of lambda.
//
// We scale upper and lower triangular part of mat(xk) because the
// inverse operation will be applied to nonsymmetric matrices.
ind2 := ind
sdims := dims.At("s")
for k := 0; k < len(sdims); k++ {
m := sdims[k]
scaleF := func(v, x float64) float64 {
return math.Sqrt(v) * math.Sqrt(x)
}
for j := 0; j < m; j++ {
c := matrix.FloatVector(lmbda.FloatArray()[ind2 : ind2+m])
c.ApplyConst(lmbda.GetIndex(ind2+j), scaleF)
if !inverse {
blas.Tbsv(c, x, &la_.IOpt{"n", m}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1},
&la_.IOpt{"offsetx", ind + j*m})
} else {
blas.Tbmv(c, x, &la_.IOpt{"n", m}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1},
&la_.IOpt{"offsetx", ind + j*m})
}
}
ind += m * m
ind2 += m
}
//if ! checkpnt.MinorEmpty() {
// checkpnt.Check("030scale2", minor)
//}
return
}
// The product x := (y o x). If diag is 'D', the 's' part of y is
// diagonal and only the diagonal is stored.
func sprod(x, y *matrix.FloatMatrix, dims *sets.DimensionSet, mnl int, opts ...la_.Option) (err error) {
err = nil
diag := la_.GetStringOpt("diag", "N", opts...)
// For the nonlinear and 'l' blocks:
//
// yk o xk = yk .* xk.
ind := mnl + dims.At("l")[0]
err = blas.Tbmv(y, x, &la_.IOpt{"n", ind}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1})
if err != nil {
return
}
//fmt.Printf("Sprod l:x=\n%v\n", x)
// For 'q' blocks:
//
// [ l0 l1' ]
// yk o xk = [ ] * xk
// [ l1 l0*I ]
//
// where yk = (l0, l1).
for _, m := range dims.At("q") {
dd := blas.DotFloat(x, y, &la_.IOpt{"offsetx", ind}, &la_.IOpt{"offsety", ind},
&la_.IOpt{"n", m})
//fmt.Printf("dd=%v\n", dd)
alpha := y.GetIndex(ind)
//fmt.Printf("scal=%v\n", alpha)
blas.ScalFloat(x, alpha, &la_.IOpt{"offset", ind + 1}, &la_.IOpt{"n", m - 1})
alpha = x.GetIndex(ind)
//fmt.Printf("axpy=%v\n", alpha)
blas.AxpyFloat(y, x, alpha, &la_.IOpt{"offsetx", ind + 1}, &la_.IOpt{"offsety", ind + 1},
&la_.IOpt{"n", m - 1})
x.SetIndex(ind, dd)
ind += m
}
//fmt.Printf("Sprod q :x=\n%v\n", x)
// For the 's' blocks:
//
// yk o sk = .5 * ( Yk * mat(xk) + mat(xk) * Yk )
//
// where Yk = mat(yk) if diag is 'N' and Yk = diag(yk) if diag is 'D'.
if diag[0] == 'N' {
// DEBUGGED
maxm := maxdim(dims.At("s"))
A := matrix.FloatZeros(maxm, maxm)
for _, m := range dims.At("s") {
blas.Copy(x, A, &la_.IOpt{"offsetx", ind}, &la_.IOpt{"n", m * m})
for i := 0; i < m-1; i++ { // i < m-1 --> i < m
symm(A, m, 0)
symm(y, m, ind)
}
err = blas.Syr2kFloat(A, y, x, 0.5, 0.0, &la_.IOpt{"n", m}, &la_.IOpt{"k", m},
&la_.IOpt{"lda", m}, &la_.IOpt{"ldb", m}, &la_.IOpt{"ldc", m},
&la_.IOpt{"offsetb", ind}, &la_.IOpt{"offsetc", ind})
if err != nil {
return
}
ind += m * m
}
//fmt.Printf("Sprod diag=N s:x=\n%v\n", x)
} else {
ind2 := ind
for _, m := range dims.At("s") {
for i := 0; i < m; i++ {
// original: u = 0.5 * ( y[ind2+i:ind2+m] + y[ind2+i] )
// creates matrix of elements: [ind2+i ... ind2+m] then
// element wisely adds y[ind2+i] and scales by 0.5
iset := matrix.MakeIndexSet(ind2+i, ind2+m, 1)
u := matrix.FloatVector(y.GetIndexes(iset...))
u.Add(y.GetIndex(ind2 + i))
u.Scale(0.5)
err = blas.Tbmv(u, x, &la_.IOpt{"n", m - i}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1},
&la_.IOpt{"offsetx", ind + i*(m+1)})
if err != nil {
return
}
}
ind += m * m
ind2 += m
}
//fmt.Printf("Sprod diag=T s:x=\n%v\n", x)
}
return
}