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)
}
}
func floorplan(Amin *matrix.FloatMatrix) *matrix.FloatMatrix {
rho := 1.0
gamma := 5.0
c := matrix.FloatZeros(22, 1)
c.SetAtColumnArray(0, []int{0, 1}, []float64{1.0, 1.0})
G := matrix.FloatZeros(26, 22)
h := matrix.FloatZeros(26, 1)
// -x1 <= 0
G.SetAt(0, 2, -1.0)
// -x2 <= 0
G.SetAt(1, 3, -1.0)
// -x4 <= 0
G.SetAt(2, 5, -1.0)
// x1 - x3 + w1 <= -rho
G.SetAtRowArray(3, []int{2, 4, 12}, []float64{1.0, -1.0, 1.0})
h.SetAt(3, 0, -rho)
// x2 - x3 + w2 <= -rho
G.SetAtRowArray(4, []int{3, 4, 13}, []float64{1.0, -1.0, 1.0})
h.SetAt(4, 0, -rho)
// x3 - x5 + w3 <= -rho
G.SetAtRowArray(5, []int{4, 6, 14}, []float64{1.0, -1.0, 1.0})
h.SetAt(5, 0, -rho)
// x4 - x5 + w4 <= -rho
G.SetAtRowArray(6, []int{5, 6, 15}, []float64{1.0, -1.0, 1.0})
h.SetAt(6, 0, -rho)
// -W + x5 + w5 <= 0
G.SetAtRowArray(7, []int{0, 6, 16}, []float64{-1.0, 1.0, 1.0})
// -y2 <= 0
G.SetAt(8, 8, -1.0)
// -y3 <= 0
G.SetAt(9, 9, -1.0)
// -y5 <= 0
G.SetAt(10, 11, -1.0)
// -y1 + y2 + h2 <= -rho
G.SetAtRowArray(11, []int{7, 8, 18}, []float64{-1.0, 1.0, 1.0})
h.SetAt(11, 0, -rho)
// y1 - y4 + h1 <= -rho
G.SetAtRowArray(12, []int{7, 10, 17}, []float64{1.0, -1.0, 1.0})
h.SetAt(12, 0, -rho)
// y3 - y4 + h3 <= -rho
G.SetAtRowArray(13, []int{9, 10, 19}, []float64{1.0, -1.0, 1.0})
h.SetAt(13, 0, -rho)
// -H + y4 + h4 <= 0
G.SetAtRowArray(14, []int{1, 10, 20}, []float64{-1.0, 1.0, 1.0})
// -H + y5 + h5 <= 0
G.SetAtRowArray(15, []int{1, 11, 21}, []float64{-1.0, 1.0, 1.0})
// -w1 + h1/gamma <= 0
G.SetAtRowArray(16, []int{12, 17}, []float64{-1.0, 1.0 / gamma})
// w1 - gamma * h1 <= 0
G.SetAtRowArray(17, []int{12, 17}, []float64{1.0, -gamma})
// -w2 + h2/gamma <= 0
G.SetAtRowArray(18, []int{13, 18}, []float64{-1.0, 1.0 / gamma})
// w2 - gamma * h2 <= 0
G.SetAtRowArray(19, []int{13, 18}, []float64{1.0, -gamma})
// -w3 + h3/gamma <= 0
G.SetAtRowArray(20, []int{14, 18}, []float64{-1.0, 1.0 / gamma})
// w3 - gamma * h3 <= 0
G.SetAtRowArray(21, []int{14, 19}, []float64{1.0, -gamma})
// -w4 + h4/gamma <= 0
G.SetAtRowArray(22, []int{15, 19}, []float64{-1.0, 1.0 / gamma})
// w4 - gamma * h4 <= 0
G.SetAtRowArray(23, []int{15, 20}, []float64{1.0, -gamma})
// -w5 + h5/gamma <= 0
G.SetAtRowArray(24, []int{16, 21}, []float64{-1.0, 1.0 / gamma})
// w5 - gamma * h5 <= 0.0
G.SetAtRowArray(25, []int{16, 21}, []float64{1.0, -gamma})
F := NewFloorPlan(Amin)
var dims *cvx.DimensionSet = nil
var solopts cvx.SolverOptions
solopts.MaxIter = 50
solopts.ShowProgress = true
sol, err := cvx.Cpl(F, c, G, h, nil, nil, dims, &solopts)
if err == nil && sol.Status == cvx.Optimal {
return sol.Result.At("x")[0]
} else {
fmt.Printf("result: %v\n", err)
}
return nil
}