func solveMVTest(t *testing.T, A, X0 *matrix.FloatMatrix, flags Flags, bN, bNB int) { X1 := X0.Copy() uplo := linalg.OptUpper diag := linalg.OptNonUnit if flags&LOWER != 0 { uplo = linalg.OptLower } if flags&UNIT != 0 { diag = linalg.OptUnit } blas.TrsvFloat(A, X0, uplo, diag) Ar := A.FloatArray() Xr := X1.FloatArray() if bN == bNB { DSolveUnblkMV(Xr, Ar, flags, 1, A.LeadingIndex(), bN) } else { DSolveBlkMV(Xr, Ar, flags, 1, A.LeadingIndex(), bN, bNB) } ok := X1.AllClose(X0) t.Logf("X1 == X0: %v\n", ok) if !ok && bN < 8 { t.Logf("A=\n%v\n", A) t.Logf("X0=\n%v\n", X0) t.Logf("blas: X0\n%v\n", X0) t.Logf("X1:\n%v\n", X1) } }
func kktChol2(G *matrix.FloatMatrix, dims *sets.DimensionSet, A *matrix.FloatMatrix, mnl int) (kktFactor, error) { if len(dims.At("q")) > 0 || len(dims.At("s")) > 0 { return nil, errors.New("'chol2' solver only for problems with no second-order or " + "semidefinite cone constraints") } p, n := A.Size() ml := dims.At("l")[0] F := &chol2Data{firstcall: true, singular: false, A: A, G: G, dims: dims} factor := func(W *sets.FloatMatrixSet, H, Df *matrix.FloatMatrix) (KKTFunc, error) { var err error = nil minor := 0 if !checkpnt.MinorEmpty() { minor = checkpnt.MinorTop() } if F.firstcall { F.Gs = matrix.FloatZeros(F.G.Size()) if mnl > 0 { F.Dfs = matrix.FloatZeros(Df.Size()) } F.S = matrix.FloatZeros(n, n) F.K = matrix.FloatZeros(p, p) checkpnt.AddMatrixVar("Gs", F.Gs) checkpnt.AddMatrixVar("Dfs", F.Dfs) checkpnt.AddMatrixVar("S", F.S) checkpnt.AddMatrixVar("K", F.K) } if mnl > 0 { dnli := matrix.FloatZeros(mnl, mnl) dnli.SetIndexesFromArray(W.At("dnli")[0].FloatArray(), matrix.DiagonalIndexes(dnli)...) blas.GemmFloat(dnli, Df, F.Dfs, 1.0, 0.0) } checkpnt.Check("02factor_chol2", minor) di := matrix.FloatZeros(ml, ml) di.SetIndexesFromArray(W.At("di")[0].FloatArray(), matrix.DiagonalIndexes(di)...) err = blas.GemmFloat(di, G, F.Gs, 1.0, 0.0) checkpnt.Check("06factor_chol2", minor) if F.firstcall { blas.SyrkFloat(F.Gs, F.S, 1.0, 0.0, la.OptTrans) if mnl > 0 { blas.SyrkFloat(F.Dfs, F.S, 1.0, 1.0, la.OptTrans) } if H != nil { F.S.Plus(H) } checkpnt.Check("10factor_chol2", minor) err = lapack.Potrf(F.S) if err != nil { err = nil // reset error F.singular = true // original code recreates F.S as dense if it is sparse and // A is dense, we don't do it as currently no sparse matrices //F.S = matrix.FloatZeros(n, n) //checkpnt.AddMatrixVar("S", F.S) blas.SyrkFloat(F.Gs, F.S, 1.0, 0.0, la.OptTrans) if mnl > 0 { blas.SyrkFloat(F.Dfs, F.S, 1.0, 1.0, la.OptTrans) } checkpnt.Check("14factor_chol2", minor) blas.SyrkFloat(F.A, F.S, 1.0, 1.0, la.OptTrans) if H != nil { F.S.Plus(H) } lapack.Potrf(F.S) } F.firstcall = false checkpnt.Check("20factor_chol2", minor) } else { blas.SyrkFloat(F.Gs, F.S, 1.0, 0.0, la.OptTrans) if mnl > 0 { blas.SyrkFloat(F.Dfs, F.S, 1.0, 1.0, la.OptTrans) } if H != nil { F.S.Plus(H) } checkpnt.Check("40factor_chol2", minor) if F.singular { blas.SyrkFloat(F.A, F.S, 1.0, 1.0, la.OptTrans) } lapack.Potrf(F.S) checkpnt.Check("50factor_chol2", minor) } // Asct := L^{-1}*A'. Factor K = Asct'*Asct. Asct := F.A.Transpose() blas.TrsmFloat(F.S, Asct, 1.0) blas.SyrkFloat(Asct, F.K, 1.0, 0.0, la.OptTrans) lapack.Potrf(F.K) checkpnt.Check("90factor_chol2", minor) solve := func(x, y, z *matrix.FloatMatrix) (err error) { // Solve // // [ H A' GG'*W^{-1} ] [ ux ] [ bx ] // [ A 0 0 ] * [ uy ] = [ by ] // [ W^{-T}*GG 0 -I ] [ W*uz ] [ W^{-T}*bz ] // // and return ux, uy, W*uz. // // If not F['singular']: // // K*uy = A * S^{-1} * ( bx + GG'*W^{-1}*W^{-T}*bz ) - by // S*ux = bx + GG'*W^{-1}*W^{-T}*bz - A'*uy // W*uz = W^{-T} * ( GG*ux - bz ). // // If F['singular']: // // K*uy = A * S^{-1} * ( bx + GG'*W^{-1}*W^{-T}*bz + A'*by ) // - by // S*ux = bx + GG'*W^{-1}*W^{-T}*bz + A'*by - A'*y. // W*uz = W^{-T} * ( GG*ux - bz ). minor := 0 if !checkpnt.MinorEmpty() { minor = checkpnt.MinorTop() } // z := W^{-1} * z = W^{-1} * bz scale(z, W, true, true) checkpnt.Check("10solve_chol2", minor) // If not F['singular']: // x := L^{-1} * P * (x + GGs'*z) // = L^{-1} * P * (x + GG'*W^{-1}*W^{-T}*bz) // // If F['singular']: // x := L^{-1} * P * (x + GGs'*z + A'*y)) // = L^{-1} * P * (x + GG'*W^{-1}*W^{-T}*bz + A'*y) if mnl > 0 { blas.GemvFloat(F.Dfs, z, x, 1.0, 1.0, la.OptTrans) } blas.GemvFloat(F.Gs, z, x, 1.0, 1.0, la.OptTrans, &la.IOpt{"offsetx", mnl}) //checkpnt.Check("20solve_chol2", minor) if F.singular { blas.GemvFloat(F.A, y, x, 1.0, 1.0, la.OptTrans) } checkpnt.Check("30solve_chol2", minor) blas.TrsvFloat(F.S, x) //checkpnt.Check("50solve_chol2", minor) // y := K^{-1} * (Asc*x - y) // = K^{-1} * (A * S^{-1} * (bx + GG'*W^{-1}*W^{-T}*bz) - by) // (if not F['singular']) // = K^{-1} * (A * S^{-1} * (bx + GG'*W^{-1}*W^{-T}*bz + // A'*by) - by) // (if F['singular']). blas.GemvFloat(Asct, x, y, 1.0, -1.0, la.OptTrans) //checkpnt.Check("55solve_chol2", minor) lapack.Potrs(F.K, y) //checkpnt.Check("60solve_chol2", minor) // x := P' * L^{-T} * (x - Asc'*y) // = S^{-1} * (bx + GG'*W^{-1}*W^{-T}*bz - A'*y) // (if not F['singular']) // = S^{-1} * (bx + GG'*W^{-1}*W^{-T}*bz + A'*by - A'*y) // (if F['singular']) blas.GemvFloat(Asct, y, x, -1.0, 1.0) blas.TrsvFloat(F.S, x, la.OptTrans) checkpnt.Check("70solve_chol2", minor) // W*z := GGs*x - z = W^{-T} * (GG*x - bz) if mnl > 0 { blas.GemvFloat(F.Dfs, x, z, 1.0, -1.0) } blas.GemvFloat(F.Gs, x, z, 1.0, -1.0, &la.IOpt{"offsety", mnl}) checkpnt.Check("90solve_chol2", minor) return nil } return solve, err } return factor, nil }