func TestDTrsm3(t *testing.T) {
const N = 31
const K = 4
A := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(N, K)
B0 := cmat.NewMatrix(N, K)
ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatUniformSource(1.0, -0.5)
A.SetFrom(zeromean, cmat.UPPER)
B.SetFrom(ones)
B0.Copy(B)
// B = A*B
blasd.MultTrm(B, A, 1.0, gomas.UPPER|gomas.LEFT)
blasd.SolveTrm(B, A, 1.0, gomas.UPPER|gomas.LEFT)
ok := B0.AllClose(B)
t.Logf("B == trsm(trmm(B, A, L|U|N), A, L|U|N) : %v\n", ok)
B.Copy(B0)
// B = A.T*B
blasd.MultTrm(B, A, 1.0, gomas.UPPER|gomas.LEFT|gomas.TRANSA)
blasd.SolveTrm(B, A, 1.0, gomas.UPPER|gomas.LEFT|gomas.TRANSA)
ok = B0.AllClose(B)
t.Logf("B == trsm(trmm(B, A, L|U|T), A, L|U|T) : %v\n", ok)
}
func TestDTrsm1(t *testing.T) {
nofail := true
const N = 31
const K = 4
A := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(N, K)
B0 := cmat.NewMatrix(N, K)
ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatUniformSource(1.0, -0.5)
A.SetFrom(zeromean, cmat.LOWER)
B.SetFrom(ones)
B0.Copy(B)
// B = A*B
blasd.MultTrm(B, A, 1.0, gomas.LOWER|gomas.LEFT)
blasd.SolveTrm(B, A, 1.0, gomas.LOWER|gomas.LEFT)
ok := B0.AllClose(B)
nofail = nofail && ok
t.Logf("B == trsm(trmm(B, A, L|L|N), A, L|L|N) : %v\n", ok)
if !ok {
t.Logf("B|B0:\n%v\n", cmat.NewJoin(cmat.AUGMENT, B, B0))
}
B.Copy(B0)
// B = A.T*B
blasd.MultTrm(B, A, 1.0, gomas.LOWER|gomas.LEFT|gomas.TRANSA)
blasd.SolveTrm(B, A, 1.0, gomas.LOWER|gomas.LEFT|gomas.TRANSA)
ok = B0.AllClose(B)
nofail = nofail && ok
t.Logf("B == trsm(trmm(B, A, L|L|T), A, L|L|T) : %v\n", ok)
}
func TestDSyr1(t *testing.T) {
const N = 911
A := cmat.NewMatrix(N, N)
X := cmat.NewMatrix(N, 1)
B := cmat.NewMatrix(N, N)
//ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatUniformSource(0.5, 2.0)
A.SetFrom(zeromean, cmat.LOWER)
X.SetFrom(zeromean)
B.Copy(A)
// B = A*B
blasd.MVUpdate(B, X, X, 1.0)
cmat.TriL(B, cmat.NONE)
blasd.MVUpdateSym(A, X, 1.0, gomas.LOWER)
ok := B.AllClose(A)
t.Logf("MVUpdateSym(A, X, L) == TriL(MVUpdate(A, X, X)) : %v\n", ok)
A.SetFrom(zeromean, cmat.UPPER)
cmat.TriU(A, cmat.NONE)
B.Copy(A)
blasd.MVUpdate(B, X, X, 1.0)
cmat.TriU(B, cmat.NONE)
blasd.MVUpdateSym(A, X, 1.0, gomas.UPPER)
ok = B.AllClose(A)
t.Logf("MVUpdateSym(A, X, U) == TriU(MVUpdate(A, X, X)) : %v\n", ok)
}
func TestDTrms2(t *testing.T) {
const N = 31
const K = 4
nofail := true
A := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(K, N)
B0 := cmat.NewMatrix(K, N)
ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatUniformSource(1.0, -0.5)
A.SetFrom(zeromean, cmat.LOWER)
B.SetFrom(ones)
B0.Copy(B)
// B = B*A
blasd.MultTrm(B, A, 1.0, gomas.LOWER|gomas.RIGHT)
blasd.SolveTrm(B, A, 1.0, gomas.LOWER|gomas.RIGHT)
ok := B0.AllClose(B)
nofail = nofail && ok
t.Logf("B == trsm(trmm(B, A, R|L|N), A, R|L|N) : %v\n", ok)
B.Copy(B0)
// B = B*A.T
blasd.MultTrm(B, A, 1.0, gomas.LOWER|gomas.RIGHT|gomas.TRANSA)
blasd.SolveTrm(B, A, 1.0, gomas.LOWER|gomas.RIGHT|gomas.TRANSA)
ok = B0.AllClose(B)
nofail = nofail && ok
t.Logf("B == trsm(trmm(B, A, R|L|T), A, R|L|T) : %v\n", ok)
}
func TestBlockedDecomposeCHOL(t *testing.T) {
N := 119
nb := 16
conf := gomas.NewConf()
conf.LB = nb
Z := cmat.NewMatrix(N, N)
AL := cmat.NewMatrix(N, N)
AU := cmat.NewMatrix(N, N)
unitrand := cmat.NewFloatUniformSource()
Z.SetFrom(unitrand)
blasd.Mult(AL, Z, Z, 1.0, 0.0, gomas.TRANSB)
AU.Copy(AL)
eu := lapackd.CHOLFactor(AU, gomas.UPPER, conf)
el := lapackd.CHOLFactor(AL, gomas.LOWER, conf)
_, _ = eu, el
Z.Transpose(AU)
if N < 10 {
t.Logf("AU.T:\n%v\n", Z)
t.Logf("AL:\n%v\n", AL)
}
ok := AL.AllClose(Z)
t.Logf("Decompose(AL) == Decompose(AU).T: %v\n", ok)
}
func TestUpperCHOL(t *testing.T) {
N := 311
K := 43
nb := 0
conf := gomas.NewConf()
conf.LB = nb
Z := cmat.NewMatrix(N, N)
A := cmat.NewMatrix(N, N)
A0 := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(N, K)
X := cmat.NewMatrix(N, K)
unitrand := cmat.NewFloatUniformSource()
Z.SetFrom(unitrand)
blasd.Mult(A, Z, Z, 1.0, 0.0, gomas.TRANSB)
A0.Copy(A)
B.SetFrom(unitrand)
X.Copy(B)
// A = chol(A) = U.T*U
t.Logf("Unblocked version: nb=%d\n", conf.LB)
lapackd.CHOLFactor(A, gomas.UPPER, conf)
// X = A.-1*B = U.-1*(U.-T*B)
lapackd.CHOLSolve(X, A, gomas.UPPER)
// B = B - A*X
blasd.Mult(B, A0, X, -1.0, 1.0, gomas.NONE)
// ||B - A*X||_1
nrm := lapackd.NormP(B, lapackd.NORM_ONE)
t.Logf("N=%d: ||B - A*X||_1: %e\n", N, nrm)
// A = chol(A) = U.T*U
A.Copy(A0)
B.SetFrom(unitrand)
X.Copy(B)
conf.LB = 16
t.Logf("Blocked version: nb=%d\n", conf.LB)
lapackd.CHOLFactor(A, gomas.UPPER, conf)
// X = A.-1*B = U.-1*(U.-T*B)
lapackd.CHOLSolve(X, A, gomas.UPPER)
// B = B - A*X
blasd.Mult(B, A0, X, -1.0, 1.0, gomas.NONE)
// ||B - A*X||_1
nrm = lapackd.NormP(B, lapackd.NORM_ONE)
t.Logf("N=%d: ||B - A*X||_1: %e\n", N, nrm)
}
func TestDSyrOther(t *testing.T) {
const N = 911
var vec, As, Bs cmat.FloatMatrix
P := N / 3
A := cmat.NewMatrix(P, P)
X := cmat.NewMatrix(P, 1)
B := cmat.NewMatrix(P, P)
//ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatUniformSource(0.5, 2.0)
A.SetFrom(zeromean, cmat.UPPER)
X.SetFrom(zeromean)
B.Copy(A)
// update submatrices
for i := 1; i < P; i++ {
vec.SubMatrix(A, i-1, i, 1, P-i)
As.SubMatrix(A, i, i)
Bs.SubMatrix(B, i, i)
// update with normal and symmetric
blasd.MVUpdate(&Bs, &vec, &vec, 1.0)
blasd.MVUpdateSym(&As, &vec, 1.0, gomas.UPPER)
}
// make normal update triangular and compare
cmat.TriU(B, cmat.NONE)
ok := B.AllClose(A)
t.Logf("submatrix updates on upper triangular : %v\n", ok)
A.SetFrom(zeromean, cmat.LOWER)
cmat.TriL(A, cmat.NONE)
B.Copy(A)
// update submatrices
for i := 1; i < P; i++ {
vec.SubMatrix(A, i-1, i, 1, P-i)
As.SubMatrix(A, i, i)
Bs.SubMatrix(B, i, i)
// update with normal and symmetric
blasd.MVUpdate(&Bs, &vec, &vec, 1.0)
blasd.MVUpdateSym(&As, &vec, 1.0, gomas.LOWER)
}
// make normal update triangular and compare
cmat.TriL(B, cmat.NONE)
ok = B.AllClose(A)
t.Logf("submatrix updates on lower triangular : %v\n", ok)
}
func TestLU(t *testing.T) {
N := 119
K := 41
nb := 0
A := cmat.NewMatrix(N, N)
A0 := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(N, K)
X := cmat.NewMatrix(N, K)
unitrand := cmat.NewFloatUniformSource()
A.SetFrom(unitrand)
A0.Copy(A)
B.SetFrom(unitrand)
X.Copy(B)
piv := lapackd.NewPivots(N)
conf := gomas.DefaultConf()
conf.LB = nb
// R = lu(A) = P*L*U
lapackd.LUFactor(A, piv, conf)
// X = A.-1*B = U.-1*(L.-1*B)
lapackd.LUSolve(X, A, piv, gomas.NONE)
// B = B - A*X
blasd.Mult(B, A0, X, -1.0, 1.0, gomas.NONE)
nrm := lapackd.NormP(B, lapackd.NORM_ONE)
t.Logf("Unblocked decomposition: nb=%d\n", conf.LB)
t.Logf("N=%d ||B - A*X||_1: %e\n", N, nrm)
// blocked
conf.LB = 16
A.Copy(A0)
B.SetFrom(unitrand)
X.Copy(B)
// lu(A) = P*L*U
lapackd.LUFactor(A, piv, conf)
// X = A.-1*B = U.-1*(L.-1*B)
lapackd.LUSolve(X, A, piv, gomas.NONE)
// B = B - A*X
blasd.Mult(B, A0, X, -1.0, 1.0, gomas.NONE)
nrm = lapackd.NormP(B, lapackd.NORM_ONE)
t.Logf("Blocked decomposition: nb=%d\n", conf.LB)
t.Logf("N=%d ||B - A*X||_1: %e\n", N, nrm)
}
func TestDSyr2(t *testing.T) {
const N = 911
A := cmat.NewMatrix(N, N)
X := cmat.NewMatrix(N, 1)
Y := cmat.NewMatrix(N, 1)
B := cmat.NewMatrix(N, N)
ones := cmat.NewFloatConstSource(1.0)
twos := cmat.NewFloatConstSource(2.0)
zeromean := cmat.NewFloatUniformSource(0.5, 2.0)
A.SetFrom(zeromean, cmat.LOWER)
X.SetFrom(ones)
Y.SetFrom(twos)
B.Copy(A)
// B = A*B
blasd.MVUpdate(B, X, Y, 1.0)
blasd.MVUpdate(B, Y, X, 1.0)
cmat.TriL(B, cmat.NONE)
blasd.MVUpdate2Sym(A, X, Y, 1.0, gomas.LOWER)
ok := B.AllClose(A)
if N < 10 {
t.Logf("A:\n%v\n", A)
t.Logf("B:\n%v\n", B)
}
t.Logf("MVUpdate2Sym(A, X, Y, L) == TriL(MVUpdate(A, X, Y);MVUpdate(A, Y, X)) : %v\n", ok)
A.SetFrom(zeromean, cmat.UPPER)
cmat.TriU(A, cmat.NONE)
B.Copy(A)
blasd.MVUpdate(B, X, Y, 1.0)
blasd.MVUpdate(B, Y, X, 1.0)
cmat.TriU(B, cmat.NONE)
blasd.MVUpdate2Sym(A, X, Y, 1.0, gomas.UPPER)
ok = B.AllClose(A)
if N < 10 {
t.Logf("A:\n%v\n", A)
t.Logf("B:\n%v\n", B)
}
t.Logf("MVUpdate2Sym(A, X, Y, U) == TriU(MVUpdate(A, X, Y);MVUpdate(A, Y, X)) : %v\n", ok)
}
func TestDVecScal(t *testing.T) {
const N = 911
X := cmat.NewMatrix(N, 1)
Y := cmat.NewMatrix(N, 1)
zeromean := cmat.NewFloatUniformSource(2.0, 0.5)
X.SetFrom(zeromean)
Y.Copy(X)
// B = A*B
blasd.Scale(X, 2.0)
blasd.InvScale(X, 2.0)
ok := X.AllClose(Y)
t.Logf("X = InvScale(Scale(X, 2.0), 2.0) : %v\n", ok)
}
func TestDSyrkUpper(t *testing.T) {
var ok bool
conf := gomas.NewConf()
A := cmat.NewMatrix(N, N)
A0 := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(N, K)
Bt := cmat.NewMatrix(K, N)
ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatUniformSource()
_, _ = ones, zeromean
A.SetFrom(ones, cmat.UPPER)
A0.Copy(A)
B.SetFrom(ones)
Bt.Transpose(B)
// B = A*B
blasd.UpdateSym(A, B, 1.0, 1.0, gomas.UPPER, conf)
blasd.Mult(A0, B, B, 1.0, 1.0, gomas.TRANSB)
cmat.TriU(A0, cmat.NONE)
ok = A0.AllClose(A)
t.Logf("UpdateSym(A, B, U|N) == TriU(Mult(A, B, B.T)) : %v\n", ok)
if N < 10 {
t.Logf("UpdateSym(A, B)\n%v\n", A)
t.Logf("Mult(A, B.T, B)\n%v\n", A0)
}
A.SetFrom(ones, cmat.UPPER)
A0.Copy(A)
blasd.UpdateSym(A, Bt, 1.0, 1.0, gomas.UPPER|gomas.TRANSA, conf)
blasd.Mult(A0, Bt, Bt, 1.0, 1.0, gomas.TRANSA)
cmat.TriU(A0, cmat.NONE)
ok = A0.AllClose(A)
t.Logf("UpdateSym(A, B, U|T) == TriU(Mult(A, B.T, B)) : %v\n", ok)
if N < 10 {
t.Logf("UpdateSym(A, B)\n%v\n", A)
t.Logf("Mult(A, B.T, B)\n%v\n", A0)
}
}
