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 CompareJac(tst *testing.T, ffcn Cb_f, Jfcn Cb_J, x []float64, tol float64, distr bool) { n := len(x) // numerical fx := make([]float64, n) w := make([]float64, n) // workspace ffcn(fx, x) var Jnum la.Triplet Jnum.Init(n, n, n*n) Jacobian(&Jnum, ffcn, x, fx, w, distr) jn := Jnum.ToMatrix(nil) // analytical var Jana la.Triplet Jana.Init(n, n, n*n) Jfcn(&Jana, x) ja := Jana.ToMatrix(nil) // compare //la.PrintMat(fmt.Sprintf("Jana(%d)",mpi.Rank()), ja.ToDense(), "%13.6f", false) //la.PrintMat(fmt.Sprintf("Jnum(%d)",mpi.Rank()), jn.ToDense(), "%13.6f", false) max_diff := la.MatMaxDiff(jn.ToDense(), ja.ToDense()) if max_diff > tol { tst.Errorf("[1;31mmax_diff = %g[0m\n", max_diff) } else { io.Pf("[1;32mmax_diff = %g[0m\n", max_diff) } }
// CompareJacMpi compares Jacobian matrix (e.g. for testing) func CompareJacMpi(tst *testing.T, ffcn Cb_f, Jfcn Cb_J, x []float64, tol float64, distr bool) { // numerical n := len(x) fx := make([]float64, n) w := make([]float64, n) // workspace ffcn(fx, x) var Jnum la.Triplet Jnum.Init(n, n, n*n) JacobianMpi(&Jnum, ffcn, x, fx, w, distr) jn := Jnum.ToMatrix(nil) // analytical var Jana la.Triplet Jana.Init(n, n, n*n) Jfcn(&Jana, x) ja := Jana.ToMatrix(nil) // compare max_diff := la.MatMaxDiff(jn.ToDense(), ja.ToDense()) if max_diff > tol { tst.Errorf("[1;31mmax_diff = %g[0m\n", max_diff) } else { io.Pf("[1;32mmax_diff = %g[0m\n", max_diff) } }
// CheckJ check Jacobian matrix // Ouptut: cnd -- condition number (with Frobenius norm) func (o *NlSolver) CheckJ(x []float64, tol float64, chkJnum, silent bool) (cnd float64, err error) { // Jacobian matrix var Jmat [][]float64 if o.useDn { Jmat = la.MatAlloc(o.neq, o.neq) err = o.JfcnDn(Jmat, x) if err != nil { return 0, chk.Err(_nls_err5, "dense", err.Error()) } } else { if o.numJ { err = Jacobian(&o.Jtri, o.Ffcn, x, o.fx, o.w, false) if err != nil { return 0, chk.Err(_nls_err5, "sparse", err.Error()) } } else { err = o.JfcnSp(&o.Jtri, x) if err != nil { return 0, chk.Err(_nls_err5, "sparse(num)", err.Error()) } } Jmat = o.Jtri.ToMatrix(nil).ToDense() } //la.PrintMat("J", Jmat, "%23g", false) // condition number cnd, err = la.MatCondG(Jmat, "F", 1e-10) if err != nil { return cnd, chk.Err(_nls_err6, err.Error()) } if math.IsInf(cnd, 0) || math.IsNaN(cnd) { return cnd, chk.Err(_nls_err7, cnd) } // numerical Jacobian if !chkJnum { return } var Jtmp la.Triplet ws := make([]float64, o.neq) err = o.Ffcn(o.fx, x) if err != nil { return } Jtmp.Init(o.neq, o.neq, o.neq*o.neq) Jacobian(&Jtmp, o.Ffcn, x, o.fx, ws, false) Jnum := Jtmp.ToMatrix(nil).ToDense() for i := 0; i < o.neq; i++ { for j := 0; j < o.neq; j++ { chk.PrintAnaNum(io.Sf("J[%d][%d]", i, j), tol, Jmat[i][j], Jnum[i][j], !silent) } } maxdiff := la.MatMaxDiff(Jmat, Jnum) if maxdiff > tol { err = chk.Err(_nls_err8, maxdiff) } return }
func main() { mpi.Start(false) defer func() { mpi.Stop(false) }() if mpi.Rank() == 0 { chk.PrintTitle("Test SumToRoot 01") } M := [][]float64{ {1000, 1000, 1000, 1011, 1021, 1000}, {1000, 1000, 1000, 1012, 1022, 1000}, {1000, 1000, 1000, 1013, 1023, 1000}, {1011, 1012, 1013, 1000, 1000, 1000}, {1021, 1022, 1023, 1000, 1000, 1000}, {1000, 1000, 1000, 1000, 1000, 1000}, } id, sz, m := mpi.Rank(), mpi.Size(), len(M) start, endp1 := (id*m)/sz, ((id+1)*m)/sz if sz > 6 { chk.Panic("this test works with at most 6 processors") } var J la.Triplet J.Init(m, m, m*m) for i := start; i < endp1; i++ { for j := 0; j < m; j++ { J.Put(i, j, M[i][j]) } } la.PrintMat(fmt.Sprintf("J @ proc # %d", id), J.ToMatrix(nil).ToDense(), "%10.1f", false) la.SpTriSumToRoot(&J) var tst testing.T if mpi.Rank() == 0 { chk.Matrix(&tst, "J @ proc 0", 1.0e-17, J.ToMatrix(nil).ToDense(), [][]float64{ {1000, 1000, 1000, 1011, 1021, 1000}, {1000, 1000, 1000, 1012, 1022, 1000}, {1000, 1000, 1000, 1013, 1023, 1000}, {1011, 1012, 1013, 1000, 1000, 1000}, {1021, 1022, 1023, 1000, 1000, 1000}, {1000, 1000, 1000, 1000, 1000, 1000}, }) } }
func Test_assemb01(tst *testing.T) { chk.PrintTitle("assemb01") // grid var g Grid2D g.Init(1.0, 1.0, 3, 3) // equations numbering var e Equations e.Init(g.N, []int{0, 3, 6}) // K11 and K12 var K11, K12 la.Triplet InitK11andK12(&K11, &K12, &e) // assembly F1 := make([]float64, e.N1) Assemble(&K11, &K12, F1, nil, &g, &e) // check K11d := K11.ToMatrix(nil).ToDense() K12d := K12.ToMatrix(nil).ToDense() K11c := [][]float64{ {16.0, -4.0, -8.0, 0.0, 0.0, 0.0}, {-8.0, 16.0, 0.0, -8.0, 0.0, 0.0}, {-4.0, 0.0, 16.0, -4.0, -4.0, 0.0}, {0.0, -4.0, -8.0, 16.0, 0.0, -4.0}, {0.0, 0.0, -8.0, 0.0, 16.0, -4.0}, {0.0, 0.0, 0.0, -8.0, -8.0, 16.0}, } K12c := [][]float64{ {-4.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, -4.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, -4.0}, {0.0, 0.0, 0.0}, } chk.Matrix(tst, "K11: ", 1e-16, K11d, K11c) chk.Matrix(tst, "K12: ", 1e-16, K12d, K12c) }
func TestJacobian03(tst *testing.T) { //verbose() chk.PrintTitle("TestJacobian 03") // grid var g fdm.Grid2D //g.Init(1.0, 1.0, 4, 4) g.Init(1.0, 1.0, 6, 6) //g.Init(1.0, 1.0, 11, 11) // equations numbering var e fdm.Equations peq := utl.IntUnique(g.L, g.R, g.B, g.T) e.Init(g.N, peq) // K11 and K12 var K11, K12 la.Triplet fdm.InitK11andK12(&K11, &K12, &e) // assembly F1 := make([]float64, e.N1) fdm.Assemble(&K11, &K12, F1, nil, &g, &e) // prescribed values U2 := make([]float64, e.N2) for _, eq := range g.L { U2[e.FR2[eq]] = 50.0 } for _, eq := range g.R { U2[e.FR2[eq]] = 0.0 } for _, eq := range g.B { U2[e.FR2[eq]] = 0.0 } for _, eq := range g.T { U2[e.FR2[eq]] = 50.0 } // functions k11 := K11.ToMatrix(nil) k12 := K12.ToMatrix(nil) ffcn := func(fU1, U1 []float64) error { // K11*U1 + K12*U2 - F1 la.VecCopy(fU1, -1, F1) // fU1 := (-F1) la.SpMatVecMulAdd(fU1, 1, k11, U1) // fU1 += K11*U1 la.SpMatVecMulAdd(fU1, 1, k12, U2) // fU1 += K12*U2 return nil } Jfcn := func(dfU1dU1 *la.Triplet, U1 []float64) error { fdm.Assemble(dfU1dU1, &K12, F1, nil, &g, &e) return nil } U1 := make([]float64, e.N1) CompareJac(tst, ffcn, Jfcn, U1, 0.0075) print_jac := false if print_jac { W1 := make([]float64, e.N1) fU1 := make([]float64, e.N1) ffcn(fU1, U1) var Jnum la.Triplet Jnum.Init(e.N1, e.N1, e.N1*e.N1) Jacobian(&Jnum, ffcn, U1, fU1, W1) la.PrintMat("K11 ", K11.ToMatrix(nil).ToDense(), "%g ", false) la.PrintMat("Jnum", Jnum.ToMatrix(nil).ToDense(), "%g ", false) } test_ffcn := false if test_ffcn { Uc := []float64{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0, 25.0, 325.0 / 22.0, 100.0 / 11.0, 50.0 / 11.0, 0.0, 50.0, 775.0 / 22.0, 25.0, 375.0 / 22.0, 100.0 / 11.0, 0.0, 50.0, 450.0 / 11.0, 725.0 / 22.0, 25.0, 325.0 / 22.0, 0.0, 50.0, 500.0 / 11.0, 450.0 / 11.0, 775.0 / 22.0, 25.0, 0.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, } for i := 0; i < e.N1; i++ { U1[i] = Uc[e.RF1[i]] } fU1 := make([]float64, e.N1) min, max := la.VecMinMax(fU1) io.Pf("min/max fU1 = %v\n", min, max) } }
func TestDiffusion1D(tst *testing.T) { //verbose() chk.PrintTitle("Test Diffusion 1D (cooling)") // solution parameters silent := false fixstp := true //fixstp := false //method := "FwEuler" method := "BwEuler" //method := "Dopri5" //method := "Radau5" //numjac := true numjac := false rtol := 1e-4 atol := rtol // timestep t0, tf, dt := 0.0, 0.2, 0.03 // problem data kx := 1.0 // conductivity N := 6 // number of nodes //Nb := N + 2 // augmented system dimension xmax := 1.0 // length dx := xmax / float64(N-1) // spatial step size dxx := dx * dx mol := []float64{kx / dxx, -2.0 * kx / dxx, kx / dxx} // function fcn := func(f []float64, t float64, y []float64, args ...interface{}) error { for i := 0; i < N; i++ { f[i] = 0 if i == 0 || i == N-1 { continue // skip presc node } for p, j := range []int{i - 1, i, i + 1} { if j < 0 { j = i + 1 } // left boundary if j == N { j = i - 1 } // right boundary f[i] += mol[p] * y[j] } } //io.Pfgrey("y = %v\n", y) //io.Pfcyan("f = %v\n", f) return nil } // Jacobian jac := func(dfdy *la.Triplet, t float64, y []float64, args ...interface{}) error { //chk.Panic("jac is not available") if dfdy.Max() == 0 { //dfdy.Init(Nb, Nb, 3*N) dfdy.Init(N, N, 3*N) } dfdy.Start() for i := 0; i < N; i++ { if i == 0 || i == N-1 { dfdy.Put(i, i, 0.0) continue } for p, j := range []int{i - 1, i, i + 1} { if j < 0 { j = i + 1 } // left boundary if j == N { j = i - 1 } // right boundary dfdy.Put(i, j, mol[p]) } } return nil } // initial values x := utl.LinSpace(0.0, xmax, N) y := make([]float64, N) //y := make([]float64, Nb) for i := 0; i < N; i++ { y[i] = 4.0*x[i] - 4.0*x[i]*x[i] } // debug f0 := make([]float64, N) //f0 := make([]float64, Nb) fcn(f0, 0, y) if false { io.Pforan("y0 = %v\n", y) io.Pforan("f0 = %v\n", f0) var J la.Triplet jac(&J, 0, y) la.PrintMat("J", J.ToMatrix(nil).ToDense(), "%8.3f", false) } //chk.Panic("stop") /* // constraints var A la.Triplet A.Init(2, N, 2) A.Put(0, 0, 1.0) A.Put(1, N-1, 1.0) io.Pfcyan("A = %+v\n", A) Am := A.ToMatrix(nil) c := make([]float64, 2) la.SpMatVecMul(c, 1, Am, y) // c := Am*y la.PrintMat("A", Am.ToDense(), "%3g", false) io.Pfcyan("c = %v ([0, 0] => consistent)\n", c) */ /* // mass matrix var M la.Triplet M.Init(Nb, Nb, N + 4) for i := 0; i < N; i++ { M.Put(i, i, 1.0) } M.PutMatAndMatT(&A) Mm := M.ToMatrix(nil) la.PrintMat("M", Mm.ToDense(), "%3g", false) */ // output var b0, b1, b2 bytes.Buffer fmt.Fprintf(&b0, "from gosl import *\n") fmt.Fprintf(&b1, "T = array([") fmt.Fprintf(&b2, "U = array([") out := func(first bool, dt, t float64, y []float64, args ...interface{}) error { fmt.Fprintf(&b1, "%23.15E,", t) fmt.Fprintf(&b2, "[") for i := 0; i < N; i++ { fmt.Fprintf(&b2, "%23.15E,", y[i]) } fmt.Fprintf(&b2, "],") return nil } defer func() { fmt.Fprintf(&b1, "])\n") fmt.Fprintf(&b2, "])\n") fmt.Fprintf(&b2, "X = linspace(0.0, %g, %d)\n", xmax, N) fmt.Fprintf(&b2, "tt, xx = meshgrid(T, X)\n") fmt.Fprintf(&b2, "ax = PlotSurf(tt, xx, vstack(transpose(U)), 't', 'x', 'u', 0.0, 1.0)\n") fmt.Fprintf(&b2, "ax.view_init(20.0, 30.0)\n") fmt.Fprintf(&b2, "show()\n") io.WriteFileD("/tmp/gosl", "plot_diffusion_1d.py", &b0, &b1, &b2) }() // ode solver var Jfcn Cb_jac var osol ODE if !numjac { Jfcn = jac } osol.Init(method, N, fcn, Jfcn, nil, out, silent) //osol.Init(method, Nb, fcn, Jfcn, &M, out, silent) osol.SetTol(atol, rtol) // constant Jacobian if method == "BwEuler" { osol.CteTg = true osol.Verbose = true } // run wallt0 := time.Now() if !fixstp { dt = tf - t0 } osol.Solve(y, t0, tf, dt, fixstp) io.Pfmag("elapsed time = %v\n", time.Now().Sub(wallt0)) }
func Test_nls04(tst *testing.T) { //verbose() chk.PrintTitle("nls04. finite differences problem") // grid var g fdm.Grid2D g.Init(1.0, 1.0, 6, 6) // equations numbering var e fdm.Equations peq := utl.IntUnique(g.L, g.R, g.B, g.T) e.Init(g.N, peq) // K11 and K12 var K11, K12 la.Triplet fdm.InitK11andK12(&K11, &K12, &e) // assembly F1 := make([]float64, e.N1) fdm.Assemble(&K11, &K12, F1, nil, &g, &e) // prescribed values U2 := make([]float64, e.N2) for _, eq := range g.L { U2[e.FR2[eq]] = 50.0 } for _, eq := range g.R { U2[e.FR2[eq]] = 0.0 } for _, eq := range g.B { U2[e.FR2[eq]] = 0.0 } for _, eq := range g.T { U2[e.FR2[eq]] = 50.0 } // functions k11 := K11.ToMatrix(nil) k12 := K12.ToMatrix(nil) ffcn := func(fU1, U1 []float64) error { // K11*U1 + K12*U2 - F1 la.VecCopy(fU1, -1, F1) // fU1 := (-F1) la.SpMatVecMulAdd(fU1, 1, k11, U1) // fU1 += K11*U1 la.SpMatVecMulAdd(fU1, 1, k12, U2) // fU1 += K12*U2 return nil } Jfcn := func(dfU1dU1 *la.Triplet, U1 []float64) error { fdm.Assemble(dfU1dU1, &K12, F1, nil, &g, &e) return nil } JfcnD := func(dfU1dU1 [][]float64, U1 []float64) error { la.MatCopy(dfU1dU1, 1, K11.ToMatrix(nil).ToDense()) return nil } prms := map[string]float64{ "atol": 1e-8, "rtol": 1e-8, "ftol": 1e-12, "lSearch": 0.0, } // init var nls_sps NlSolver // sparse analytical var nls_num NlSolver // sparse numerical var nls_den NlSolver // dense analytical nls_sps.Init(e.N1, ffcn, Jfcn, nil, false, false, prms) nls_num.Init(e.N1, ffcn, nil, nil, false, true, prms) nls_den.Init(e.N1, ffcn, nil, JfcnD, true, false, prms) defer nls_sps.Clean() defer nls_num.Clean() defer nls_den.Clean() // results U1sps := make([]float64, e.N1) U1num := make([]float64, e.N1) U1den := make([]float64, e.N1) Usps := make([]float64, e.N) Unum := make([]float64, e.N) Uden := make([]float64, e.N) // solution Uc := []float64{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 50.0, 25.0, 325.0 / 22.0, 100.0 / 11.0, 50.0 / 11.0, 0.0, 50.0, 775.0 / 22.0, 25.0, 375.0 / 22.0, 100.0 / 11.0, 0.0, 50.0, 450.0 / 11.0, 725.0 / 22.0, 25.0, 325.0 / 22.0, 0.0, 50.0, 500.0 / 11.0, 450.0 / 11.0, 775.0 / 22.0, 25.0, 0.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, } io.PfYel("\n---- sparse -------- Analytical Jacobian -------------------\n") // solve err := nls_sps.Solve(U1sps, false) if err != nil { chk.Panic(err.Error()) } // check fdm.JoinVecs(Usps, U1sps, U2, &e) chk.Vector(tst, "Usps", 1e-14, Usps, Uc) // plot if false { g.Contour("results", "fig_t_heat_square", nil, Usps, 11, false) } io.PfYel("\n---- dense -------- Analytical Jacobian -------------------\n") // solve err = nls_den.Solve(U1den, false) if err != nil { chk.Panic(err.Error()) } // check fdm.JoinVecs(Uden, U1den, U2, &e) chk.Vector(tst, "Uden", 1e-14, Uden, Uc) io.PfYel("\n---- sparse -------- Numerical Jacobian -------------------\n") // solve err = nls_num.Solve(U1num, false) if err != nil { chk.Panic(err.Error()) } // check fdm.JoinVecs(Unum, U1num, U2, &e) chk.Vector(tst, "Unum", 1e-14, Unum, Uc) }
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) }, ) } }