// See function Trsm.
func TrsmFloat(A, B *matrix.FloatMatrix, alpha float64, opts ...linalg.Option) (err error) {
params, e := linalg.GetParameters(opts...)
if e != nil {
err = e
return
}
ind := linalg.GetIndexOpts(opts...)
err = check_level3_func(ind, ftrsm, A, B, nil, params)
if err != nil {
return
}
if ind.N == 0 || ind.M == 0 {
return
}
Aa := A.FloatArray()
Ba := B.FloatArray()
uplo := linalg.ParamString(params.Uplo)
transA := linalg.ParamString(params.TransA)
side := linalg.ParamString(params.Side)
diag := linalg.ParamString(params.Diag)
dtrsm(side, uplo, transA, diag, ind.M, ind.N, alpha,
Aa[ind.OffsetA:], ind.LDa, Ba[ind.OffsetB:], ind.LDb)
return
}
func GbtrsFloat(A, B *matrix.FloatMatrix, ipiv []int32, KL int, opts ...linalg.Option) error {
pars, err := linalg.GetParameters(opts...)
if err != nil {
return err
}
ind := linalg.GetIndexOpts(opts...)
ind.Kl = KL
err = checkGbtrs(ind, A, B, ipiv)
if err != nil {
return err
}
if ind.N == 0 || ind.Nrhs == 0 {
return nil
}
Aa := A.FloatArray()
Ba := B.FloatArray()
trans := linalg.ParamString(pars.Trans)
info := dgbtrs(trans, ind.N, ind.Kl, ind.Ku, ind.Nrhs,
Aa[ind.OffsetA:], ind.LDa, ipiv, Ba[ind.OffsetB:], ind.LDb)
if info != 0 {
return onError(fmt.Sprintf("Gbtrs: lapack error: %d", info))
}
return nil
}
// See function Syrk.
func SyrkFloat(A, C *matrix.FloatMatrix, alpha, beta float64, opts ...linalg.Option) (err error) {
params, e := linalg.GetParameters(opts...)
if e != nil {
err = e
return
}
ind := linalg.GetIndexOpts(opts...)
err = check_level3_func(ind, fsyrk, A, nil, C, params)
if e != nil || err != nil {
return
}
if ind.N == 0 {
return
}
Aa := A.FloatArray()
Ca := C.FloatArray()
uplo := linalg.ParamString(params.Uplo)
trans := linalg.ParamString(params.Trans)
//diag := linalg.ParamString(params.Diag)
dsyrk(uplo, trans, ind.N, ind.K, alpha, Aa[ind.OffsetA:], ind.LDa, beta,
Ca[ind.OffsetC:], ind.LDc)
return
}
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)
}
}
// Solve multiple right sides. If flags&UNIT then A diagonal is assumed to
// to unit and is not referenced. (blas.TRSM)
// alpha*B = A.-1*B if flags&LEFT
// alpha*B = A.-T*B if flags&(LEFT|TRANS)
// alpha*B = B*A.-1 if flags&RIGHT
// alpha*B = B*A.-T if flags&(RIGHT|TRANS)
//
// Matrix A is N*N triangular matrix defined with flags bits as follow
// LOWER non-unit lower triangular
// LOWER|UNIT unit lower triangular
// UPPER non-unit upper triangular
// UPPER|UNIT unit upper triangular
//
// Matrix B is N*P if flags&LEFT or P*N if flags&RIGHT.
//
func SolveTrm(B, A *matrix.FloatMatrix, alpha float64, flags Flags) error {
ok := true
empty := false
br, bc := B.Size()
ar, ac := A.Size()
switch flags & (LEFT | RIGHT) {
case LEFT:
empty = br == 0
ok = br == ac && ac == ar
case RIGHT:
empty = bc == 0
ok = bc == ar && ac == ar
}
if empty {
return nil
}
if !ok {
return onError("A, B size mismatch")
}
Ar := A.FloatArray()
ldA := A.LeadingIndex()
Br := B.FloatArray()
ldB := B.LeadingIndex()
E := bc
if flags&RIGHT != 0 {
E = br
}
// if more workers available can divide to tasks by B columns if flags&LEFT or by
// B rows if flags&RIGHT.
calgo.DSolveBlk(Br, Ar, alpha, calgo.Flags(flags), ldB, ldA, ac, 0, E, nB)
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 syrkTest(t *testing.T, C, A *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.SyrkFloat(A, 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()
Cr := C.FloatArray()
DSymmRankBlk(Cr, Ar, 1.0, 1.0, flags, C.LeadingIndex(), A.LeadingIndex(),
P, S, E, vlen, nb)
result := C0.AllClose(C)
t.Logf(" C0 == C: %v\n", result)
if A.Rows() < 8 {
t.Logf(" DMRank C:\n%v\n", C)
}
return result
}
func (p *floorPlan) F2(x, z *matrix.FloatMatrix) (f, Df, H *matrix.FloatMatrix, err error) {
f, Df, err = p.F1(x)
x17 := matrix.FloatVector(x.FloatArray()[17:])
tmp := matrix.Div(p.Amin, matrix.Pow(x17, 3.0))
tmp = matrix.Mul(z, tmp).Scale(2.0)
diag := matrix.FloatDiagonal(5, tmp.FloatArray()...)
H = matrix.FloatZeros(22, 22)
H.SetSubMatrix(17, 17, diag)
return
}
func sinv(x, y *matrix.FloatMatrix, dims *sets.DimensionSet, mnl int) (err error) {
/*DEBUGGED*/
err = nil
// For the nonlinear and 'l' blocks:
//
// yk o\ xk = yk .\ xk.
ind := mnl + dims.At("l")[0]
blas.Tbsv(y, x, &la_.IOpt{"n", ind}, &la_.IOpt{"k", 0}, &la_.IOpt{"ldA", 1})
// For the 'q' blocks:
//
// [ l0 -l1' ]
// yk o\ xk = 1/a^2 * [ ] * xk
// [ -l1 (a*I + l1*l1')/l0 ]
//
// where yk = (l0, l1) and a = l0^2 - l1'*l1.
for _, m := range dims.At("q") {
aa := blas.Nrm2Float(y, &la_.IOpt{"n", m - 1}, &la_.IOpt{"offset", ind + 1})
ee := y.GetIndex(ind)
aa = (ee + aa) * (ee - aa)
cc := x.GetIndex(ind)
dd := blas.DotFloat(x, y, &la_.IOpt{"n", m - 1}, &la_.IOpt{"offsetx", ind + 1},
&la_.IOpt{"offsety", ind + 1})
x.SetIndex(ind, cc*ee-dd)
blas.ScalFloat(x, aa/ee, &la_.IOpt{"n", m - 1}, &la_.IOpt{"offset", ind + 1})
blas.AxpyFloat(y, x, dd/ee-cc, &la_.IOpt{"n", m - 1},
&la_.IOpt{"offsetx", ind + 1}, &la_.IOpt{"offsety", ind + 1})
blas.ScalFloat(x, 1.0/aa, &la_.IOpt{"n", m}, &la_.IOpt{"offset", ind})
ind += m
}
// For the 's' blocks:
//
// yk o\ xk = xk ./ gamma
//
// where gammaij = .5 * (yk_i + yk_j).
ind2 := ind
for _, m := range dims.At("s") {
for j := 0; j < m; j++ {
u := matrix.FloatVector(y.FloatArray()[ind2+j : ind2+m])
u.Add(y.GetIndex(ind2 + j))
u.Scale(0.5)
blas.Tbsv(u, x, &la_.IOpt{"n", m - j}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1},
&la_.IOpt{"offsetx", ind + j*(m+1)})
}
ind += m * m
ind2 += m
}
return
}
// Returns min {t | x + t*e >= 0}, where e is defined as follows
//
// - For the nonlinear and 'l' blocks: e is the vector of ones.
// - For the 'q' blocks: e is the first unit vector.
// - For the 's' blocks: e is the identity matrix.
//
// When called with the argument sigma, also returns the eigenvalues
// (in sigma) and the eigenvectors (in x) of the 's' components of x.
func maxStep(x *matrix.FloatMatrix, dims *sets.DimensionSet, mnl int, sigma *matrix.FloatMatrix) (rval float64, err error) {
/*DEBUGGED*/
rval = 0.0
err = nil
t := make([]float64, 0, 10)
ind := mnl + dims.Sum("l")
if ind > 0 {
t = append(t, -minvec(x.FloatArray()[:ind]))
}
for _, m := range dims.At("q") {
if m > 0 {
v := blas.Nrm2Float(x, &la_.IOpt{"offset", ind + 1}, &la_.IOpt{"n", m - 1})
v -= x.GetIndex(ind)
t = append(t, v)
}
ind += m
}
//var Q *matrix.FloatMatrix
//var w *matrix.FloatMatrix
ind2 := 0
//if sigma == nil && len(dims.At("s")) > 0 {
// mx := dims.Max("s")
// Q = matrix.FloatZeros(mx, mx)
// w = matrix.FloatZeros(mx, 1)
//}
for _, m := range dims.At("s") {
if sigma == nil {
Q := matrix.FloatZeros(m, m)
w := matrix.FloatZeros(m, 1)
blas.Copy(x, Q, &la_.IOpt{"offsetx", ind}, &la_.IOpt{"n", m * m})
err = lapack.SyevrFloat(Q, w, nil, 0.0, nil, []int{1, 1}, la_.OptRangeInt,
&la_.IOpt{"n", m}, &la_.IOpt{"lda", m})
if m > 0 && err == nil {
t = append(t, -w.GetIndex(0))
}
} else {
err = lapack.SyevdFloat(x, sigma, la_.OptJobZValue, &la_.IOpt{"n", m},
&la_.IOpt{"lda", m}, &la_.IOpt{"offseta", ind}, &la_.IOpt{"offsetw", ind2})
if m > 0 {
t = append(t, -sigma.GetIndex(ind2))
}
}
ind += m * m
ind2 += m
}
if len(t) > 0 {
rval = maxvec(t)
}
return
}
// See function Scal.
func ScalFloat(X *matrix.FloatMatrix, alpha float64, opts ...linalg.Option) (err error) {
ind := linalg.GetIndexOpts(opts...)
err = check_level1_func(ind, fscal, X, nil)
if err != nil {
return
}
if ind.Nx == 0 {
return
}
Xa := X.FloatArray()
dscal(ind.Nx, alpha, Xa[ind.OffsetX:], ind.IncX)
return
}
// 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
}
// Return Complex(Real, Imag). Return a new matrix.
func Complex(Real, Imag *matrix.FloatMatrix) *matrix.ComplexMatrix {
if !Real.SizeMatch(Imag.Size()) {
return nil
}
C := matrix.ComplexZeros(Real.Size())
Rr := Real.FloatArray()
Ir := Imag.FloatArray()
Cr := C.ComplexArray()
for i, _ := range Rr {
Cr[i] = complex(Rr[i], Ir[i])
}
return C
}
func trmmTest(t *testing.T, A *matrix.FloatMatrix, flags Flags, nb int) bool {
var B0 *matrix.FloatMatrix
N := A.Cols()
S := 0
E := A.Cols()
side := linalg.OptLeft
if flags&RIGHT != 0 {
B0 = matrix.FloatWithValue(2, A.Rows(), 2.0)
side = linalg.OptRight
E = B0.Rows()
} else {
B0 = matrix.FloatWithValue(A.Rows(), 2, 2.0)
E = B0.Cols()
}
B1 := B0.Copy()
trans := linalg.OptNoTrans
if flags&TRANSA != 0 {
trans = linalg.OptTransA
}
diag := linalg.OptNonUnit
if flags&UNIT != 0 {
diag = linalg.OptUnit
}
uplo := linalg.OptUpper
if flags&LOWER != 0 {
uplo = linalg.OptLower
}
blas.TrmmFloat(A, B0, 1.0, uplo, diag, trans, side)
if A.Rows() < 8 {
//t.Logf("..A\n%v\n", A)
t.Logf(" BLAS B0:\n%v\n", B0)
}
Ar := A.FloatArray()
Br := B1.FloatArray()
if nb != 0 {
DTrmmBlk(Br, Ar, 1.0, flags, B1.LeadingIndex(), A.LeadingIndex(),
N, S, E, nb)
} else {
DTrmmUnblk(Br, Ar, 1.0, flags, B1.LeadingIndex(), A.LeadingIndex(),
N, S, E, 0)
}
result := B0.AllClose(B1)
t.Logf(" B0 == B1: %v\n", result)
if A.Rows() < 8 {
t.Logf(" DTrmm B1:\n%v\n", B1)
}
return result
}
// See function Copy.
func CopyFloat(X, Y *matrix.FloatMatrix, opts ...linalg.Option) (err error) {
ind := linalg.GetIndexOpts(opts...)
err = check_level1_func(ind, fcopy, X, Y)
if err != nil {
return
}
if ind.Nx == 0 {
return
}
Xa := X.FloatArray()
Ya := Y.FloatArray()
dcopy(ind.Nx, Xa[ind.OffsetX:], ind.IncX, Ya[ind.OffsetY:], ind.IncY)
return
}
func GesvdFloat(A, S, U, Vt *matrix.FloatMatrix, opts ...linalg.Option) error {
pars, err := linalg.GetParameters(opts...)
if err != nil {
return err
}
ind := linalg.GetIndexOpts(opts...)
err = checkGesvd(ind, pars, A, S, U, Vt)
if err != nil {
return err
}
if ind.M == 0 || ind.N == 0 {
return nil
}
Aa := A.FloatArray()
Sa := S.FloatArray()
var Ua, Va []float64
Ua = nil
Va = nil
if U != nil {
Ua = U.FloatArray()[ind.OffsetU:]
}
if Vt != nil {
Va = Vt.FloatArray()[ind.OffsetVt:]
}
info := dgesvd(linalg.ParamString(pars.Jobu), linalg.ParamString(pars.Jobvt),
ind.M, ind.N, Aa[ind.OffsetA:], ind.LDa, Sa[ind.OffsetS:], Ua, ind.LDu, Va, ind.LDvt)
if info != 0 {
return onError(fmt.Sprintf("GesvdFloat lapack error: %d", info))
}
return nil
}
// See function Asum.
func AsumFloat(X *matrix.FloatMatrix, opts ...linalg.Option) (v float64) {
v = math.NaN()
ind := linalg.GetIndexOpts(opts...)
err := check_level1_func(ind, fasum, X, nil)
if err != nil {
return
}
if ind.Nx == 0 {
v = 0.0
return
}
Xa := X.FloatArray()
v = dasum(ind.Nx, Xa[ind.OffsetX:], ind.IncX)
return
}
// See functin Dot.
func DotFloat(X, Y *matrix.FloatMatrix, opts ...linalg.Option) (v float64) {
v = math.NaN()
ind := linalg.GetIndexOpts(opts...)
err := check_level1_func(ind, fdot, X, Y)
if err != nil {
return
}
if ind.Nx == 0 {
v = 0.0
return
}
Xa := X.FloatArray()
Ya := Y.FloatArray()
v = ddot(ind.Nx, Xa[ind.OffsetX:], ind.IncX, Ya[ind.OffsetY:], ind.IncY)
return
}
// A = A + alpha*X*Y.T; A is N*N symmetric, X is row or column vector of length N.
func MVSymmUpdateUpper(A, X *matrix.FloatMatrix, alpha float64) error {
if X.Rows() != 1 && X.Cols() != 1 {
return errors.New("X not a vector.")
}
Ar := A.FloatArray()
ldA := A.LeadingIndex()
Xr := X.FloatArray()
incX := 1
if X.Rows() == 1 {
// row vector
incX = X.LeadingIndex()
}
// NOTE: This could diveded to parallel tasks per column.
calgo.DSymmRankMV(Ar, Xr, alpha, calgo.UPPER, ldA, incX, 0, A.Cols(), 0)
return nil
}
func GbtrfFloat(A *matrix.FloatMatrix, ipiv []int32, M, KL int, opts ...linalg.Option) error {
ind := linalg.GetIndexOpts(opts...)
ind.M = M
ind.Kl = KL
err := checkGbtrf(ind, A, ipiv)
if err != nil {
return err
}
if ind.M == 0 || ind.N == 0 {
return nil
}
Aa := A.FloatArray()
info := dgbtrf(ind.M, ind.N, ind.Kl, ind.Ku, Aa[ind.OffsetA:], ind.LDa, ipiv)
if info != 0 {
return onError(fmt.Sprintf("Gbtrf lapack error: %d", info))
}
return nil
}
func PotrfFloat(A *matrix.FloatMatrix, opts ...linalg.Option) error {
pars, err := linalg.GetParameters(opts...)
if err != nil {
return err
}
ind := linalg.GetIndexOpts(opts...)
err = checkPotrf(ind, A)
if ind.N == 0 {
return nil
}
Aa := A.FloatArray()
uplo := linalg.ParamString(pars.Uplo)
info := dpotrf(uplo, ind.N, Aa[ind.OffsetA:], ind.LDa)
if info != 0 {
return onError(fmt.Sprintf("Potrf: lapack error %d", info))
}
return nil
}
// Convert triangular band matrix S to new matrix R with elements stored in
// triangular-band-packed mode. Returned matrix has dimensions R.Rows() == K+1
// and R.Cols() == S.Cols(). Parameter flags must have either UPPER or LOWER bit set.
func BandedTrmMatrix(S *matrix.FloatMatrix, K int, flags Flags) (R *matrix.FloatMatrix) {
if S.Rows() != S.Cols() {
return nil
}
M := S.Rows()
N := S.Cols()
R = nil
Sr := S.FloatArray()
if flags&UPPER != 0 {
// Upper triangular matrix
R = matrix.FloatZeros(K+1, M)
Rr := R.FloatArray()
for j := 0; j < N; j++ {
m := K + 1 - j
// is = max(0, j-K)
is := j - K
if is < 0 {
is = 0
}
for i := is; i <= j; i++ {
Rr[j*(K+1)+m+i-1] = Sr[j*M+i]
}
}
} else if flags&LOWER != 0 {
// Lower triangular matrix
R = matrix.FloatZeros(K+1, M)
Rr := R.FloatArray()
for j := 0; j < N; j++ {
m := 1 - j
// ie = min(N, j+K+1)
ie := j + K + 1
if ie >= N {
ie = N
}
for i := j; i < ie; i++ {
Rr[j*(K+1)+m+i-1] = Sr[j*M+i]
}
}
}
return
}
// Rank update for symmetric lower or upper matrix (blas.SYRK)
// C = beta*C + alpha*A*A.T + alpha*A.T*A
func RankUpdateSym(C, A *matrix.FloatMatrix, alpha, beta float64, flags Flags) error {
if C.Rows() != C.Cols() {
return onError("C not a square matrix")
}
Ar := A.FloatArray()
ldA := A.LeadingIndex()
Cr := C.FloatArray()
ldC := C.LeadingIndex()
S := 0
E := C.Rows()
P := A.Cols()
if flags&TRANSA != 0 {
P = A.Rows()
}
// if more workers available C can be divided to blocks [S:E, S:E] along diagonal
// and updated in separate tasks.
calgo.DSymmRankBlk(Cr, Ar, alpha, beta, calgo.Flags(flags), ldC, ldA, P, S, E,
vpLen, nB)
return nil
}
// See function Syr.
func SyrFloat(X, A *matrix.FloatMatrix, alpha float64, opts ...linalg.Option) (err error) {
var params *linalg.Parameters
params, err = linalg.GetParameters(opts...)
if err != nil {
return
}
ind := linalg.GetIndexOpts(opts...)
err = check_level2_func(ind, fsyr, X, nil, A, params)
if err != nil {
return
}
if ind.N == 0 {
return
}
Xa := X.FloatArray()
Aa := A.FloatArray()
uplo := linalg.ParamString(params.Uplo)
dsyr(uplo, ind.N, alpha, Xa[ind.OffsetX:], ind.IncX, Aa[ind.OffsetA:], ind.LDa)
return
}
func (p *floorPlan) F1(x *matrix.FloatMatrix) (f, Df *matrix.FloatMatrix, err error) {
err = nil
mn := x.Min(-1, -2, -3, -4, -5)
if mn <= 0.0 {
f, Df = nil, nil
return
}
zeros := matrix.FloatZeros(5, 12)
dk1 := matrix.FloatDiagonal(5, -1.0)
dk2 := matrix.FloatZeros(5, 5)
x17 := matrix.FloatVector(x.FloatArray()[17:])
// -( Amin ./ (x17 .* x17) )
diag := matrix.Div(p.Amin, matrix.Mul(x17, x17)).Scale(-1.0)
dk2.SetIndexesFromArray(diag.FloatArray(), matrix.MakeDiagonalSet(5)...)
Df, _ = matrix.FloatMatrixStacked(matrix.StackRight, zeros, dk1, dk2)
x12 := matrix.FloatVector(x.FloatArray()[12:17])
// f = -x[12:17] + div(Amin, x[17:]) == div(Amin, x[17:]) - x[12:17]
f = matrix.Minus(matrix.Div(p.Amin, x17), x12)
return
}
func GbsvFloat(A, B *matrix.FloatMatrix, ipiv []int32, kl int, opts ...linalg.Option) error {
ind := linalg.GetIndexOpts(opts...)
ind.Kl = kl
err := checkGbsv(ind, A, B, ipiv)
if err != nil {
return err
}
if ind.N == 0 || ind.Nrhs == 0 {
return nil
}
Aa := A.FloatArray()
Ba := B.FloatArray()
info := dgbsv(ind.N, ind.Kl, ind.Ku, ind.Nrhs, Aa[ind.OffsetA:], ind.LDa,
ipiv, Ba[ind.OffsetB:], ind.LDb)
if info != 0 {
return onError(fmt.Sprintf("Gbsv lapack error: %d", info))
}
return nil
}
// Calculate C = alpha*A*B.T + beta*C, C is M*N, A is M*P and B is N*P
func MMMultTransB(C, A, B *matrix.FloatMatrix, alpha, beta float64) error {
psize := int64(C.NumElements() * 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.DMult(Cr, Ar, Br, alpha, beta, calgo.TRANSB, 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.DMult(Cr, Ar, Br, alpha, beta, calgo.TRANSB, 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)
//scheduleWork(colworks, rowworks, worker)
return nil
}
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 MVSymm2UpdateUpper(A, X, Y *matrix.FloatMatrix, alpha float64) error {
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.DSymmRank2MV(Ar, Xr, Yr, alpha, calgo.UPPER, ldA, incY, incX, 0, A.Cols(), 0)
return nil
}
// Y = alpha*A.T*X + beta*Y
func MVMultTransA(Y, A, X *matrix.FloatMatrix, alpha, beta float64) error {
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
lenY := Y.Rows()
if Y.Rows() == 1 {
// row vector
incY = Y.LeadingIndex()
lenY = Y.Cols()
}
Xr := X.FloatArray()
incX := 1
lenX := X.Rows()
if X.Rows() == 1 {
// row vector
incX = X.LeadingIndex()
lenX = X.Cols()
}
calgo.DMultMV(Yr, Ar, Xr, alpha, beta, calgo.TRANSA, incY, ldA, incX,
0, lenX, 0, lenY, vpLen, mB)
return nil
}