func MakeData(M, N, P int, randomData, diagonal bool) (A, B, C *matrix.FloatMatrix) {
if diagonal && M != N {
diagonal = false
fmt.Printf("cannot make diagonal if B.rows != B.cols\n")
}
if randomData {
A = matrix.FloatNormal(M, P)
if diagonal {
d := matrix.FloatNormal(P, 1)
B := matrix.FloatDiagonal(P, 0.0)
B.SetIndexesFromArray(d.FloatArray(), matrix.DiagonalIndexes(B)...)
} else {
B = matrix.FloatNormal(P, N)
}
} else {
A = matrix.FloatWithValue(M, P, 1.0)
if diagonal {
B = matrix.FloatDiagonal(P, 1.0)
} else {
B = matrix.FloatWithValue(P, N, 1.0)
}
}
C = matrix.FloatZeros(M, N)
return
}
func _TestMultMV(t *testing.T) {
bM := 100 * M
bN := 100 * N
A := matrix.FloatNormal(bM, bN)
X := matrix.FloatNormal(bN, 1)
Y1 := matrix.FloatZeros(bM, 1)
Y0 := matrix.FloatZeros(bM, 1)
Ar := A.FloatArray()
Xr := X.FloatArray()
Y1r := Y1.FloatArray()
blas.GemvFloat(A, X, Y0, 1.0, 1.0)
DMultMV(Y1r, Ar, Xr, 1.0, 1.0, NOTRANS, 1, A.LeadingIndex(), 1, 0, bN, 0, bM, 32, 32)
t.Logf("Y0 == Y1: %v\n", Y0.AllClose(Y1))
/*
if ! Y0.AllClose(Y1) {
y0 := Y0.SubMatrix(0, 0, 2, 1)
y1 := Y1.SubMatrix(0, 0, 2, 1)
t.Logf("y0=\n%v\n", y0)
t.Logf("y1=\n%v\n", y1)
}
*/
}
func MMTestMultTransAB(m, n, p int) (fnc func(), A, B, C *matrix.FloatMatrix) {
A = matrix.FloatNormal(p, m)
B = matrix.FloatNormal(n, p)
C = matrix.FloatZeros(m, n)
fnc = func() {
matops.Mult(C, A, B, 1.0, 1.0, matops.TRANSA|matops.TRANSB)
}
return
}
func TestTemplate(m, n, p int) (fnc func(), A, B, C *matrix.FloatMatrix) {
A = matrix.FloatNormal(m, p)
B = matrix.FloatNormal(p, n)
C = matrix.FloatZeros(m, n)
fnc = func() {
// test core here
}
return
}
func CTestGemv(m, n, p int) (fnc func(), A, X, Y *matrix.FloatMatrix) {
A = matrix.FloatNormal(m, n)
X = matrix.FloatNormal(n, 1)
Y = matrix.FloatZeros(m, 1)
fnc = func() {
blas.GemvFloat(A, X, Y, 1.0, 1.0)
}
return
}
func TestTemplate(m, n, p int) (fnc func(), A, X, Y *matrix.FloatMatrix) {
A = matrix.FloatNormal(m, n)
X = matrix.FloatNormal(n, 1)
Y = matrix.FloatZeros(m, 1)
fnc = func() {
// test core here
}
return
}
func CTestMVMultTransA(m, n, p int) (fnc func(), A, X, Y *matrix.FloatMatrix) {
A = matrix.FloatNormal(n, m)
X = matrix.FloatNormal(n, 1)
Y = matrix.FloatZeros(m, 1)
fnc = func() {
matops.MVMultTransA(Y, A, X, 1.0, 1.0)
}
return
}
func MMTestMult(m, n, p int) (fnc func(), A, B, C *matrix.FloatMatrix) {
A = matrix.FloatNormal(m, p)
B = matrix.FloatNormal(p, n)
C = matrix.FloatZeros(m, n)
fnc = func() {
matops.Mult(C, A, B, 1.0, 1.0, matops.NOTRANS)
}
return
}
func CTestGemvTransA(m, n, p int) (fnc func(), A, X, Y *matrix.FloatMatrix) {
A = matrix.FloatNormal(n, m)
X = matrix.FloatNormal(n, 1)
Y = matrix.FloatZeros(m, 1)
A = A.Transpose()
fnc = func() {
blas.GemvFloat(A, X, Y, 1.0, 1.0, linalg.OptTrans)
}
return
}
func _TestLDLnoPiv(t *testing.T) {
N := 42
nb := 8
A0 := matrix.FloatUniform(N, N)
A := matrix.FloatZeros(N, N)
Mult(A, A0, A0, 1.0, 1.0, TRANSB)
B := matrix.FloatNormal(A.Rows(), 2)
w := matrix.FloatWithValue(A.Rows(), 2, 1.0)
// B0 = A*B
B0 := B.Copy()
nb = 2
L, _ := DecomposeLDLnoPiv(A.Copy(), w, LOWER, nb)
Mult(B0, A, B, 1.0, 0.0, NOTRANS)
SolveLDLnoPiv(B0, L, LOWER)
t.Logf("L*D*L.T: ||B - A*X||_1: %e\n", NormP(B0.Minus(B), NORM_ONE))
U, _ := DecomposeLDLnoPiv(A.Copy(), w, UPPER, nb)
Mult(B0, A, B, 1.0, 0.0, NOTRANS)
SolveLDLnoPiv(B0, U, UPPER)
t.Logf("U*D*U.T: ||B - A*X||_1: %e\n", NormP(B0.Minus(B), NORM_ONE))
}
func main() {
blas.PanicOnError(true)
matrix.PanicOnError(true)
var data *matrix.FloatMatrix = nil
flag.Parse()
if len(dataVal) > 0 {
data, _ = matrix.FloatParse(dataVal)
if data == nil {
fmt.Printf("could not parse:\n%s\n", dataVal)
return
}
} else {
data = matrix.FloatNormal(20, 20)
}
if len(spPath) > 0 {
checkpnt.Reset(spPath)
checkpnt.Activate()
checkpnt.Verbose(spVerbose)
checkpnt.Format("%.7f")
}
sol, err := mcsdp(data)
if sol != nil && sol.Status == cvx.Optimal {
x := sol.Result.At("x")[0]
z := sol.Result.At("z")[0]
matrix.Reshape(z, data.Rows(), data.Rows())
fmt.Printf("x=\n%v\n", x.ToString("%.9f"))
//fmt.Printf("z=\n%v\n", z.ToString("%.9f"))
check(x, z)
} else {
fmt.Printf("status: %v\n", err)
}
}
func _TestMultMVTransA(t *testing.T) {
bM := 1000 * M
bN := 1000 * N
A := matrix.FloatNormal(bN, bM)
X := matrix.FloatWithValue(bN, 1, 1.0)
Y1 := matrix.FloatZeros(bM, 1)
Y0 := matrix.FloatZeros(bM, 1)
Ar := A.FloatArray()
Xr := X.FloatArray()
Y1r := Y1.FloatArray()
blas.GemvFloat(A, X, Y0, 1.0, 1.0, linalg.OptTrans)
DMultMV(Y1r, Ar, Xr, 1.0, 1.0, TRANSA, 1, A.LeadingIndex(), 1, 0, bN, 0, bM, 4, 4)
ok := Y0.AllClose(Y1)
t.Logf("Y0 == Y1: %v\n", ok)
if !ok {
var y1, y0 matrix.FloatMatrix
Y1.SubMatrix(&y1, 0, 0, 5, 1)
t.Logf("Y1[0:5]:\n%v\n", y1)
Y0.SubMatrix(&y0, 0, 0, 5, 1)
t.Logf("Y0[0:5]:\n%v\n", y0)
}
}
func _TestMultSymmLowerSmall(t *testing.T) {
//bM := 5
bN := 7
bP := 7
Adata := [][]float64{
[]float64{1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
[]float64{1.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0},
[]float64{1.0, 2.0, 3.0, 0.0, 0.0, 0.0, 0.0},
[]float64{1.0, 2.0, 3.0, 4.0, 0.0, 0.0, 0.0},
[]float64{1.0, 2.0, 3.0, 4.0, 5.0, 0.0, 0.0},
[]float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.0},
[]float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}}
A := matrix.FloatMatrixFromTable(Adata, matrix.RowOrder)
B := matrix.FloatNormal(bN, bP)
C0 := matrix.FloatZeros(bN, bP)
C1 := matrix.FloatZeros(bN, bP)
Ar := A.FloatArray()
Br := B.FloatArray()
C1r := C1.FloatArray()
blas.SymmFloat(A, B, C0, 1.0, 1.0, linalg.OptLower, linalg.OptRight)
DMultSymm(C1r, Ar, Br, 1.0, 1.0, LOWER|RIGHT, bN, A.LeadingIndex(), bN,
bN, 0, bP, 0, bN, 2, 2, 2)
ok := C0.AllClose(C1)
t.Logf("C0 == C1: %v\n", ok)
if !ok {
t.Logf("A=\n%v\n", A)
t.Logf("blas: C=A*B\n%v\n", C0)
t.Logf("C1: C1 = A*X\n%v\n", C1)
}
}
func TestUpdateTrmMV(t *testing.T) {
//bM := 5
bN := 8
//bP := 4
nb := 4
X := matrix.FloatNormal(bN, 1)
//B := matrix.FloatNormal(bP, bN)
Y := X.Copy()
C0 := matrix.FloatZeros(bN, bN)
C2 := matrix.FloatZeros(bN, bN)
C1 := matrix.FloatZeros(bN, bN)
Xr := X.FloatArray()
Yr := Y.FloatArray()
C1r := C1.FloatArray()
C0r := C0.FloatArray()
C2r := C2.FloatArray()
// no transpose
DRankMV(C1r, Xr, Yr, 1.0, C1.LeadingIndex(), 1, 1,
0, bN, 0, bN, nb, nb)
DTrmUpdMV(C0r, Xr, Yr, 1.0, LOWER, C0.LeadingIndex(), 1, 1,
0, bN, nb)
DTrmUpdMV(C2r, Xr, Yr, 1.0, UPPER, C2.LeadingIndex(), 1, 1,
0, bN, nb)
t.Logf("C1:\n%v\nC0:\n%v\nC2:\n%v\n", C1, C0, C2)
// C0 == C2.T
t.Logf("C0 == C2.T: %v\n", C0.AllClose(C2.Transpose()))
// C1 == C1 - C2 + C0.T
Cn := matrix.Minus(C1, C2)
Cn.Plus(C0.Transpose())
t.Logf("C1 == C1 - C2 + C0.T: %v\n", Cn.AllClose(C1))
}
func main() {
var A, b *matrix.FloatMatrix = nil, nil
m, n := 20, 20
blas.PanicOnError(true)
matrix.PanicOnError(true)
flag.Parse()
if len(spPath) > 0 {
checkpnt.Reset(spPath)
checkpnt.Activate()
checkpnt.Verbose(spVerbose)
checkpnt.Format("%.17f")
}
if len(AVal) > 0 {
A, _ = matrix.FloatParse(AVal)
if A == nil {
fmt.Printf("could not parse:\n%s\n", AVal)
return
}
} else {
A = matrix.FloatNormal(m, n)
}
if len(bVal) > 0 {
b, _ = matrix.FloatParse(bVal)
if b == nil {
fmt.Printf("could not parse:\n%s\n", bVal)
return
}
} else {
b = matrix.FloatNormal(m, 1)
}
sol, err := qcl1(A, b)
if sol != nil {
r := sol.Result.At("x")[0]
x := matrix.FloatVector(r.FloatArray()[:A.Cols()])
r = sol.Result.At("z")[0]
z := matrix.FloatVector(r.FloatArray()[r.NumElements()-A.Rows():])
fmt.Printf("x=\n%v\n", x.ToString("%.9f"))
fmt.Printf("z=\n%v\n", z.ToString("%.9f"))
check(x, z)
} else {
fmt.Printf("status: %v\n", err)
}
}
func TestLDLlower(t *testing.T) {
/*
Ldata := [][]float64{
[]float64{7.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
[]float64{7.0, 6.0, 0.0, 0.0, 0.0, 0.0, 0.0},
[]float64{7.0, 6.0, 5.0, 0.0, 0.0, 0.0, 0.0},
[]float64{7.0, 6.0, 5.0, 4.0, 0.0, 0.0, 0.0},
[]float64{7.0, 6.0, 5.0, 4.0, 6.0, 0.0, 0.0},
[]float64{7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 0.0},
[]float64{7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}}
A := matrix.FloatMatrixFromTable(Ldata, matrix.RowOrder)
N := A.Rows()
*/
N := 7
nb := 0
A0 := matrix.FloatUniform(N, N)
A := matrix.FloatZeros(N, N)
Mult(A, A0, A0, 1.0, 1.0, TRANSB)
B := matrix.FloatNormal(A.Rows(), 2)
B0 := B.Copy()
B1 := B.Copy()
Mult(B0, A, B, 1.0, 0.0, NOTRANS)
_, _, _ = B0, B1, A0
ipiv := make([]int, N, N)
L, _ := DecomposeLDL(A.Copy(), nil, ipiv, LOWER, 0)
//t.Logf("unblk: ipiv = %v\n", ipiv)
//t.Logf("unblk: L\n%v\n", L)
ApplyRowPivots(B, ipiv, FORWARD)
MultTrm(B, L, 1.0, LOWER|UNIT|TRANSA)
MultDiag(B, L, LEFT)
MultTrm(B, L, 1.0, LOWER|UNIT)
ApplyRowPivots(B0, ipiv, FORWARD)
t.Logf(" unblk: L*D*L.T %d pivots: ||A*B - L*D*L.T*B||_1: %e\n",
NumPivots(ipiv), NormP(B.Minus(B0), NORM_ONE))
t.Logf("pivots: %v\n", ipiv)
nb = 4
w := matrix.FloatWithValue(A.Rows(), nb, 1.0)
L, _ = DecomposeLDL(A.Copy(), w, ipiv, LOWER, nb)
//t.Logf("blk: ipiv = %v\n", ipiv)
//t.Logf("blk: L\n%v\n", L)
// B2 = A*B1 == A*B
B2 := B1.Copy()
Mult(B2, A, B1, 1.0, 0.0, NOTRANS)
ApplyRowPivots(B1, ipiv, FORWARD)
MultTrm(B1, L, 1.0, LOWER|UNIT|TRANSA)
MultDiag(B1, L, LEFT)
MultTrm(B1, L, 1.0, LOWER|UNIT)
ApplyRowPivots(B2, ipiv, FORWARD)
t.Logf(" blk: L*D*L.T %d pivots: ||A*B - L*D*L.T*B||_1: %e\n",
NumPivots(ipiv), NormP(B2.Minus(B1), NORM_ONE))
t.Logf("pivots: %v\n", ipiv)
}
func _TestSyrk2Small(t *testing.T) {
//bN := 7
Udata3 := [][]float64{
[]float64{2.0, 2.0, 2.0},
[]float64{0.0, 3.0, 3.0},
[]float64{0.0, 0.0, 4.0}}
Udata := [][]float64{
[]float64{1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0},
[]float64{0.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0},
[]float64{0.0, 0.0, 3.0, 3.0, 3.0, 3.0, 3.0},
[]float64{0.0, 0.0, 0.0, 4.0, 4.0, 4.0, 4.0},
[]float64{0.0, 0.0, 0.0, 0.0, 5.0, 5.0, 5.0},
[]float64{0.0, 0.0, 0.0, 0.0, 0.0, 6.0, 6.0},
[]float64{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 7.0}}
U := matrix.FloatMatrixFromTable(Udata, matrix.RowOrder)
U3 := matrix.FloatMatrixFromTable(Udata3, matrix.RowOrder)
_ = U
_ = U3
Ldata3 := [][]float64{
[]float64{1.0, 0.0, 0.0},
[]float64{1.0, 2.0, 0.0},
[]float64{1.0, 2.0, 3.0}}
Ldata := [][]float64{
[]float64{1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
[]float64{1.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0},
[]float64{1.0, 2.0, 3.0, 0.0, 0.0, 0.0, 0.0},
[]float64{1.0, 2.0, 3.0, 4.0, 0.0, 0.0, 0.0},
[]float64{1.0, 2.0, 3.0, 4.0, 5.0, 0.0, 0.0},
[]float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.0},
[]float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}}
L := matrix.FloatMatrixFromTable(Ldata, matrix.RowOrder)
L3 := matrix.FloatMatrixFromTable(Ldata3, matrix.RowOrder)
_ = L
_ = L3
Adata := [][]float64{
[]float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0},
[]float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}}
Bdata := [][]float64{
[]float64{7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0},
[]float64{7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}}
_ = Bdata
A := matrix.FloatMatrixFromTable(Adata)
//B := matrix.FloatMatrixFromTable(Bdata);
B := matrix.FloatNormal(7, 2)
t.Logf("-- SYR2K UPPER --")
syrk2Test(t, U.Copy(), A, B, UPPER, 4, 2)
t.Logf("-- SYR2K LOWER --")
syrk2Test(t, L.Copy(), A, B, LOWER, 4, 2)
t.Logf("-- SYR2K UPPER, TRANSA --")
//t.Logf("A: \n%v\n", A.Transpose())
syrk2Test(t, U.Copy(), A.Transpose(), B.Transpose(), UPPER|TRANSA, 4, 2)
t.Logf("-- SYR2K LOWER, TRANS --")
syrk2Test(t, L.Copy(), A.Transpose(), B.Transpose(), LOWER|TRANSA, 4, 2)
}
func CTestBlasUp(m, n, p int) (fnc func(), A, B, C *matrix.FloatMatrix) {
A = matrix.FloatNormalSymmetric(m, matrix.Lower)
B = matrix.FloatNormal(m, n)
C = matrix.FloatZeros(m, n)
fnc = func() {
blas.SymmFloat(A, B, C, 1.0, 1.0, linalg.OptUpper)
}
return fnc, A, B, C
}
func CTestSymmLower(m, n, p int) (fnc func(), A, B, C *matrix.FloatMatrix) {
A = matrix.FloatNormalSymmetric(m, matrix.Upper)
B = matrix.FloatNormal(m, n)
C = matrix.FloatZeros(m, n)
fnc = func() {
matops.MultSym(C, A, B, 1.0, 1.0, matops.LEFT|matops.LOWER)
}
return fnc, A, B, C
}
func _TestRank(t *testing.T) {
bM := M * 100
bN := N * 100
//bP := 5
A := matrix.FloatWithValue(bM, bN, 1.0)
A0 := matrix.FloatWithValue(bM, bN, 1.0)
X := matrix.FloatNormal(bM, 1)
Y := matrix.FloatNormal(bN, 1)
Ar := A.FloatArray()
Xr := X.FloatArray()
Yr := Y.FloatArray()
blas.GerFloat(X, Y, A0, 1.0)
DRankMV(Ar, Xr, Yr, 1.0, A.LeadingIndex(), 1, 1, 0, bN, 0, bM, 4, 4)
t.Logf("GER A0 == A1: %v\n", A0.AllClose(A))
}
func _TestMultTransABig(t *testing.T) {
bM := 100*M + 3
bN := 100*N + 3
bP := 100*P + 3
D := matrix.FloatNormal(bM, bP)
E := matrix.FloatNormal(bP, bN)
C0 := matrix.FloatZeros(bM, bN)
C1 := matrix.FloatZeros(bM, bN)
Dt := D.Transpose()
Dr := Dt.FloatArray()
Er := E.FloatArray()
C1r := C1.FloatArray()
blas.GemmFloat(Dt, E, C0, 1.0, 1.0, linalg.OptTransA)
DMult(C1r, Dr, Er, 1.0, 1.0, TRANSA, bM, bM, bP, bP, 0, bN, 0, bM, 32, 32, 32)
t.Logf("C0 == C1: %v\n", C0.AllClose(C1))
}
func _TestMultBig(t *testing.T) {
bM := 100*M + 3
bN := 100*N + 3
bP := 100*P + 3
D := matrix.FloatNormal(bM, bP)
E := matrix.FloatNormal(bP, bN)
C0 := matrix.FloatZeros(bM, bN)
C1 := matrix.FloatZeros(bM, bN)
Dr := D.FloatArray()
Er := E.FloatArray()
C1r := C1.FloatArray()
blas.GemmFloat(D, E, C0, 1.0, 1.0)
//t.Logf("blas: C=D*E\n%v\n", C0)
DMult(C1r, Dr, Er, 1.0, 1.0, NOTRANS, bM, bM, bP, bP, 0, bN, 0, bM, 32, 32, 32)
res := C0.AllClose(C1)
t.Logf("C0 == C1: %v\n", res)
}
func _TestMultSmall(t *testing.T) {
bM := 6
bN := 6
bP := 6
D := matrix.FloatNormal(bM, bP)
E := matrix.FloatNormal(bP, bN)
C0 := matrix.FloatWithValue(bM, bN, 1.0)
C1 := C0.Copy()
Dr := D.FloatArray()
Er := E.FloatArray()
C1r := C1.FloatArray()
blas.GemmFloat(D, E, C0, 1.0, 1.0)
t.Logf("blas: C=D*E\n%v\n", C0)
DMult(C1r, Dr, Er, 1.0, 1.0, NOTRANS, bM, bM, bP, bP, 0, bN, 0, bM, 4, 4, 4)
t.Logf("C0 == C1: %v\n", C0.AllClose(C1))
t.Logf("C1: C1=D*E\n%v\n", C1)
}
func _TestMultTransASmall(t *testing.T) {
bM := 7
bN := 7
bP := 7
D := matrix.FloatNormal(bM, bP)
E := matrix.FloatNormal(bP, bN)
C0 := matrix.FloatWithValue(bM, bN, 0.0)
C1 := C0.Copy()
Dt := D.Transpose()
Dr := Dt.FloatArray()
Er := E.FloatArray()
C1r := C1.FloatArray()
blas.GemmFloat(Dt, E, C0, 1.0, 1.0, linalg.OptTransA)
t.Logf("blas: C=D*E\n%v\n", C0)
DMult(C1r, Dr, Er, 1.0, 1.0, TRANSA, bM, bM, bP, bP, 0, bN, 0, bM, 4, 4, 4)
t.Logf("C0 == C1: %v\n", C0.AllClose(C1))
t.Logf("C1: C1=D*E\n%v\n", C1)
}
func _TestMultTransABSmall(t *testing.T) {
bM := 7
bN := 7
bP := 7
D := matrix.FloatNormal(bM, bP)
E := matrix.FloatNormal(bP, bN)
C0 := matrix.FloatZeros(bM, bN)
C1 := matrix.FloatZeros(bM, bN)
Dt := D.Transpose()
Et := E.Transpose()
Dr := Dt.FloatArray()
Er := Et.FloatArray()
C1r := C1.FloatArray()
blas.GemmFloat(Dt, Et, C0, 1.0, 1.0, linalg.OptTransA, linalg.OptTransB)
t.Logf("blas: C=D.T*E.T\n%v\n", C0)
DMult(C1r, Dr, Er, 1.0, 1.0, TRANSA|TRANSB, bM, bM, bP, bP, 0, bN, 0, bM, 4, 4, 4)
t.Logf("C0 == C1: %v\n", C0.AllClose(C1))
t.Logf("C1: C1=D.T*E.T\n%v\n", C1)
}
func _TestBK2U(t *testing.T) {
Bdata := [][]float64{
[]float64{10.0, 20.0},
[]float64{10.0, 20.0},
[]float64{10.0, 20.0},
[]float64{10.0, 20.0},
[]float64{10.0, 20.0},
[]float64{10.0, 20.0},
[]float64{10.0, 20.0}}
N := 7
A0 := matrix.FloatNormal(N, N)
A := matrix.FloatZeros(N, N)
// A is symmetric, posivite definite
Mult(A, A0, A0, 1.0, 1.0, TRANSB)
X := matrix.FloatMatrixFromTable(Bdata, matrix.RowOrder)
B := matrix.FloatZeros(N, 2)
MultSym(B, A, X, 1.0, 0.0, LOWER|LEFT)
t.Logf("initial B:\n%v\n", B)
nb := 0
W := matrix.FloatWithValue(A.Rows(), 5, 1.0)
A.SetAt(4, 1, A.GetAt(4, 1)+1.0)
A.SetAt(1, 4, A.GetAt(4, 1))
ipiv := make([]int, N, N)
L, _ := DecomposeBK(A.Copy(), W, ipiv, LOWER, nb)
t.Logf("ipiv: %v\n", ipiv)
t.Logf("L:\n%v\n", L)
ipiv0 := make([]int, N, N)
nb = 4
L0, _ := DecomposeBK(A.Copy(), W, ipiv0, LOWER, nb)
t.Logf("ipiv: %v\n", ipiv0)
t.Logf("L:\n%v\n", L0)
B0 := B.Copy()
SolveBK(B0, L0, ipiv0, LOWER)
t.Logf("B0:\n%v\n", B0)
ipiv2 := make([]int32, N, N)
lapack.Sytrf(A, ipiv2, linalg.OptLower)
t.Logf("ipiv2: %v\n", ipiv2)
t.Logf("lapack A:\n%v\n", A)
lapack.Sytrs(A, B, ipiv2, linalg.OptLower)
t.Logf("lapack B:\n%v\n", B)
t.Logf("B == B0: %v\n", B.AllClose(B0))
}
func TestLDLSolve(t *testing.T) {
N := 7
nb := 4
K := 6
A0 := matrix.FloatUniform(N, N)
A := matrix.FloatZeros(N, N)
Mult(A, A0, A0, 1.0, 1.0, TRANSB)
X0 := matrix.FloatNormal(A.Rows(), K)
B0 := matrix.FloatZeros(X0.Size())
Mult(B0, A, X0, 1.0, 0.0, NOTRANS)
B := B0.Copy()
_ = B
w := matrix.FloatZeros(A.Rows(), nb)
ipiv := make([]int, N, N)
L, _ := DecomposeLDL(A.Copy(), w, ipiv, LOWER, nb)
ipiv0 := make([]int, N, N)
L0, _ := DecomposeLDL(A.Copy(), w, ipiv0, LOWER, 0)
t.Logf("L:\n%v\n", L)
t.Logf("ipiv: %v\n", ipiv)
t.Logf("L0:\n%v\n", L0)
t.Logf("ipiv0: %v\n", ipiv0)
t.Logf("L == L0: %v", L.AllClose(L0))
// B = A*X0; solve and B should be X0
/*
SolveLDL(B, L, ipiv, LOWER)
B.Minus(X0)
t.Logf("L*D*L.T: ||A*X - B||_1: %e\n", NormP(B, NORM_ONE))
t.Logf("ipiv: %v\n", ipiv)
*/
/*
B = B0.Copy()
U, _ := DecomposeLDL(A.Copy(), w, ipiv, UPPER, nb)
// B = A*X0; solve and B should be X0
SolveLDL(B, U, ipiv, UPPER)
B.Minus(X0)
t.Logf("U*D*U.T: ||A*X - B||_1: %e\n", NormP(B, NORM_ONE))
*/
}
func _TestMultSymmLower(t *testing.T) {
//bM := 5
bN := 100 * N
bP := 100 * P
A := matrix.FloatNormalSymmetric(bN, matrix.Lower)
B := matrix.FloatNormal(bN, bP)
C0 := matrix.FloatZeros(bN, bP)
C1 := matrix.FloatZeros(bN, bP)
Ar := A.FloatArray()
Br := B.FloatArray()
C1r := C1.FloatArray()
blas.SymmFloat(A, B, C0, 1.0, 1.0, linalg.OptLower)
DMultSymm(C1r, Ar, Br, 1.0, 1.0, LOWER|LEFT, bN, A.LeadingIndex(), bN,
bN, 0, bP, 0, bN, 32, 32, 32)
t.Logf("C0 == C1: %v\n", C0.AllClose(C1))
}
func _TestLDLupper(t *testing.T) {
N := 8
nb := 0
A0 := matrix.FloatUniform(N, N)
A := matrix.FloatZeros(N, N)
Mult(A, A0, A0, 1.0, 1.0, TRANSB)
B := matrix.FloatNormal(A.Rows(), 2)
B0 := B.Copy()
B1 := B.Copy()
Mult(B0, A, B, 1.0, 0.0, NOTRANS)
ipiv := make([]int, N, N)
U, _ := DecomposeLDL(A.Copy(), nil, ipiv, UPPER, 0)
ApplyRowPivots(B, ipiv, BACKWARD)
MultTrm(B, U, 1.0, UPPER|UNIT|TRANSA)
MultDiag(B, U, LEFT)
MultTrm(B, U, 1.0, UPPER|UNIT)
ApplyRowPivots(B0, ipiv, BACKWARD)
t.Logf(" unblk: U*D*U.T %d pivots: ||A*B - U*D*U.T*B||_1: %e\n",
NumPivots(ipiv), NormP(B.Minus(B0), NORM_ONE))
t.Logf("pivots: %v\n", ipiv)
nb = 4
w := matrix.FloatZeros(A.Rows(), nb)
U, _ = DecomposeLDL(A.Copy(), w, ipiv, UPPER, nb)
// B2 = A*B1 == A*B
B2 := B1.Copy()
Mult(B2, A, B1, 1.0, 0.0, NOTRANS)
ApplyRowPivots(B1, ipiv, BACKWARD)
MultTrm(B1, U, 1.0, UPPER|UNIT|TRANSA)
MultDiag(B1, U, LEFT)
MultTrm(B1, U, 1.0, UPPER|UNIT)
ApplyRowPivots(B2, ipiv, BACKWARD)
t.Logf(" blk: U*D*U.T %d pivots: ||A*B - U*D*U.T*B||_1: %e\n",
NumPivots(ipiv), NormP(B2.Minus(B1), NORM_ONE))
t.Logf("pivots: %v\n", ipiv)
}
func _TestMultMVSmall(t *testing.T) {
bM := 5
bN := 4
A := matrix.FloatNormal(bM, bN)
X := matrix.FloatVector([]float64{1.0, 2.0, 3.0, 4.0})
Y1 := matrix.FloatZeros(bM, 1)
Y0 := matrix.FloatZeros(bM, 1)
Ar := A.FloatArray()
Xr := X.FloatArray()
Y1r := Y1.FloatArray()
blas.GemvFloat(A, X, Y0, 1.0, 1.0)
DMultMV(Y1r, Ar, Xr, 1.0, 1.0, NOTRANS, 1, A.LeadingIndex(), 1, 0, bN, 0, bM, 4, 4)
ok := Y0.AllClose(Y1)
t.Logf("Y0 == Y1: %v\n", ok)
if !ok {
t.Logf("blas: Y=A*X\n%v\n", Y0)
t.Logf("Y1: Y1 = A*X\n%v\n", Y1)
}
}
