func main() {
flag.Parse()
reftest := flag.NFlag() > 0
gdata0 := [][]float64{
[]float64{12., 13., 12.},
[]float64{6., -3., -12.},
[]float64{-5., -5., 6.}}
gdata1 := [][]float64{
[]float64{3., 3., -1., 1.},
[]float64{-6., -6., -9., 19.},
[]float64{10., -2., -2., -3.}}
c := matrix.FloatVector([]float64{-2.0, 1.0, 5.0})
g0 := matrix.FloatMatrixStacked(gdata0, matrix.ColumnOrder)
g1 := matrix.FloatMatrixStacked(gdata1, matrix.ColumnOrder)
Ghq := cvx.FloatSetNew("Gq", "hq")
Ghq.Append("Gq", g0, g1)
h0 := matrix.FloatVector([]float64{-12.0, -3.0, -2.0})
h1 := matrix.FloatVector([]float64{27.0, 0.0, 3.0, -42.0})
Ghq.Append("hq", h0, h1)
var Gl, hl, A, b *matrix.FloatMatrix = nil, nil, nil, nil
var solopts cvx.SolverOptions
solopts.MaxIter = 30
solopts.ShowProgress = true
sol, err := cvx.Socp(c, Gl, hl, A, b, Ghq, &solopts, nil, nil)
fmt.Printf("status: %v\n", err)
if sol != nil && sol.Status == cvx.Optimal {
x := sol.Result.At("x")[0]
fmt.Printf("x=\n%v\n", x.ToString("%.9f"))
for i, m := range sol.Result.At("sq") {
fmt.Printf("sq[%d]=\n%v\n", i, m.ToString("%.9f"))
}
for i, m := range sol.Result.At("zq") {
fmt.Printf("zq[%d]=\n%v\n", i, m.ToString("%.9f"))
}
if reftest {
sq0 := sol.Result.At("sq")[0]
sq1 := sol.Result.At("sq")[1]
zq0 := sol.Result.At("zq")[0]
zq1 := sol.Result.At("zq")[1]
check(x, sq0, sq1, zq0, zq1)
}
}
}
func main() {
flag.Parse()
reftest := flag.NFlag() > 0
gdata := [][]float64{
[]float64{16., 7., 24., -8., 8., -1., 0., -1., 0., 0., 7.,
-5., 1., -5., 1., -7., 1., -7., -4.},
[]float64{-14., 2., 7., -13., -18., 3., 0., 0., -1., 0., 3.,
13., -6., 13., 12., -10., -6., -10., -28.},
[]float64{5., 0., -15., 12., -6., 17., 0., 0., 0., -1., 9.,
6., -6., 6., -7., -7., -6., -7., -11.}}
hdata := []float64{-3., 5., 12., -2., -14., -13., 10., 0., 0., 0., 68.,
-30., -19., -30., 99., 23., -19., 23., 10.}
c := matrix.FloatVector([]float64{-6., -4., -5.})
G := matrix.FloatMatrixStacked(gdata)
h := matrix.FloatVector(hdata)
dims := cvx.DSetNew("l", "q", "s")
dims.Set("l", []int{2})
dims.Set("q", []int{4, 4})
dims.Set("s", []int{3})
var solopts cvx.SolverOptions
solopts.MaxIter = 30
solopts.ShowProgress = true
sol, err := cvx.ConeLp(c, G, h, nil, nil, dims, &solopts, nil, nil)
if err == nil {
x := sol.Result.At("x")[0]
s := sol.Result.At("s")[0]
z := sol.Result.At("z")[0]
fmt.Printf("Optimal\n")
fmt.Printf("x=\n%v\n", x.ToString("%.9f"))
fmt.Printf("s=\n%v\n", s.ToString("%.9f"))
fmt.Printf("z=\n%v\n", z.ToString("%.9f"))
if reftest {
check(x, s, z)
}
} else {
fmt.Printf("status: %s\n", err)
}
}
func main() {
Sdata := [][]float64{
[]float64{ 4e-2, 6e-3, -4e-3, 0.0 },
[]float64{ 6e-3, 1e-2, 0.0, 0.0 },
[]float64{-4e-3, 0.0, 2.5e-3, 0.0 },
[]float64{ 0.0, 0.0, 0.0, 0.0 }}
pbar := matrix.FloatVector([]float64{.12, .10, .07, .03})
S := matrix.FloatMatrixStacked(Sdata)
n := pbar.Rows()
G := matrix.FloatDiagonal(n, -1.0)
h := matrix.FloatZeros(n, 1)
A := matrix.FloatWithValue(1, n, 1.0)
b := matrix.FloatNew(1,1, []float64{1.0})
var solopts cvx.SolverOptions
solopts.MaxIter = 30
solopts.ShowProgress = true
mu := 1.0
Smu := S.Copy().Scale(mu)
pbarNeg := pbar.Copy().Scale(-1.0)
fmt.Printf("Smu=\n%v\n", Smu.String())
fmt.Printf("-pbar=\n%v\n", pbarNeg.String())
sol, err := cvx.Qp(Smu, pbarNeg, G, h, A, b, &solopts, nil)
fmt.Printf("status: %v\n", err)
if sol != nil && sol.Status == cvx.Optimal {
x := sol.Result.At("x")[0]
ret := blas.DotFloat(x, pbar)
risk := math.Sqrt(blas.DotFloat(x, S.Times(x)))
fmt.Printf("ret=%.3f, risk=%.3f\n", ret, risk)
fmt.Printf("x=\n%v\n", x)
}
}
func main() {
flag.Parse()
reftest := flag.NFlag() > 0
gdata0 := [][]float64{
[]float64{-7., -11., -11., 3.},
[]float64{7., -18., -18., 8.},
[]float64{-2., -8., -8., 1.}}
gdata1 := [][]float64{
[]float64{-21., -11., 0., -11., 10., 8., 0., 8., 5.},
[]float64{0., 10., 16., 10., -10., -10., 16., -10., 3.},
[]float64{-5., 2., -17., 2., -6., 8., -17., -7., 6.}}
hdata0 := [][]float64{
[]float64{33., -9.},
[]float64{-9., 26.}}
hdata1 := [][]float64{
[]float64{14., 9., 40.},
[]float64{9., 91., 10.},
[]float64{40., 10., 15.}}
g0 := matrix.FloatMatrixStacked(gdata0, matrix.ColumnOrder)
g1 := matrix.FloatMatrixStacked(gdata1, matrix.ColumnOrder)
Ghs := cvx.FloatSetNew("Gs", "hs")
Ghs.Append("Gs", g0, g1)
h0 := matrix.FloatMatrixStacked(hdata0, matrix.ColumnOrder)
h1 := matrix.FloatMatrixStacked(hdata1, matrix.ColumnOrder)
Ghs.Append("hs", h0, h1)
c := matrix.FloatVector([]float64{1.0, -1.0, 1.0})
Ghs.Print()
fmt.Printf("calling...\n")
// nil variables
var Gs, hs, A, b *matrix.FloatMatrix = nil, nil, nil, nil
var solopts cvx.SolverOptions
solopts.MaxIter = 30
solopts.ShowProgress = true
sol, err := cvx.Sdp(c, Gs, hs, A, b, Ghs, &solopts, nil, nil)
if sol != nil && sol.Status == cvx.Optimal {
x := sol.Result.At("x")[0]
fmt.Printf("x=\n%v\n", x.ToString("%.9f"))
for i, m := range sol.Result.At("ss") {
fmt.Printf("ss[%d]=\n%v\n", i, m.ToString("%.9f"))
}
for i, m := range sol.Result.At("zs") {
fmt.Printf("zs[%d]=\n%v\n", i, m.ToString("%.9f"))
}
if reftest {
ss0 := sol.Result.At("ss")[0]
ss1 := sol.Result.At("ss")[1]
zs0 := sol.Result.At("zs")[0]
zs1 := sol.Result.At("zs")[1]
check(x, ss0, ss1, zs0, zs1)
}
} else {
fmt.Printf("status: %v\n", err)
}
}