func main() {
// input matrix in Triplet format
// including repeated positions. e.g. (0,0)
var A la.Triplet
A.Init(5, 5, 13)
A.Put(0, 0, 1.0) // << repeated
A.Put(0, 0, 1.0) // << repeated
A.Put(1, 0, 3.0)
A.Put(0, 1, 3.0)
A.Put(2, 1, -1.0)
A.Put(4, 1, 4.0)
A.Put(1, 2, 4.0)
A.Put(2, 2, -3.0)
A.Put(3, 2, 1.0)
A.Put(4, 2, 2.0)
A.Put(2, 3, 2.0)
A.Put(1, 4, 6.0)
A.Put(4, 4, 1.0)
// right-hand-side
b := []float64{8.0, 45.0, -3.0, 3.0, 19.0}
// solve
x, err := la.SolveRealLinSys(&A, b)
if err != nil {
io.Pfred("solver failed:\n%v", err)
return
}
// output
la.PrintMat("a", A.ToMatrix(nil).ToDense(), "%5g", false)
la.PrintVec("b", b, "%v ", false)
la.PrintVec("x", x, "%v ", false)
}
func main() {
// input matrix in Triplet format
// including repeated positions. e.g. (0,0)
var A la.Triplet
A.Init(5, 5, 13)
A.Put(0, 0, 1.0) // << repeated
A.Put(0, 0, 1.0) // << repeated
A.Put(1, 0, 3.0)
A.Put(0, 1, 3.0)
A.Put(2, 1, -1.0)
A.Put(4, 1, 4.0)
A.Put(1, 2, 4.0)
A.Put(2, 2, -3.0)
A.Put(3, 2, 1.0)
A.Put(4, 2, 2.0)
A.Put(2, 3, 2.0)
A.Put(1, 4, 6.0)
A.Put(4, 4, 1.0)
// right-hand-side
b := []float64{8.0, 45.0, -3.0, 3.0, 19.0}
// allocate solver
lis := la.GetSolver("umfpack")
defer lis.Clean()
// info
symmetric := false
verbose := false
timing := false
// initialise solver (R)eal
err := lis.InitR(&A, symmetric, verbose, timing)
if err != nil {
io.Pfred("solver failed:\n%v", err)
return
}
// factorise
err = lis.Fact()
if err != nil {
io.Pfred("solver failed:\n%v", err)
return
}
// solve (R)eal
var dummy bool
x := make([]float64, len(b))
err = lis.SolveR(x, b, dummy) // x := inv(a) * b
if err != nil {
io.Pfred("solver failed:\n%v", err)
return
}
// output
la.PrintMat("a", A.ToMatrix(nil).ToDense(), "%5g", false)
la.PrintVec("b", b, "%v ", false)
la.PrintVec("x", x, "%v ", false)
}
func (o *Rjoint) debug_update(idx int, Δwb0, Δwb1, Δwb2, σc float64) {
τ := o.States[idx].Sig
qn1 := o.States[idx].Phi[0]
qn2 := o.States[idx].Phi[1]
la.PrintVec("Δw", o.Δw, "%13.10f", false)
io.Pf("Δwb0=%13.10f Δwb1=%13.10f Δwb2=%13.10f\n", Δwb0, Δwb1, Δwb2)
la.PrintVec("σIp", o.σIp, "%13.10f", false)
io.Pf("σc=%13.10f t1=%13.10f t2=%13.10f\n", σc, o.t1, o.t2)
io.Pf("τ=%13.10f qn1=%13.10f qn2=%13.10f\n", τ, qn1, qn2)
}
func Test_linipm02(tst *testing.T) {
//verbose()
chk.PrintTitle("linipm02")
// linear program
// min 2*x0 + x1
// s.t. -x0 + x1 ≤ 1
// x0 + x1 ≥ 2 → -x0 - x1 ≤ -2
// x0 - 2*x1 ≤ 4
// x1 ≥ 0
// standard (step 1) add slack
// s.t. -x0 + x1 + x2 = 1
// -x0 - x1 + x3 = -2
// x0 - 2*x1 + x4 = 4
// standard (step 2)
// replace x0 := x0_ - x5
// because it's unbounded
// min 2*x0_ + x1 - 2*x5
// s.t. -x0_ + x1 + x2 + x5 = 1
// -x0_ - x1 + x3 + x5 = -2
// x0_ - 2*x1 + x4 - x5 = 4
// x0_,x1,x2,x3,x4,x5 ≥ 0
var T la.Triplet
T.Init(3, 6, 12)
T.Put(0, 0, -1)
T.Put(0, 1, 1)
T.Put(0, 2, 1)
T.Put(0, 5, 1)
T.Put(1, 0, -1)
T.Put(1, 1, -1)
T.Put(1, 3, 1)
T.Put(1, 5, 1)
T.Put(2, 0, 1)
T.Put(2, 1, -2)
T.Put(2, 4, 1)
T.Put(2, 5, -1)
Am := T.ToMatrix(nil)
A := Am.ToDense()
c := []float64{2, 1, 0, 0, 0, -2}
b := []float64{1, -2, 4}
// print LP
la.PrintMat("A", A, "%6g", false)
la.PrintVec("b", b, "%6g", false)
la.PrintVec("c", c, "%6g", false)
io.Pf("\n")
// solve LP
var ipm LinIpm
defer ipm.Clean()
ipm.Init(Am, b, c, nil)
err := ipm.Solve(chk.Verbose)
if err != nil {
tst.Errorf("ipm failed:\n%v", err)
return
}
// check
io.Pf("\n")
bres := make([]float64, len(b))
la.MatVecMul(bres, 1, A, ipm.X)
io.Pforan("bres = %v\n", bres)
chk.Vector(tst, "A*x=b", 1e-8, bres, b)
// fix and check x
x := ipm.X[:2]
x[0] -= ipm.X[5]
io.Pforan("x = %v\n", x)
chk.Vector(tst, "x", 1e-8, x, []float64{0.5, 1.5})
// plot
if true && chk.Verbose {
f := func(x []float64) float64 {
return c[0]*x[0] + c[1]*x[1]
}
g := func(x []float64, i int) float64 {
return A[i][0]*x[0] + A[i][1]*x[1] - b[i]
}
np := 41
vmin, vmax := []float64{-2.0, -2.0}, []float64{2.0, 2.0}
PlotTwoVarsContour("/tmp/gosl", "test_linipm02", x, np, nil, true, vmin, vmax, f,
func(x []float64) float64 { return g(x, 0) },
func(x []float64) float64 { return g(x, 1) },
)
}
}
func Test_linipm01(tst *testing.T) {
//verbose()
chk.PrintTitle("linipm01")
// linear programming problem
// min -4*x0 - 5*x1
// s.t. 2*x0 + x1 ≤ 3
// x0 + 2*x1 ≤ 3
// x0,x1 ≥ 0
// standard:
// 2*x0 + x1 + x2 = 3
// x0 + 2*x1 + x3 = 3
// x0,x1,x2,x3 ≥ 0
var T la.Triplet
T.Init(2, 4, 6)
T.Put(0, 0, 2.0)
T.Put(0, 1, 1.0)
T.Put(0, 2, 1.0)
T.Put(1, 0, 1.0)
T.Put(1, 1, 2.0)
T.Put(1, 3, 1.0)
Am := T.ToMatrix(nil)
A := Am.ToDense()
c := []float64{-4, -5, 0, 0}
b := []float64{3, 3}
// print LP
la.PrintMat("A", A, "%6g", false)
la.PrintVec("b", b, "%6g", false)
la.PrintVec("c", c, "%6g", false)
io.Pf("\n")
// solve LP
var ipm LinIpm
defer ipm.Clean()
ipm.Init(Am, b, c, nil)
err := ipm.Solve(chk.Verbose)
if err != nil {
tst.Errorf("ipm failed:\n%v", err)
return
}
// check
io.Pf("\n")
io.Pforan("x = %v\n", ipm.X)
io.Pfcyan("λ = %v\n", ipm.L)
io.Pforan("s = %v\n", ipm.S)
x := ipm.X[:2]
bres := make([]float64, 2)
la.MatVecMul(bres, 1, A, x)
io.Pforan("bres = %v\n", bres)
chk.Vector(tst, "x", 1e-9, x, []float64{1, 1})
chk.Vector(tst, "A*x=b", 1e-8, bres, b)
// plot
if true && chk.Verbose {
f := func(x []float64) float64 {
return c[0]*x[0] + c[1]*x[1]
}
g := func(x []float64, i int) float64 {
return A[i][0]*x[0] + A[i][1]*x[1] - b[i]
}
np := 41
vmin, vmax := []float64{-2.0, -2.0}, []float64{2.0, 2.0}
PlotTwoVarsContour("/tmp/gosl", "test_linipm01", x, np, nil, true, vmin, vmax, f,
func(x []float64) float64 { return g(x, 0) },
func(x []float64) float64 { return g(x, 1) },
)
}
}
// CheckEigenprojs checks eigen projectors
func CheckEigenprojs(a []float64, tolP, tolS float64, ver bool) (λsorted []float64) {
// compute eigenvalues and eigenprojectors
ncp := len(a)
λ := make([]float64, 3)
P := la.MatAlloc(3, ncp)
err := M_EigenValsProjsNum(P, λ, a)
if err != nil {
chk.Panic("eigenprojs.go: CheckEigenprojs failed:\n %v", err.Error())
}
// print projectors
if ver {
la.PrintVec("P0", P[0], "%14.6e", false)
la.PrintVec("P1", P[1], "%14.6e", false)
la.PrintVec("P2", P[2], "%14.6e", false)
}
// check P dot P
PdotP := make([]float64, ncp)
Z := make([]float64, ncp)
for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
err := M_Dot(PdotP, P[i], P[j], 1e-14)
if err != nil {
chk.Panic("%v", err)
}
if i == j {
diff := la.VecMaxDiff(PdotP, P[i])
if diff > tolP {
chk.Panic("eigenprojs.go: CheckEigenprojs failed: P%d dot P%d != P%d (diff=%g)", i, j, i, diff)
} else if ver {
io.Pf("P%d dot P%d == P%d [1;32mOK[0m (diff=%g)\n", i, j, i, diff)
}
} else {
diff := la.VecMaxDiff(PdotP, Z)
if diff > tolP {
chk.Panic("eigenprojs.go: CheckEigenprojs failed: P%d dot P%d != 0 (diff=%g)", i, j, diff)
} else if ver {
io.Pf("P%d dot P%d == 0 [1;32mOK[0m (diff=%g)\n", i, j, diff)
}
}
}
}
// check sum of eigenprojectors
sumP := make([]float64, ncp)
for k := 0; k < 3; k++ {
for i := 0; i < ncp; i++ {
sumP[i] += P[k][i]
}
}
diff := la.VecMaxDiff(sumP, Im[:ncp])
if diff > tolP {
chk.Panic("eigenprojs.go: CheckEigenprojs failed: sumP != I (diff=%g)", diff)
} else if ver {
io.Pf("sum(P) [1;32mOK[0m (diff=%g)\n", diff)
}
// check spectral decomposition
as := make([]float64, len(a))
for k := 0; k < 3; k++ {
for i := 0; i < len(a); i++ {
as[i] += λ[k] * P[k][i]
}
}
diff = la.VecMaxDiff(as, a)
if diff > tolS {
chk.Panic("eigenprojs.go: CheckEigenprojs failed: a(spectral) != a (diff=%g)", diff)
} else if ver {
io.Pf("a(spectral) == a [1;32mOK[0m (diff=%g)\n", diff)
}
// sort eigenvalues
λsorted = make([]float64, 3)
I := []int{0, 1, 2}
I, λsorted, _, _, err = utl.SortQuadruples(I, λ, nil, nil, "x")
if err != nil {
chk.Panic("%v", err)
}
return
}