func runTest(A *matrix.FloatMatrix, ntest, LB int) time.Duration {
var mintime time.Duration
M := A.Rows()
N := A.Cols()
nN := N
if M < N {
nN = M
}
ipiv := make([]int, nN, nN)
fnc := func() {
_, ERRmatops = matops.DecomposeLU(A, ipiv, LB)
}
A0 := A.Copy()
for n := 0; n < ntest; n++ {
if n > 0 {
// restore original A
A0.CopyTo(A)
}
mperf.FlushCache()
time0 := mperf.Timeit(fnc)
if n == 0 || time0 < mintime {
mintime = time0
}
if verbose {
fmt.Printf("%.4f ms\n", time0.Seconds()*1000.0)
}
}
return mintime
}
func syrk2Test(t *testing.T, C, A, B *matrix.FloatMatrix, flags Flags, vlen, nb int) bool {
//var B0 *matrix.FloatMatrix
P := A.Cols()
S := 0
E := C.Rows()
C0 := C.Copy()
trans := linalg.OptNoTrans
if flags&TRANSA != 0 {
trans = linalg.OptTrans
P = A.Rows()
}
uplo := linalg.OptUpper
if flags&LOWER != 0 {
uplo = linalg.OptLower
}
blas.Syr2kFloat(A, B, C0, 1.0, 1.0, uplo, trans)
if A.Rows() < 8 {
//t.Logf("..A\n%v\n", A)
t.Logf(" BLAS C0:\n%v\n", C0)
}
Ar := A.FloatArray()
Br := B.FloatArray()
Cr := C.FloatArray()
DSymmRank2Blk(Cr, Ar, Br, 1.0, 1.0, flags, C.LeadingIndex(), A.LeadingIndex(),
B.LeadingIndex(), P, S, E, vlen, nb)
result := C0.AllClose(C)
t.Logf(" C0 == C: %v\n", result)
if A.Rows() < 8 {
t.Logf(" DMRank2 C:\n%v\n", C)
}
return result
}
func InverseTrm(A *matrix.FloatMatrix, flags Flags, nb int) (*matrix.FloatMatrix, error) {
var err error = nil
if nb == 0 || A.Cols() < nb {
if flags&UNIT != 0 {
if flags&LOWER != 0 {
err = unblockedInverseUnitLower(A)
} else {
err = unblockedInverseUnitUpper(A)
}
} else {
if flags&LOWER != 0 {
err = unblockedInverseLower(A)
} else {
err = unblockedInverseUpper(A)
}
}
} else {
if flags&LOWER != 0 {
err = blockedInverseLower(A, flags, nb)
} else {
err = blockedInverseUpper(A, flags, nb)
}
}
return A, err
}
func updateBlas(t *testing.T, Y1, Y2, C1, C2, T, W *matrix.FloatMatrix) {
if W.Rows() != C1.Cols() {
panic("W.Rows != C1.Cols")
}
// W = C1.T
ScalePlus(W, C1, 0.0, 1.0, TRANSB)
//fmt.Printf("W = C1.T:\n%v\n", W)
// W = C1.T*Y1
blas.TrmmFloat(Y1, W, 1.0, linalg.OptLower, linalg.OptUnit, linalg.OptRight)
t.Logf("W = C1.T*Y1:\n%v\n", W)
// W = W + C2.T*Y2
blas.GemmFloat(C2, Y2, W, 1.0, 1.0, linalg.OptTransA)
t.Logf("W = W + C2.T*Y2:\n%v\n", W)
// --- here: W == C.T*Y ---
// W = W*T
blas.TrmmFloat(T, W, 1.0, linalg.OptUpper, linalg.OptRight)
t.Logf("W = C.T*Y*T:\n%v\n", W)
// --- here: W == C.T*Y*T ---
// C2 = C2 - Y2*W.T
blas.GemmFloat(Y2, W, C2, -1, 1.0, linalg.OptTransB)
t.Logf("C2 = C2 - Y2*W.T:\n%v\n", C2)
// W = Y1*W.T ==> W.T = W*Y1.T
blas.TrmmFloat(Y1, W, 1.0, linalg.OptLower,
linalg.OptUnit, linalg.OptRight, linalg.OptTrans)
t.Logf("W.T = W*Y1.T:\n%v\n", W)
// C1 = C1 - W.T
ScalePlus(C1, W, 1.0, -1.0, TRANSB)
//fmt.Printf("C1 = C1 - W.T:\n%v\n", C1)
// --- here: C = (I - Y*T*Y.T).T * C ---
}
// Swap X and Y.
func Swap(X, Y *matrix.FloatMatrix) {
if X == nil || Y == nil {
return
}
if X.NumElements() == 0 || Y.NumElements() == 0 {
return
}
if !isVector(X) {
return
}
if !isVector(Y) {
return
}
Xr := X.FloatArray()
incX := 1
if X.Cols() != 1 {
// Row vector
incX = X.LeadingIndex()
}
Yr := Y.FloatArray()
incY := 1
if Y.Cols() != 1 {
// Row vector
incY = Y.LeadingIndex()
}
calgo.DSwap(Xr, Yr, incX, incY, X.NumElements())
}
// Y := alpha * X + Y
func Axpy(Y, X *matrix.FloatMatrix, alpha float64) {
if X == nil || Y == nil {
return
}
if !isVector(X) {
return
}
if !isVector(Y) {
return
}
Xr := X.FloatArray()
incX := 1
if X.Cols() != 1 {
// Row vector
incX = X.LeadingIndex()
}
Yr := Y.FloatArray()
incY := 1
if Y.Cols() != 1 {
// Row vector
incY = Y.LeadingIndex()
}
calgo.DAxpy(Xr, Yr, alpha, incX, incY, X.NumElements())
return
}
func runTest(A *matrix.FloatMatrix, ntest, LB int) time.Duration {
var W *matrix.FloatMatrix = nil
var mintime time.Duration
N := A.Cols()
tau := matrix.FloatZeros(N, 1)
if LB > 0 {
W = matrix.FloatZeros(A.Rows(), LB)
}
fnc := func() {
_, ERRmatops = matops.DecomposeQR(A, tau, W, LB)
}
A0 := A.Copy()
for n := 0; n < ntest; n++ {
if n > 0 {
// restore original A
A0.CopyTo(A)
tau.Scale(0.0)
}
mperf.FlushCache()
time0 := mperf.Timeit(fnc)
if n == 0 || time0 < mintime {
mintime = time0
}
if verbose {
fmt.Printf("%.4f ms\n", time0.Seconds()*1000.0)
}
}
return mintime
}
func runRefTest(A *matrix.FloatMatrix, ntest, LB int) time.Duration {
var mintime time.Duration
N := A.Cols()
tau := matrix.FloatZeros(N, 1)
fnc := func() {
ERRlapack = lapack.Geqrf(A, tau)
}
A0 := A.Copy()
for n := 0; n < ntest; n++ {
if n > 0 {
// restore original A
A0.CopyTo(A)
tau.Scale(0.0)
}
mperf.FlushCache()
time0 := mperf.Timeit(fnc)
if n == 0 || time0 < mintime {
mintime = time0
}
}
return mintime
}
// In-place version of pack(), which also accepts matrix arguments x.
// The columns of x are elements of S, with the 's' components stored
// in unpacked storage. On return, the 's' components are stored in
// packed storage and the off-diagonal entries are scaled by sqrt(2).
//
func pack2(x *matrix.FloatMatrix, dims *sets.DimensionSet, mnl int) (err error) {
if len(dims.At("s")) == 0 {
return nil
}
const sqrt2 = 1.41421356237309504880
iu := mnl + dims.Sum("l", "q")
ip := iu
row := matrix.FloatZeros(1, x.Cols())
//fmt.Printf("x.size = %d %d\n", x.Rows(), x.Cols())
for _, n := range dims.At("s") {
for k := 0; k < n; k++ {
cnt := n - k
row = x.GetRow(iu+(n+1)*k, row)
//fmt.Printf("%02d: %v\n", iu+(n+1)*k, x.FloatArray())
x.SetRow(ip, row)
for i := 1; i < n-k; i++ {
row = x.GetRow(iu+(n+1)*k+i, row)
//fmt.Printf("%02d: %v\n", iu+(n+1)*k+i, x.FloatArray())
x.SetRow(ip+i, row.Scale(sqrt2))
}
ip += cnt
}
iu += n * n
}
return nil
}
/*
Matrix-vector multiplication.
A is a matrix or spmatrix of size (m, n) where
N = dims['l'] + sum(dims['q']) + sum( k**2 for k in dims['s'] )
representing a mapping from R^n to S.
If trans is 'N':
y := alpha*A*x + beta * y (trans = 'N').
x is a vector of length n. y is a vector of length N.
If trans is 'T':
y := alpha*A'*x + beta * y (trans = 'T').
x is a vector of length N. y is a vector of length n.
The 's' components in S are stored in unpacked 'L' storage.
*/
func sgemv(A, x, y *matrix.FloatMatrix, alpha, beta float64, dims *sets.DimensionSet, opts ...la_.Option) error {
m := dims.Sum("l", "q") + dims.SumSquared("s")
n := la_.GetIntOpt("n", -1, opts...)
if n == -1 {
n = A.Cols()
}
trans := la_.GetIntOpt("trans", int(la_.PNoTrans), opts...)
offsetX := la_.GetIntOpt("offsetx", 0, opts...)
offsetY := la_.GetIntOpt("offsety", 0, opts...)
offsetA := la_.GetIntOpt("offseta", 0, opts...)
if trans == int(la_.PTrans) && alpha != 0.0 {
trisc(x, dims, offsetX)
//fmt.Printf("trisc x=\n%v\n", x.ConvertToString())
}
//fmt.Printf("alpha=%.4f beta=%.4f m=%d n=%d\n", alpha, beta, m, n)
//fmt.Printf("A=\n%v\nx=\n%v\ny=\n%v\n", A, x.ConvertToString(), y.ConvertToString())
err := blas.GemvFloat(A, x, y, alpha, beta, &la_.IOpt{"trans", trans},
&la_.IOpt{"n", n}, &la_.IOpt{"m", m}, &la_.IOpt{"offseta", offsetA},
&la_.IOpt{"offsetx", offsetX}, &la_.IOpt{"offsety", offsetY})
//fmt.Printf("gemv y=\n%v\n", y.ConvertToString())
if trans == int(la_.PTrans) && alpha != 0.0 {
triusc(x, dims, offsetX)
}
return err
}
func Mult0(C, A, B *matrix.FloatMatrix, alpha, beta float64, flags Flags) error {
if A.Cols() != B.Rows() {
return errors.New("A.cols != B.rows: size mismatch")
}
psize := int64(C.NumElements()) * int64(A.Cols())
Ar := A.FloatArray()
ldA := A.LeadingIndex()
Br := B.FloatArray()
ldB := B.LeadingIndex()
Cr := C.FloatArray()
ldC := C.LeadingIndex()
if nWorker <= 1 || psize <= limitOne {
calgo.DMult0(Cr, Ar, Br, alpha, beta, calgo.Flags(flags), ldC, ldA, ldB, B.Rows(),
0, C.Cols(), 0, C.Rows(),
vpLen, nB, mB)
return nil
}
// here we have more than one worker available
worker := func(cstart, cend, rstart, rend int, ready chan int) {
calgo.DMult0(Cr, Ar, Br, alpha, beta, calgo.Flags(flags), ldC, ldA, ldB, B.Rows(),
cstart, cend, rstart, rend, vpLen, nB, mB)
ready <- 1
}
colworks, rowworks := divideWork(C.Rows(), C.Cols(), nWorker)
scheduleWork(colworks, rowworks, C.Cols(), C.Rows(), worker)
return nil
}
func trmvTest(t *testing.T, A *matrix.FloatMatrix, flags Flags, nb int) bool {
N := A.Cols()
//S := 0
//E := A.Cols()
X0 := matrix.FloatWithValue(A.Rows(), 1, 2.0)
X1 := X0.Copy()
trans := linalg.OptNoTrans
if flags&TRANS != 0 {
trans = linalg.OptTrans
}
diag := linalg.OptNonUnit
if flags&UNIT != 0 {
diag = linalg.OptUnit
}
uplo := linalg.OptUpper
if flags&LOWER != 0 {
uplo = linalg.OptLower
}
blas.TrmvFloat(A, X0, uplo, diag, trans)
Ar := A.FloatArray()
Xr := X1.FloatArray()
if nb == 0 {
DTrimvUnblkMV(Xr, Ar, flags, 1, A.LeadingIndex(), N)
}
result := X0.AllClose(X1)
t.Logf(" X0 == X1: %v\n", result)
if !result && A.Rows() < 8 {
t.Logf(" BLAS TRMV X0:\n%v\n", X0)
t.Logf(" DTrmv X1:\n%v\n", X1)
}
return result
}
func runRefTest(A *matrix.FloatMatrix, ntest, LB int) time.Duration {
var mintime time.Duration
M := A.Rows()
N := A.Cols()
nN := N
if M < N {
nN = M
}
ipiv := make([]int32, nN, nN)
fnc := func() {
ERRlapack = lapack.Getrf(A, ipiv)
}
A0 := A.Copy()
for n := 0; n < ntest; n++ {
if n > 0 {
// restore original A
A0.CopyTo(A)
}
mperf.FlushCache()
time0 := mperf.Timeit(fnc)
if n == 0 || time0 < mintime {
mintime = time0
}
}
return mintime
}
// Generic matrix-matrix multpily. (blas.GEMM). Calculates
// C = beta*C + alpha*A*B (default)
// C = beta*C + alpha*A.T*B flags&TRANSA
// C = beta*C + alpha*A*B.T flags&TRANSB
// C = beta*C + alpha*A.T*B.T flags&(TRANSA|TRANSB)
//
// C is M*N, A is M*P or P*M if flags&TRANSA. B is P*N or N*P if flags&TRANSB.
//
func Mult(C, A, B *matrix.FloatMatrix, alpha, beta float64, flags Flags) error {
var ok, empty bool
// error checking must take in account flag values!
ar, ac := A.Size()
br, bc := B.Size()
cr, cc := C.Size()
switch flags & (TRANSA | TRANSB) {
case TRANSA | TRANSB:
empty = ac == 0 || br == 0
ok = cr == ac && cc == br && ar == bc
case TRANSA:
empty = ac == 0 || bc == 0
ok = cr == ac && cc == bc && ar == br
case TRANSB:
empty = ar == 0 || br == 0
ok = cr == ar && cc == br && ac == bc
default:
empty = ar == 0 || bc == 0
ok = cr == ar && cc == bc && ac == br
}
if empty {
return nil
}
if !ok {
return errors.New("Mult: size mismatch")
}
psize := int64(C.NumElements()) * int64(A.Cols())
Ar := A.FloatArray()
ldA := A.LeadingIndex()
Br := B.FloatArray()
ldB := B.LeadingIndex()
Cr := C.FloatArray()
ldC := C.LeadingIndex()
// matrix A, B common dimension
P := A.Cols()
if flags&TRANSA != 0 {
P = A.Rows()
}
if nWorker <= 1 || psize <= limitOne {
calgo.DMult(Cr, Ar, Br, alpha, beta, calgo.Flags(flags), ldC, ldA, ldB, P,
0, C.Cols(), 0, C.Rows(),
vpLen, nB, mB)
return nil
}
// here we have more than one worker available
worker := func(cstart, cend, rstart, rend int, ready chan int) {
calgo.DMult(Cr, Ar, Br, alpha, beta, calgo.Flags(flags), ldC, ldA, ldB, P,
cstart, cend, rstart, rend, vpLen, nB, mB)
ready <- 1
}
colworks, rowworks := divideWork(C.Rows(), C.Cols(), nWorker)
scheduleWork(colworks, rowworks, C.Cols(), C.Rows(), worker)
return nil
}
/*
* like LAPACK/dlafrt.f
*
* Build block reflector T from HH reflector stored in TriLU(A) and coefficients
* in tau.
*
* Q = I - Y*T*Y.T; Householder H = I - tau*v*v.T
*
* T = | T z | z = -tau*T*Y.T*v
* | 0 c | c = tau
*
* Q = H(1)H(2)...H(k) building forward here.
*/
func unblkQRBlockReflector(T, A, tau *matrix.FloatMatrix) {
var ATL, ATR, ABL, ABR matrix.FloatMatrix
var A00, a10, a11, A20, a21, A22 matrix.FloatMatrix
var TTL, TTR, TBL, TBR matrix.FloatMatrix
var T00, t01, T02, t11, t12, T22 matrix.FloatMatrix
var tT, tB matrix.FloatMatrix
var t0, tau1, t2 matrix.FloatMatrix
partition2x2(
&ATL, &ATR,
&ABL, &ABR, A, 0, 0, pTOPLEFT)
partition2x2(
&TTL, &TTR,
&TBL, &TBR, T, 0, 0, pTOPLEFT)
partition2x1(
&tT,
&tB, tau, 0, pTOP)
for ABR.Rows() > 0 && ABR.Cols() > 0 {
repartition2x2to3x3(&ATL,
&A00, nil, nil,
&a10, &a11, nil,
&A20, &a21, &A22, A, 1, pBOTTOMRIGHT)
repartition2x2to3x3(&TTL,
&T00, &t01, &T02,
nil, &t11, &t12,
nil, nil, &T22, T, 1, pBOTTOMRIGHT)
repartition2x1to3x1(&tT,
&t0,
&tau1,
&t2, tau, 1, pBOTTOM)
// --------------------------------------------------
// t11 := tau
tauval := tau1.GetAt(0, 0)
if tauval != 0.0 {
t11.SetAt(0, 0, tauval)
// t01 := a10.T + &A20.T*a21
a10.CopyTo(&t01)
MVMult(&t01, &A20, &a21, -tauval, -tauval, TRANSA)
// t01 := T00*t01
MVMultTrm(&t01, &T00, UPPER)
//t01.Scale(-tauval)
}
// --------------------------------------------------
continue3x3to2x2(
&ATL, &ATR,
&ABL, &ABR, &A00, &a11, &A22, A, pBOTTOMRIGHT)
continue3x3to2x2(
&TTL, &TTR,
&TBL, &TBR, &T00, &t11, &T22, T, pBOTTOMRIGHT)
continue3x1to2x1(
&tT,
&tB, &t0, &tau1, tau, pBOTTOM)
}
}
func blockedBuildQT(A, T, W *matrix.FloatMatrix, nb int) error {
var err error = nil
var ATL, ATR, ABL, ABR, AL matrix.FloatMatrix
var A00, A01, A11, A12, A21, A22 matrix.FloatMatrix
var TTL, TTR, TBL, TBR matrix.FloatMatrix
var T00, T01, T02, T11, T12, T22 matrix.FloatMatrix
var tau1, Wrk matrix.FloatMatrix
var mb int
mb = A.Rows() - A.Cols()
partition2x2(
&ATL, &ATR,
&ABL, &ABR, A, mb, 0, pBOTTOMRIGHT)
partition2x2(
&TTL, &TTR,
&TBL, &TBR, T, 0, 0, pBOTTOMRIGHT)
// clearing of the columns of the right and setting ABR to unit diagonal
// (only if not applying all reflectors, kb > 0)
for ATL.Rows() > 0 && ATL.Cols() > 0 {
repartition2x2to3x3(&ATL,
&A00, &A01, nil,
nil, &A11, &A12,
nil, &A21, &A22, A, nb, pTOPLEFT)
repartition2x2to3x3(&TTL,
&T00, &T01, &T02,
nil, &T11, &T12,
nil, nil, &T22, T, nb, pTOPLEFT)
// --------------------------------------------------------
// update with current block reflector (I - Y*T*Y.T)*Atrailing
W.SubMatrix(&Wrk, 0, 0, A12.Cols(), A11.Cols())
updateWithQT(&A12, &A22, &A11, &A21, &T11, &Wrk, nb, false)
// use unblocked version to compute current block
W.SubMatrix(&Wrk, 0, 0, 1, A11.Cols())
// elementary scalar coefficients on the diagonal, column vector
T11.Diag(&tau1)
merge2x1(&AL, &A11, &A21)
// do an unblocked update to current block
unblockedBuildQ(&AL, &tau1, &Wrk, 0)
// zero upper part
A01.SetIndexes(0.0)
// --------------------------------------------------------
continue3x3to2x2(
&ATL, &ATR,
&ABL, &ABR, &A00, &A11, &A22, A, pTOPLEFT)
continue3x3to2x2(
&TTL, &TTR,
&TBL, &TBR, &T00, &T11, &T22, T, pTOPLEFT)
}
return err
}
func swapRows(A *matrix.FloatMatrix, src, dst int) {
var r0, r1 matrix.FloatMatrix
if src == dst || A.Rows() == 0 {
return
}
A.SubMatrix(&r0, src, 0, 1, A.Cols())
A.SubMatrix(&r1, dst, 0, 1, A.Cols())
Swap(&r0, &r1)
}
/*
* Compute an LU factorization of a general M-by-N matrix without pivoting.
*
* Arguments:
* A On entry, the M-by-N matrix to be factored. On exit the factors
* L and U from factorization A = P*L*U, the unit diagonal elements
* of L are not stored.
*
* nb Blocking factor for blocked invocations. If bn == 0 or
* min(M,N) < nb unblocked algorithm is used.
*
* Returns:
* LU factorization and error indicator.
*
* Compatible with lapack.DGETRF
*/
func DecomposeLUnoPiv(A *matrix.FloatMatrix, nb int) (*matrix.FloatMatrix, error) {
var err error
mlen := imin(A.Rows(), A.Cols())
if mlen <= nb || nb == 0 {
err = unblockedLUnoPiv(A)
} else {
err = blockedLUnoPiv(A, nb)
}
return A, err
}
func columnDiffs(A, B *matrix.FloatMatrix) *matrix.FloatMatrix {
var c matrix.FloatMatrix
nrm := matrix.FloatZeros(A.Cols(), 1)
A0 := A.Copy()
A0.Minus(B)
for k := 0; k < A.Cols(); k++ {
A0.SubMatrix(&c, 0, k, A.Rows(), 1)
nrm.SetAt(k, 0, matops.Norm2(&c))
}
return nrm
}
func rowDiffs(A, B *matrix.FloatMatrix) *matrix.FloatMatrix {
var r matrix.FloatMatrix
nrm := matrix.FloatZeros(A.Rows(), 1)
A0 := A.Copy()
A0.Minus(B)
for k := 0; k < A.Rows(); k++ {
A0.SubMatrix(&r, k, 0, 1, A.Cols())
nrm.SetAt(k, 0, matops.Norm2(&r))
}
return nrm
}
func mNormInf(A *matrix.FloatMatrix) float64 {
var amax float64 = 0.0
var row matrix.FloatMatrix
for k := 0; k < A.Rows(); k++ {
row.SubMatrixOf(A, k, 0, A.Cols(), 1)
rmax := ASum(&row)
if rmax > amax {
amax = rmax
}
}
return amax
}
func mNorm1(A *matrix.FloatMatrix) float64 {
var amax float64 = 0.0
var col matrix.FloatMatrix
for k := 0; k < A.Cols(); k++ {
col.SubMatrixOf(A, 0, k, A.Rows(), 1)
cmax := ASum(&col)
if cmax > amax {
amax = cmax
}
}
return amax
}
/*
* Compute the Cholesky factorization of a symmetric positive definite
* N-by-N matrix A.
*
* Arguments:
* A On entry, the symmetric matrix A. If flags&UPPER the upper triangular part
* of A contains the upper triangular part of the matrix A, and strictly
* lower part A is not referenced. If flags&LOWER the lower triangular part
* of a contains the lower triangular part of the matrix A. Likewise, the
* strictly upper part of A is not referenced. On exit, factor U or L from the
* Cholesky factorization A = U.T*U or A = L*L.T
*
* flags The matrix structure indicator, UPPER for upper tridiagonal and LOWER for
* lower tridiagonal matrix.
*
* nb The blocking factor for blocked invocations. If nb == 0 or N < nb unblocked
* algorithm is used.
*
* Compatible with lapack.DPOTRF
*/
func DecomposeCHOL(A *matrix.FloatMatrix, flags Flags, nb int) (*matrix.FloatMatrix, error) {
var err error
if A.Cols() != A.Rows() {
return A, errors.New("A not a square matrix")
}
if A.Cols() < nb || nb == 0 {
err = unblockedCHOL(A, flags, 0)
} else {
err = blockedCHOL(A, flags, nb)
}
return A, err
}
// Make A tridiagonal, lower, non-unit matrix by clearing the strictly upper part
// of the matrix.
func TriL(A *matrix.FloatMatrix) *matrix.FloatMatrix {
var Ac matrix.FloatMatrix
mlen := imin(A.Rows(), A.Cols())
for k := 1; k < mlen; k++ {
Ac.SubMatrixOf(A, 0, k, k, 1)
Ac.SetIndexes(0.0)
}
if A.Cols() > A.Rows() {
Ac.SubMatrixOf(A, 0, A.Rows())
Ac.SetIndexes(0.0)
}
return A
}
/*
Partition A to 1 by 2 blocks.
A --> AL | AR
Parameter nb is initial block size for AL (pLEFT) or AR (pRIGHT).
*/
func partition1x2(AL, AR, A *matrix.FloatMatrix, nb int, side pDirection) {
if nb > A.Cols() {
nb = A.Cols()
}
switch side {
case pLEFT:
A.SubMatrix(AL, 0, 0, A.Rows(), nb)
A.SubMatrix(AR, 0, nb, A.Rows(), A.Cols()-nb)
case pRIGHT:
A.SubMatrix(AL, 0, 0, A.Rows(), A.Cols()-nb)
A.SubMatrix(AR, 0, A.Cols()-nb, A.Rows(), nb)
}
}
// A = alpha*A + beta*B
// A = alpha*A + beta*B.T if flags&TRANSB
func ScalePlus(A, B *matrix.FloatMatrix, alpha, beta float64, flags Flags) error {
Ar := A.FloatArray()
ldA := A.LeadingIndex()
Br := B.FloatArray()
ldB := B.LeadingIndex()
S := 0
L := A.Cols()
R := 0
E := A.Rows()
calgo.DScalePlus(Ar, Br, alpha, beta, calgo.Flags(flags), ldA, ldB, S, L, R, E)
return nil
}
// single invocation for matops and lapack functions
func runCheck(A *matrix.FloatMatrix, LB int) (bool, time.Duration, time.Duration) {
M := A.Rows()
N := A.Cols()
nN := N
if M < N {
nN = M
}
ipiv := make([]int, nN, nN)
ipiv0 := make([]int32, nN, nN)
fnc := func() {
_, ERRmatops = matops.DecomposeLU(A, ipiv, LB)
}
if verbose && N < 10 {
fmt.Fprintf(os.Stderr, "A start:\n%v\n", A)
}
A0 := A.Copy()
mperf.FlushCache()
time0 := mperf.Timeit(fnc)
if verbose && N < 10 {
fmt.Fprintf(os.Stderr, "A end:\n%v\n", A)
fmt.Fprintf(os.Stderr, "ipiv:%v\n", ipiv)
}
fn2 := func() {
ERRlapack = lapack.Getrf(A0, ipiv0)
}
if verbose && N < 10 {
fmt.Fprintf(os.Stderr, "A0 start:\n%v\n", A0)
}
mperf.FlushCache()
time2 := mperf.Timeit(fn2)
if verbose && N < 10 {
fmt.Fprintf(os.Stderr, "A0 end:\n%v\n", A0)
fmt.Fprintf(os.Stderr, "ipiv0:%v\n", ipiv0)
}
// now A == A0 && ipiv == ipiv0
ok := A.AllClose(A0)
okip := checkIPIV(ipiv, ipiv0)
_ = okip
if !ok || !okip {
// save result to globals
Rlapack = A0
Rmatops = A
IPIVlapack = ipiv0
IPIVmatops = ipiv
}
return ok && okip, time0, time2
}
// Matrix-vector rank update A = A + alpha*X*Y.T
// A is M*N generic matrix,
// X is row or column vector of length M
// Y is row or column vector of legth N.
func MVRankUpdate(A, X, Y *matrix.FloatMatrix, alpha float64) error {
if A.Rows() == 0 || A.Cols() == 0 {
return nil
}
if Y.Rows() != 1 && Y.Cols() != 1 {
return errors.New("Y not a vector.")
}
if X.Rows() != 1 && X.Cols() != 1 {
return errors.New("X not a vector.")
}
Ar := A.FloatArray()
ldA := A.LeadingIndex()
Yr := Y.FloatArray()
incY := 1
if Y.Rows() == 1 {
// row vector
incY = Y.LeadingIndex()
}
Xr := X.FloatArray()
incX := 1
if X.Rows() == 1 {
// row vector
incX = X.LeadingIndex()
}
// NOTE: This could diveded to parallel tasks like matrix-matrix multiplication
calgo.DRankMV(Ar, Xr, Yr, alpha, ldA, incX, incY, 0, A.Cols(), 0, A.Rows(), 0, 0)
return nil
}
/*
* Unblocked QR decomposition with block reflector T.
*/
func unblockedQRT(A, T *matrix.FloatMatrix) {
var ATL, ATR, ABL, ABR matrix.FloatMatrix
var A00, a10, a11, a12, A20, a21, A22 matrix.FloatMatrix
var TTL, TTR, TBL, TBR matrix.FloatMatrix
var T00, t01, T02, t11, t12, T22 matrix.FloatMatrix
//As.SubMatrixOf(A, 0, 0, mlen, nb)
partition2x2(
&ATL, &ATR,
&ABL, &ABR, A, 0, 0, pTOPLEFT)
partition2x2(
&TTL, &TTR,
&TBL, &TBR, T, 0, 0, pTOPLEFT)
for ABR.Rows() > 0 && ABR.Cols() > 0 {
repartition2x2to3x3(&ATL,
&A00, nil, nil,
&a10, &a11, &a12,
&A20, &a21, &A22, A, 1, pBOTTOMRIGHT)
repartition2x2to3x3(&TTL,
&T00, &t01, &T02,
nil, &t11, &t12,
nil, nil, &T22, T, 1, pBOTTOMRIGHT)
// ------------------------------------------------------
computeHouseholder(&a11, &a21, &t11, LEFT)
// H*[a12 A22].T
applyHouseholder(&t11, &a21, &a12, &A22, LEFT)
// update T
tauval := t11.GetAt(0, 0)
if tauval != 0.0 {
// t01 := -tauval*(a10.T + &A20.T*a21)
a10.CopyTo(&t01)
MVMult(&t01, &A20, &a21, -tauval, -tauval, TRANSA)
// t01 := T00*t01
MVMultTrm(&t01, &T00, UPPER)
}
// ------------------------------------------------------
continue3x3to2x2(
&ATL, &ATR,
&ABL, &ABR, &A00, &a11, &A22, A, pBOTTOMRIGHT)
continue3x3to2x2(
&TTL, &TTR,
&TBL, &TBR, &T00, &t11, &T22, T, pBOTTOMRIGHT)
}
}
func createGpProg(K []int, F, g *matrix.FloatMatrix) *gpConvexProg {
gp := &gpConvexProg{mnl: len(K) - 1, l: F.Rows(), n: F.Cols()}
gp.ind = make([][2]int, len(K))
s := 0
for i := 0; i < len(K); i++ {
gp.ind[i][0] = s
gp.ind[i][1] = s + K[i]
s += K[i]
}
gp.F = F
gp.g = g
gp.maxK = maxdim(K)
return gp
}
