func TestDTrmmUnitUpper(t *testing.T) {
var d cmat.FloatMatrix
N := 563
K := 171
A := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(N, K)
B0 := cmat.NewMatrix(N, K)
C := cmat.NewMatrix(N, K)
zeros := cmat.NewFloatConstSource(0.0)
ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatNormSource()
A.SetFrom(zeromean, cmat.UPPER|cmat.UNIT)
B.SetFrom(ones)
B0.SetFrom(ones)
// B = A*B
blasd.MultTrm(B, A, 1.0, gomas.UPPER|gomas.LEFT|gomas.UNIT)
d.Diag(A).SetFrom(ones)
blasd.Mult(C, A, B0, 1.0, 0.0, gomas.NONE)
ok := C.AllClose(B)
t.Logf("trmm(B, A, L|U|N|U) == gemm(C, TriUU(A), B) : %v\n", ok)
B.SetFrom(ones)
// B = A.T*B
d.Diag(A).SetFrom(zeros)
blasd.MultTrm(B, A, 1.0, gomas.UPPER|gomas.LEFT|gomas.TRANSA|gomas.UNIT)
d.Diag(A).SetFrom(ones)
blasd.Mult(C, A, B0, 1.0, 0.0, gomas.TRANSA)
ok = C.AllClose(B)
t.Logf("trmm(B, A, L|U|T|U) == gemm(C, TriUU(A).T, B) : %v\n", ok)
}
func TestDTrmmUnitUpperRight(t *testing.T) {
var d cmat.FloatMatrix
N := 563
K := 171
A := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(K, N)
B0 := cmat.NewMatrix(K, N)
C := cmat.NewMatrix(K, N)
zeros := cmat.NewFloatConstSource(0.0)
ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatNormSource()
A.SetFrom(zeromean, cmat.UPPER|cmat.UNIT)
B.SetFrom(ones)
B0.SetFrom(ones)
// B = B*A
blasd.MultTrm(B, A, 1.0, gomas.UPPER|gomas.RIGHT|gomas.UNIT)
d.Diag(A).SetFrom(ones)
blasd.Mult(C, B0, A, 1.0, 0.0, gomas.NONE)
ok := C.AllClose(B)
t.Logf("trmm(B, A, R|U|N|U) == gemm(C, B, TriUU(A)) : %v\n", ok)
B.SetFrom(ones)
// B = B*A.T
d.SetFrom(zeros)
blasd.MultTrm(B, A, 1.0, gomas.UPPER|gomas.RIGHT|gomas.TRANSA|gomas.UNIT)
d.SetFrom(ones)
blasd.Mult(C, B0, A, 1.0, 0.0, gomas.TRANSB)
ok = C.AllClose(B)
t.Logf("trmm(B, A, R|U|T|U) == gemm(C, B, TriUU(A).T) : %v\n", ok)
}
// Simple and slow LQ decomposition with Givens rotations
func TestGivensLQ(t *testing.T) {
var d cmat.FloatMatrix
M := 149
N := 167
A := cmat.NewMatrix(M, N)
A1 := cmat.NewCopy(A)
ones := cmat.NewFloatConstSource(1.0)
src := cmat.NewFloatNormSource()
A.SetFrom(src)
A0 := cmat.NewCopy(A)
Qt := cmat.NewMatrix(N, N)
d.Diag(Qt)
d.SetFrom(ones)
// R = G(n)...G(2)G(1)*A; Q = G(1).T*G(2).T...G(n).T ; Q.T = G(n)...G(2)G(1)
for i := 0; i < M; i++ {
// zero elements right of diagonal
for j := N - 2; j >= i; j-- {
c, s, r := lapackd.ComputeGivens(A.Get(i, j), A.Get(i, j+1))
A.Set(i, j, r)
A.Set(i, j+1, 0.0)
// apply rotation to this column starting from row i+1
lapackd.ApplyGivensRight(A, j, j+1, i+1, M-i-1, c, s)
// update Qt = G(k)*Qt
lapackd.ApplyGivensRight(Qt, j, j+1, 0, N, c, s)
}
}
// A = L*Q
blasd.Mult(A1, A, Qt, 1.0, 0.0, gomas.TRANSB)
blasd.Plus(A0, A1, 1.0, -1.0, gomas.NONE)
nrm := lapackd.NormP(A0, lapackd.NORM_ONE)
t.Logf("M=%d, N=%d ||A - L*G(1)..G(n)||_1: %e\n", M, N, nrm)
}
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 TestDTrmmLower(t *testing.T) {
N := 563
K := 171
nofail := true
A := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(N, K)
B0 := cmat.NewMatrix(N, K)
C := cmat.NewMatrix(N, K)
ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatNormSource()
A.SetFrom(zeromean, cmat.LOWER)
B.SetFrom(ones)
B0.SetFrom(ones)
// B = A*B
blasd.MultTrm(B, A, 1.0, gomas.LOWER|gomas.LEFT)
blasd.Mult(C, A, B0, 1.0, 0.0, gomas.NONE)
ok := C.AllClose(B)
nofail = nofail && ok
t.Logf("trmm(B, A, L|L|N) == gemm(C, TriL(A), B) : %v\n", ok)
B.SetFrom(ones)
// B = A.T*B
blasd.MultTrm(B, A, 1.0, gomas.LOWER|gomas.LEFT|gomas.TRANSA)
blasd.Mult(C, A, B0, 1.0, 0.0, gomas.TRANSA)
ok = C.AllClose(B)
nofail = nofail && ok
t.Logf("trmm(B, A, L|L|T) == gemm(C, TriL(A).T, B) : %v\n", ok)
}
func TestDTrmmLowerRight(t *testing.T) {
N := 563
K := 171
nofail := true
A := cmat.NewMatrix(N, N)
B := cmat.NewMatrix(K, N)
B0 := cmat.NewMatrix(K, N)
C := cmat.NewMatrix(K, N)
ones := cmat.NewFloatConstSource(1.0)
zeromean := cmat.NewFloatNormSource()
A.SetFrom(zeromean, cmat.LOWER)
B.SetFrom(ones)
B0.SetFrom(ones)
// B = B*A
blasd.MultTrm(B, A, 1.0, gomas.LOWER|gomas.RIGHT)
blasd.Mult(C, B0, A, 1.0, 0.0, gomas.NONE)
ok := C.AllClose(B)
nofail = nofail && ok
t.Logf("trmm(B, A, R|L|N) == gemm(C, B, TriL(A)) : %v\n", ok)
B.SetFrom(ones)
// B = B*A.T
blasd.MultTrm(B, A, 1.0, gomas.LOWER|gomas.RIGHT|gomas.TRANSA)
blasd.Mult(C, B0, A, 1.0, 0.0, gomas.TRANSB)
ok = C.AllClose(B)
nofail = nofail && ok
t.Logf("trmm(B, A, R|L|T) == gemm(C, B, TriL(A).T) : %v\n", ok)
}
/*
* Solve a system of linear equations A*X = B with general M-by-N
* matrix A using the QR factorization computed by DecomposeQRT().
*
* If flags&gomas.TRANS != 0:
* find the minimum norm solution of an overdetermined system A.T * X = B.
* i.e min ||X|| s.t A.T*X = B
*
* Otherwise:
* find the least squares solution of an overdetermined system, i.e.,
* solve the least squares problem: min || B - A*X ||.
*
* Arguments:
* B On entry, the right hand side N-by-P matrix B. On exit, the solution matrix X.
*
* A The elements on and above the diagonal contain the min(M,N)-by-N upper
* trapezoidal matrix R. The elements below the diagonal with the matrix 'T',
* represent the ortogonal matrix Q as product of elementary reflectors.
* Matrix A and T are as returned by DecomposeQRT()
*
* T The block reflector computed from elementary reflectors as returned by
* DecomposeQRT() or computed from elementary reflectors and scalar coefficients
* by BuildT()
*
* W Workspace, size as returned by WorkspaceMultQT()
*
* flags Indicator flag
*
* conf Blocking configuration
*
* Compatible with lapack.GELS (the m >= n part)
*/
func QRTSolve(B, A, T, W *cmat.FloatMatrix, flags int, confs ...*gomas.Config) *gomas.Error {
var err *gomas.Error = nil
var R, BT cmat.FloatMatrix
conf := gomas.CurrentConf(confs...)
if flags&gomas.TRANS != 0 {
// Solve overdetermined system A.T*X = B
// B' = R.-1*B
R.SubMatrix(A, 0, 0, n(A), n(A))
BT.SubMatrix(B, 0, 0, n(A), n(B))
err = blasd.SolveTrm(&BT, &R, 1.0, gomas.LEFT|gomas.UPPER|gomas.TRANSA, conf)
// Clear bottom part of B
BT.SubMatrix(B, n(A), 0)
BT.SetFrom(cmat.NewFloatConstSource(0.0))
// X = Q*B'
err = QRTMult(B, A, T, W, gomas.LEFT, conf)
} else {
// solve least square problem min ||A*X - B||
// B' = Q.T*B
err = QRTMult(B, A, T, W, gomas.LEFT|gomas.TRANS, conf)
if err != nil {
return err
}
// X = R.-1*B'
R.SubMatrix(A, 0, 0, n(A), n(A))
BT.SubMatrix(B, 0, 0, n(A), n(B))
err = blasd.SolveTrm(&BT, &R, 1.0, gomas.LEFT|gomas.UPPER, conf)
}
return err
}
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 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 TestPartition2D(t *testing.T) {
var ATL, ATR, ABL, ABR, As cmat.FloatMatrix
var A00, a01, A02, a10, a11, a12, A20, a21, A22 cmat.FloatMatrix
csource := cmat.NewFloatConstSource(1.0)
A := cmat.NewMatrix(6, 6)
As.SubMatrix(A, 1, 1, 4, 4)
As.SetFrom(csource)
Partition2x2(&ATL, &ATR, &ABL, &ABR, &As, 0, 0, PTOPLEFT)
t.Logf("ATL:\n%v\n", &ATL)
t.Logf("n(ATL)=%d, n(As)=%d\n", n(&ATL), n(&As))
k := 0
for n(&ATL) < n(&As) && k < n(&As) {
Repartition2x2to3x3(&ATL,
&A00, &a01, &A02,
&a10, &a11, &a12,
&A20, &a21, &A22, &As, 1, PBOTTOMRIGHT)
t.Logf("n(A00)=%d, n(a01)=%d, n(A02)=%d\n", n(&A00), n(&a01), n(&A02))
t.Logf("n(a10)=%d, n(a11)=%d, n(a12)=%d\n", n(&a10), n(&a11), n(&a12))
t.Logf("n(A20)=%d, n(a21)=%d, n(A22)=%d\n", n(&A20), n(&a21), n(&A22))
//t.Logf("n(a12)=%d [%d], n(a11)=%d\n", n(&a12), a12.Len(), a11.Len())
a11.Set(0, 0, a11.Get(0, 0)+1.0)
addConst(&a21, -2.0)
Continue3x3to2x2(&ATL, &ATR, &ABL, &ABR, &A00, &a11, &A22, &As, PBOTTOMRIGHT)
t.Logf("n(ATL)=%d, n(As)=%d\n", n(&ATL), n(&As))
k += 1
}
t.Logf("A:\n%v\n", A)
}
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)
}
// test: C = C*Q.T
func TestQLMultRightTrans(t *testing.T) {
var d, di0, di1 cmat.FloatMatrix
M := 891
N := 853
lb := 36
conf := gomas.NewConf()
A := cmat.NewMatrix(M, N)
src := cmat.NewFloatNormSource()
A.SetFrom(src)
C0 := cmat.NewMatrix(N, M)
d.Diag(C0, M-N)
ones := cmat.NewFloatConstSource(1.0)
d.SetFrom(ones)
C1 := cmat.NewCopy(C0)
I0 := cmat.NewMatrix(N, N)
I1 := cmat.NewCopy(I0)
di0.Diag(I0)
di1.Diag(I1)
tau := cmat.NewMatrix(N, 1)
W := cmat.NewMatrix(lb*(M+N), 1)
conf.LB = lb
lapackd.QLFactor(A, tau, W, conf)
conf.LB = 0
lapackd.QLMult(C0, A, tau, W, gomas.RIGHT|gomas.TRANS, conf)
// I = Q*Q.T - I
blasd.Mult(I0, C0, C0, 1.0, 0.0, gomas.TRANSB, conf)
blasd.Add(&di0, -1.0)
n0 := lapackd.NormP(I0, lapackd.NORM_ONE)
conf.LB = lb
lapackd.QLMult(C1, A, tau, W, gomas.RIGHT|gomas.TRANS, conf)
// I = Q*Q.T - I
blasd.Mult(I1, C1, C1, 1.0, 0.0, gomas.TRANSB, conf)
blasd.Add(&di1, -1.0)
n1 := lapackd.NormP(I1, lapackd.NORM_ONE)
if N < 10 {
t.Logf("unblk C0*Q:\n%v\n", C0)
t.Logf("blk. C2*Q:\n%v\n", C1)
}
blasd.Plus(C0, C1, 1.0, -1.0, gomas.NONE)
n2 := lapackd.NormP(C0, lapackd.NORM_ONE)
t.Logf("M=%d, N=%d ||unblk.QLMult(C) - blk.QLMult(C)||_1: %e\n", M, N, n2)
t.Logf("unblk M=%d, N=%d ||I - Q*Q.T||_1: %e\n", M, N, n0)
t.Logf("blk M=%d, N=%d ||I - Q*Q.T||_1: %e\n", M, N, n1)
}
// test: A - Q*Hess(A)*Q.T == 0
func TestMultHess(t *testing.T) {
N := 377
nb := 16
conf := gomas.NewConf()
conf.LB = nb
A := cmat.NewMatrix(N, N)
tau := cmat.NewMatrix(N, 1)
zeromean := cmat.NewFloatNormSource()
A.SetFrom(zeromean)
A0 := cmat.NewCopy(A)
// reduction
W := lapackd.Workspace(lapackd.HessReduceWork(A, conf))
lapackd.HessReduce(A, tau, W, conf)
var Hlow cmat.FloatMatrix
H := cmat.NewCopy(A)
// set triangular part below first subdiagonal to zeros
zeros := cmat.NewFloatConstSource(0.0)
Hlow.SubMatrix(H, 1, 0, N-1, N-1)
Hlow.SetFrom(zeros, cmat.LOWER|cmat.UNIT)
H1 := cmat.NewCopy(H)
// H := Q*H*Q.T
conf.LB = nb
lapackd.HessMult(H, A, tau, W, gomas.LEFT, conf)
lapackd.HessMult(H, A, tau, W, gomas.RIGHT|gomas.TRANS, conf)
// H := Q*H*Q.T
conf.LB = 0
lapackd.HessMult(H1, A, tau, W, gomas.LEFT, conf)
lapackd.HessMult(H1, A, tau, W, gomas.RIGHT|gomas.TRANS, conf)
// compute ||Q*Hess(A)*Q.T - A||_1
blasd.Plus(H, A0, 1.0, -1.0, gomas.NONE)
nrm := lapackd.NormP(H, lapackd.NORM_ONE)
t.Logf(" blk.|| Q*Hess(A)*Q.T - A ||_1 : %e\n", nrm)
blasd.Plus(H1, A0, 1.0, -1.0, gomas.NONE)
nrm = lapackd.NormP(H1, lapackd.NORM_ONE)
t.Logf("unblk.|| Q*Hess(A)*Q.T - A ||_1 : %e\n", nrm)
}
/*
* Solve a system of linear equations A.T*X = B with general M-by-N
* matrix A using the QR factorization computed by LQFactor().
*
* If flags&TRANS != 0:
* find the minimum norm solution of an overdetermined system A.T * X = B.
* i.e min ||X|| s.t A.T*X = B
*
* Otherwise:
* find the least squares solution of an overdetermined system, i.e.,
* solve the least squares problem: min || B - A*X ||.
*
* Arguments:
* B On entry, the right hand side N-by-P matrix B. On exit, the solution matrix X.
*
* A The elements on and below the diagonal contain the M-by-min(M,N) lower
* trapezoidal matrix L. The elements right of the diagonal with the vector 'tau',
* represent the ortogonal matrix Q as product of elementary reflectors.
* Matrix A is as returned by LQFactor()
*
* tau The vector of N scalar coefficients that together with trilu(A) define
* the ortogonal matrix Q as Q = H(N)H(N-1)...H(1)
*
* W Workspace, size required returned WorksizeMultLQ().
*
* flags Indicator flags
*
* conf Optinal blocking configuration. If not given default will be used. Unblocked
* invocation is indicated with conf.LB == 0.
*
* Compatible with lapack.GELS (the m < n part)
*/
func LQSolve(B, A, tau, W *cmat.FloatMatrix, flags int, confs ...*gomas.Config) *gomas.Error {
var err *gomas.Error = nil
var L, BL cmat.FloatMatrix
conf := gomas.CurrentConf(confs...)
wsmin := wsMultLQLeft(B, 0)
if W.Len() < wsmin {
return gomas.NewError(gomas.EWORK, "SolveLQ", wsmin)
}
if flags&gomas.TRANS != 0 {
// solve: MIN ||A.T*X - B||
// B' = Q.T*B
err = LQMult(B, A, tau, W, gomas.LEFT, conf)
if err != nil {
return err
}
// X = L.-1*B'
L.SubMatrix(A, 0, 0, m(A), m(A))
BL.SubMatrix(B, 0, 0, m(A), n(B))
err = blasd.SolveTrm(&BL, &L, 1.0, gomas.LEFT|gomas.LOWER|gomas.TRANSA, conf)
} else {
// Solve underdetermined system A*X = B
// B' = L.-1*B
L.SubMatrix(A, 0, 0, m(A), m(A))
BL.SubMatrix(B, 0, 0, m(A), n(B))
err = blasd.SolveTrm(&BL, &L, 1.0, gomas.LEFT|gomas.LOWER, conf)
// Clear bottom part of B
BL.SubMatrix(B, m(A), 0)
BL.SetFrom(cmat.NewFloatConstSource(0.0))
// X = Q.T*B'
err = LQMult(B, A, tau, W, gomas.LEFT|gomas.TRANS, conf)
}
return err
}
func TestCopy(t *testing.T) {
M := 9
N := 9
A := cmat.NewMatrix(M, N)
B := cmat.NewMatrix(M, N)
twos := cmat.NewFloatConstSource(2.0)
B.SetFrom(twos)
A.Copy(B)
ok := A.AllClose(B)
if !ok {
t.Logf("copy status: %v\n", ok)
if N < 9 {
t.Logf("A\n%v\n", A)
}
}
if N < 10 {
t.Logf("A\n%v\n", A)
}
}
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)
}
}
func TestSubMatrixCopy(t *testing.T) {
var subA, subB cmat.FloatMatrix
M := 9
N := 9
A := cmat.NewMatrix(M, N)
B := cmat.NewMatrix(M, N)
twos := cmat.NewFloatConstSource(2.0)
B.SetFrom(twos)
subA.SubMatrix(A, 1, 1, M-2, N-2)
subB.SubMatrix(B, 1, 1, M-2, N-2)
subA.Copy(&subB)
ok := subA.AllClose(&subB)
if !ok {
t.Logf("copy status: %v\n", ok)
if N < 9 {
t.Logf("subA\n%v\n", subA)
}
}
if N < 10 {
t.Logf("A\n%v\n", A)
}
}
// Simple and slow QR decomposition with Givens rotations
func TestGivensQR(t *testing.T) {
var d cmat.FloatMatrix
M := 181
N := 159
A := cmat.NewMatrix(M, N)
A1 := cmat.NewCopy(A)
ones := cmat.NewFloatConstSource(1.0)
src := cmat.NewFloatNormSource()
A.SetFrom(src)
A0 := cmat.NewCopy(A)
Qt := cmat.NewMatrix(M, M)
d.Diag(Qt)
d.SetFrom(ones)
// R = G(n)...G(2)G(1)*A; Q = G(1).T*G(2).T...G(n).T ; Q.T = G(n)...G(2)G(1)
// for all columns ...
for j := 0; j < N; j++ {
// ... zero elements below diagonal, starting from bottom
for i := M - 2; i >= j; i-- {
c, s, r := lapackd.ComputeGivens(A.Get(i, j), A.Get(i+1, j))
A.Set(i, j, r)
A.Set(i+1, j, 0.0)
// apply rotations on this row starting from column j, N-j column
lapackd.ApplyGivensLeft(A, i, i+1, j+1, N-j-1, c, s)
// update Qt = G(k)*Qt
lapackd.ApplyGivensLeft(Qt, i, i+1, 0, M, c, s)
}
}
// check: A = Q*R
blasd.Mult(A1, Qt, A, 1.0, 0.0, gomas.TRANSA)
blasd.Plus(A0, A1, 1.0, -1.0, gomas.NONE)
nrm := lapackd.NormP(A0, lapackd.NORM_ONE)
t.Logf("M=%d, N=%d ||A - G(n)..G(1)*R||_1: %e\n", M, N, nrm)
}