func checkSytrf(ind *linalg.IndexOpts, A matrix.Matrix, ipiv []int32) error {
if ind.N < 0 {
ind.N = A.Rows()
if ind.N != A.Cols() {
return errors.New("A not square")
}
}
if ind.N == 0 {
return nil
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < max(1, ind.N) {
return errors.New("Sytrf: lda")
}
if ind.OffsetA < 0 {
return errors.New("Sytrf: offsetA")
}
sizeA := A.NumElements()
if sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.N {
return errors.New("Sytrf: sizeA")
}
if ipiv != nil && len(ipiv) < ind.N {
return errors.New("Sytrf: size ipiv")
}
return nil
}
func checkSyevd(ind *linalg.IndexOpts, A, W matrix.Matrix) error {
if ind.N < 0 {
ind.N = A.Rows()
if ind.N != A.Cols() {
return errors.New("Syevd: A not square")
}
}
if ind.N == 0 {
return nil
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < max(1, ind.N) {
return errors.New("Syevd: lda")
}
if ind.OffsetA < 0 {
return errors.New("Syevd: offsetA")
}
sizeA := A.NumElements()
if sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.N {
return errors.New("Syevd: sizeA")
}
if ind.OffsetW < 0 {
return errors.New("Syevd: offsetW")
}
sizeW := W.NumElements()
if sizeW < ind.OffsetW+ind.N {
return errors.New("Syevd: sizeW")
}
return nil
}
func checkGbtrs(ind *linalg.IndexOpts, A, B matrix.Matrix, ipiv []int32) error {
if ind.Kl < 0 {
return errors.New("Gbtrs: invalid kl")
}
if ind.N < 0 {
ind.N = A.Rows()
}
if ind.Nrhs < 0 {
ind.Nrhs = A.Cols()
}
if ind.N == 0 || ind.Nrhs == 0 {
return nil
}
if ind.Ku < 0 {
ind.Ku = A.Rows() - 2*ind.Kl - 1
}
if ind.Ku < 0 {
return errors.New("Gbtrs: invalid ku")
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < 2*ind.Kl+ind.Ku+1 {
return errors.New("Gbtrs: lda")
}
if ind.OffsetA < 0 {
return errors.New("Gbtrs: offsetA")
}
sizeA := A.NumElements()
if sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+2*ind.Kl+ind.Ku+1 {
return errors.New("Gbtrs: sizeA")
}
if ind.LDb == 0 {
ind.LDb = max(1, B.Rows())
}
if ind.OffsetB < 0 {
return errors.New("Gbtrs: offsetB")
}
sizeB := B.NumElements()
if sizeB < ind.OffsetB+(ind.Nrhs-1)*ind.LDb+ind.N {
return errors.New("Gbtrs: sizeB")
}
if ipiv != nil && len(ipiv) < ind.N {
return errors.New("Gbtrs: size ipiv")
}
return nil
}
func checkPotri(ind *linalg.IndexOpts, A matrix.Matrix) error {
if ind.N < 0 {
ind.N = A.Rows()
}
if ind.N == 0 {
return nil
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < max(1, ind.N) {
return errors.New("Potri: lda")
}
if ind.OffsetA < 0 {
return errors.New("Potri: offsetA")
}
if A.NumElements() < ind.OffsetA+(ind.N-1)*ind.LDa+ind.N {
return errors.New("Potri: sizeA")
}
return nil
}
func checkGbtrf(ind *linalg.IndexOpts, A matrix.Matrix, ipiv []int32) error {
if ind.M < 0 {
return errors.New("Gbtrf: illegal m")
}
if ind.Kl < 0 {
return errors.New("GBtrf: illegal kl")
}
if ind.N < 0 {
ind.N = A.Rows()
}
if ind.M == 0 || ind.N == 0 {
return nil
}
if ind.Ku < 0 {
ind.Ku = A.Rows() - 2*ind.Kl - 1
}
if ind.Ku < 0 {
return errors.New("Gbtrf: invalid ku")
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < 2*ind.Kl+ind.Ku+1 {
return errors.New("Gbtrf: lda")
}
if ind.OffsetA < 0 {
return errors.New("Gbtrf: offsetA")
}
sizeA := A.NumElements()
if sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+2*ind.Kl+ind.Ku+1 {
return errors.New("Gbtrf: sizeA")
}
if ipiv != nil && len(ipiv) < min(ind.N, ind.M) {
return errors.New("Gbtrf: size ipiv")
}
return nil
}
func check_level1_func(ind *linalg.IndexOpts, fn funcNum, X, Y matrix.Matrix) error {
nX, nY := 0, 0
// this is adapted from cvxopt:blas.c python blas interface
switch fn {
case fnrm2, fasum, fiamax, fscal, fset:
if ind.IncX <= 0 {
return errors.New("incX illegal, <=0")
}
if ind.OffsetX < 0 {
return errors.New("offsetX illegal, <0")
}
sizeX := X.NumElements()
if sizeX >= ind.OffsetX+1 {
// calculate default size for N based on X size
nX = 1 + (sizeX-ind.OffsetX-1)/ind.IncX
}
if sizeX < ind.OffsetX+1+(ind.Nx-1)*abs(ind.IncX) {
return errors.New("X size error")
}
if ind.Nx < 0 {
ind.Nx = nX
}
case fdot, fswap, fcopy, faxpy, faxpby:
// vector X
if ind.IncX <= 0 {
return errors.New("incX illegal, <=0")
}
if ind.OffsetX < 0 {
return errors.New("offsetX illegal, <0")
}
sizeX := X.NumElements()
if sizeX >= ind.OffsetX+1 {
// calculate default size for N based on X size
nX = 1 + (sizeX-ind.OffsetX-1)/ind.IncX
}
if sizeX < ind.OffsetX+1+(ind.Nx-1)*abs(ind.IncX) {
return errors.New("X size error")
}
if ind.Nx < 0 {
ind.Nx = nX
}
// vector Y
if ind.IncY <= 0 {
return errors.New("incY illegal, <=0")
}
if ind.OffsetY < 0 {
return errors.New("offsetY illegal, <0")
}
sizeY := Y.NumElements()
if sizeY >= ind.OffsetY+1 {
// calculate default size for N based on Y size
nY = 1 + (sizeY-ind.OffsetY-1)/ind.IncY
}
if ind.Ny < 0 {
ind.Ny = nY
}
if sizeY < ind.OffsetY+1+(ind.Ny-1)*abs(ind.IncY) {
fmt.Printf("sizeY=%d, inds: %#v\n", sizeY, ind)
return errors.New("Y size error")
}
case frotg, frotmg, frot, frotm:
}
return nil
}
func check_level3_func(ind *linalg.IndexOpts, fn funcNum, A, B, C matrix.Matrix,
pars *linalg.Parameters) (err error) {
switch fn {
case fgemm:
if ind.M < 0 {
if pars.TransA == linalg.PNoTrans {
ind.M = A.Rows()
} else {
ind.M = A.Cols()
}
}
if ind.N < 0 {
if pars.TransB == linalg.PNoTrans {
ind.N = A.Cols()
} else {
ind.N = A.Rows()
}
}
if ind.K < 0 {
if pars.TransA == linalg.PNoTrans {
ind.K = A.Cols()
} else {
ind.K = A.Rows()
}
if pars.TransB == linalg.PNoTrans && ind.K != B.Rows() ||
pars.TransB != linalg.PNoTrans && ind.K != B.Cols() {
return errors.New("dimensions of A and B do not match")
}
}
if ind.OffsetB < 0 {
return errors.New("offsetB illegal, <0")
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.K > 0 {
if (pars.TransA == linalg.PNoTrans && ind.LDa < max(1, ind.M)) ||
(pars.TransA != linalg.PNoTrans && ind.LDa < max(1, ind.K)) {
return errors.New("inconsistent ldA")
}
sizeA := A.NumElements()
if (pars.TransA == linalg.PNoTrans &&
sizeA < ind.OffsetA+(ind.K-1)*ind.LDa+ind.M) ||
(pars.TransA != linalg.PNoTrans &&
sizeA < ind.OffsetA+(ind.M-1)*ind.LDa+ind.K) {
return errors.New("sizeA")
}
}
// B matrix
if B != nil {
if ind.OffsetB < 0 {
return errors.New("offsetB illegal, <0")
}
if ind.LDb == 0 {
ind.LDb = max(1, B.Rows())
}
if ind.K > 0 {
if (pars.TransB == linalg.PNoTrans && ind.LDb < max(1, ind.K)) ||
(pars.TransB != linalg.PNoTrans && ind.LDb < max(1, ind.N)) {
return errors.New("inconsistent ldB")
}
sizeB := B.NumElements()
if (pars.TransB == linalg.PNoTrans &&
sizeB < ind.OffsetB+(ind.N-1)*ind.LDb+ind.K) ||
(pars.TransB != linalg.PNoTrans &&
sizeB < ind.OffsetB+(ind.K-1)*ind.LDb+ind.N) {
return errors.New("sizeB")
}
}
}
// C matrix
if C != nil {
if ind.OffsetC < 0 {
return errors.New("offsetC illegal, <0")
}
if ind.LDc == 0 {
ind.LDb = max(1, C.Rows())
}
if ind.LDc < max(1, ind.M) {
return errors.New("inconsistent ldC")
}
sizeC := C.NumElements()
if sizeC < ind.OffsetC+(ind.N-1)*ind.LDc+ind.M {
return errors.New("sizeC")
}
}
case fsymm, ftrmm, ftrsm:
if ind.M < 0 {
ind.M = B.Rows()
if pars.Side == linalg.PLeft && (ind.M != A.Rows() || ind.M != A.Cols()) {
return errors.New("dimensions of A and B do not match")
}
}
if ind.N < 0 {
ind.N = B.Cols()
if pars.Side == linalg.PRight && (ind.N != A.Rows() || ind.N != A.Cols()) {
return errors.New("dimensions of A and B do not match")
}
}
if ind.M == 0 || ind.N == 0 {
return
}
// check A
if ind.OffsetB < 0 {
return errors.New("offsetB illegal, <0")
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if pars.Side == linalg.PLeft && ind.LDa < max(1, ind.M) || ind.LDa < max(1, ind.N) {
return errors.New("ldA")
}
sizeA := A.NumElements()
if (pars.Side == linalg.PLeft && sizeA < ind.OffsetA+(ind.M-1)*ind.LDa+ind.M) ||
(pars.Side == linalg.PRight && sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.N) {
return errors.New("sizeA")
}
if B != nil {
if ind.OffsetB < 0 {
return errors.New("offsetB illegal, <0")
}
if ind.LDb == 0 {
ind.LDb = max(1, B.Rows())
}
if ind.LDb < max(1, ind.M) {
return errors.New("ldB")
}
sizeB := B.NumElements()
if sizeB < ind.OffsetB+(ind.N-1)*ind.LDb+ind.M {
return errors.New("sizeB")
}
}
if C != nil {
if ind.OffsetC < 0 {
return errors.New("offsetC illegal, <0")
}
if ind.LDc == 0 {
ind.LDc = max(1, C.Rows())
}
if ind.LDc < max(1, ind.M) {
return errors.New("ldC")
}
sizeC := C.NumElements()
if sizeC < ind.OffsetC+(ind.N-1)*ind.LDc+ind.M {
return errors.New("sizeC")
}
}
case fsyrk, fsyr2k:
if ind.N < 0 {
if pars.Trans == linalg.PNoTrans {
ind.N = B.Rows()
} else {
ind.N = B.Cols()
}
}
if ind.K < 0 {
if pars.Trans == linalg.PNoTrans {
ind.K = A.Cols()
} else {
ind.K = A.Rows()
}
}
if ind.N == 0 {
return
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.K > 0 {
if (pars.Trans == linalg.PNoTrans && ind.LDa < max(1, ind.N)) ||
(pars.Trans != linalg.PNoTrans && ind.LDa < max(1, ind.K)) {
return errors.New("inconsistent ldA")
}
sizeA := A.NumElements()
if (pars.Trans == linalg.PNoTrans &&
sizeA < ind.OffsetA+(ind.K-1)*ind.LDa+ind.N) ||
(pars.TransA != linalg.PNoTrans &&
sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.K) {
return errors.New("sizeA")
}
}
if B != nil {
if ind.OffsetB < 0 {
return errors.New("offsetB illegal, <0")
}
if ind.LDb == 0 {
ind.LDb = max(1, B.Rows())
}
if ind.K > 0 {
if (pars.Trans == linalg.PNoTrans && ind.LDb < max(1, ind.N)) ||
(pars.Trans != linalg.PNoTrans && ind.LDb < max(1, ind.K)) {
return errors.New("ldB")
}
sizeB := B.NumElements()
if (pars.Trans == linalg.PNoTrans &&
sizeB < ind.OffsetB+(ind.K-1)*ind.LDb+ind.N) ||
(pars.Trans != linalg.PNoTrans &&
sizeB < ind.OffsetB+(ind.N-1)*ind.LDb+ind.K) {
return errors.New("sizeB")
}
}
}
if C != nil {
if ind.OffsetC < 0 {
return errors.New("offsetC illegal, <0")
}
if ind.LDc == 0 {
ind.LDc = max(1, C.Rows())
}
if ind.LDc < max(1, ind.N) {
return errors.New("ldC")
}
sizeC := C.NumElements()
if sizeC < ind.OffsetC+(ind.N-1)*ind.LDc+ind.N {
return errors.New("sizeC")
}
}
}
err = nil
return
}
func check_level2_func(ind *linalg.IndexOpts, fn funcNum, X, Y, A matrix.Matrix, pars *linalg.Parameters) error {
if ind.IncX <= 0 {
return errors.New("incX")
}
if ind.IncY <= 0 {
return errors.New("incY")
}
sizeA := A.NumElements()
switch fn {
case fgemv: // general matrix
if ind.M < 0 {
ind.M = A.Rows()
}
if ind.N < 0 {
ind.N = A.Cols()
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.OffsetA < 0 {
return errors.New("offsetA")
}
if ind.N > 0 && ind.M > 0 &&
sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.M {
return errors.New("sizeA")
}
if ind.OffsetX < 0 {
return errors.New("offsetX")
}
if ind.OffsetY < 0 {
return errors.New("offsetY")
}
sizeX := X.NumElements()
sizeY := Y.NumElements()
if pars.Trans == linalg.PNoTrans {
if ind.N > 0 && sizeX < ind.OffsetX+(ind.N-1)*abs(ind.IncX)+1 {
return errors.New("sizeX")
}
if ind.M > 0 && sizeY < ind.OffsetY+(ind.M-1)*abs(ind.IncY)+1 {
return errors.New("sizeY")
}
} else {
if ind.M > 0 && sizeX < ind.OffsetX+(ind.M-1)*abs(ind.IncX)+1 {
return errors.New("sizeX")
}
if ind.N > 0 && sizeY < ind.OffsetY+(ind.N-1)*abs(ind.IncY)+1 {
return errors.New("sizeY")
}
}
case fger:
if ind.M < 0 {
ind.M = A.Rows()
}
if ind.N < 0 {
ind.N = A.Cols()
}
if ind.M == 0 || ind.N == 0 {
return nil
}
if ind.M > 0 && ind.N > 0 {
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < max(1, ind.M) {
return errors.New("ldA")
}
if ind.OffsetA < 0 {
return errors.New("offsetA")
}
if sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.M {
return errors.New("sizeA")
}
if ind.OffsetX < 0 {
return errors.New("offsetX")
}
if ind.OffsetY < 0 {
return errors.New("offsetY")
}
sizeX := X.NumElements()
if sizeX < ind.OffsetX+(ind.M-1)*abs(ind.IncX)+1 {
return errors.New("sizeX")
}
sizeY := Y.NumElements()
if sizeY < ind.OffsetY+(ind.N-1)*abs(ind.IncY)+1 {
return errors.New("sizeY")
}
}
case fgbmv: // general banded
if ind.M < 0 {
ind.M = A.Rows()
}
if ind.N < 0 {
ind.N = A.Cols()
}
if ind.Kl < 0 {
return errors.New("kl")
}
if ind.Ku < 0 {
ind.Ku = A.Rows() - 1 - ind.Kl
}
if ind.Ku < 0 {
return errors.New("ku")
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < ind.Kl+ind.Ku+1 {
return errors.New("ldA")
}
if ind.OffsetA < 0 {
return errors.New("offsetA")
}
sizeA := A.NumElements()
if ind.N > 0 && ind.M > 0 &&
sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.Kl+ind.Ku+1 {
return errors.New("sizeA")
}
if ind.OffsetX < 0 {
return errors.New("offsetX")
}
if ind.OffsetY < 0 {
return errors.New("offsetY")
}
sizeX := X.NumElements()
sizeY := Y.NumElements()
if pars.Trans == linalg.PNoTrans {
if ind.N > 0 && sizeX < ind.OffsetX+(ind.N-1)*abs(ind.IncX)+1 {
return errors.New("sizeX")
}
if ind.N > 0 && sizeY < ind.OffsetY+(ind.M-1)*abs(ind.IncY)+1 {
return errors.New("sizeY")
}
} else {
if ind.N > 0 && sizeX < ind.OffsetX+(ind.M-1)*abs(ind.IncX)+1 {
return errors.New("sizeX")
}
if ind.N > 0 && sizeY < ind.OffsetY+(ind.N-1)*abs(ind.IncY)+1 {
return errors.New("sizeY")
}
}
case ftrmv, ftrsv:
// ftrmv = triangular
// ftrsv = triangular solve
if ind.N < 0 {
if A.Rows() != A.Cols() {
return errors.New("A not square")
}
ind.N = A.Rows()
}
if ind.N > 0 {
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < max(1, ind.N) {
return errors.New("ldA")
}
if ind.OffsetA < 0 {
return errors.New("offsetA")
}
sizeA := A.NumElements()
if sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.N {
return errors.New("sizeA")
}
sizeX := X.NumElements()
if sizeX < ind.OffsetX+(ind.N-1)*abs(ind.IncX)+1 {
return errors.New("sizeX")
}
}
case ftbmv, ftbsv, fsbmv:
// ftbmv = triangular banded
// ftbsv = triangular banded solve
// fsbmv = symmetric banded product
if ind.N < 0 {
ind.N = A.Rows()
}
if ind.N > 0 {
if ind.K < 0 {
ind.K = max(0, A.Rows()-1)
}
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < ind.K+1 {
return errors.New("ldA")
}
if ind.OffsetA < 0 {
return errors.New("offsetA")
}
sizeA := A.NumElements()
if sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.K+1 {
return errors.New("sizeA")
}
sizeX := X.NumElements()
if sizeX < ind.OffsetX+(ind.N-1)*abs(ind.IncX)+1 {
return errors.New("sizeX")
}
if Y != nil {
sizeY := Y.NumElements()
if sizeY < ind.OffsetY+(ind.N-1)*abs(ind.IncY)+1 {
return errors.New("sizeY")
}
}
}
case fsymv, fsyr, fsyr2:
// fsymv = symmetric product
// fsyr = symmetric rank update
// fsyr2 = symmetric rank-2 update
if ind.N < 0 {
if A.Rows() != A.Cols() {
return errors.New("A not square")
}
ind.N = A.Rows()
}
if ind.N > 0 {
if ind.LDa == 0 {
ind.LDa = max(1, A.Rows())
}
if ind.LDa < max(1, ind.N) {
return errors.New("ldA")
}
if ind.OffsetA < 0 {
return errors.New("offsetA")
}
sizeA := A.NumElements()
if sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.N {
return errors.New("sizeA")
}
if ind.OffsetX < 0 {
return errors.New("offsetX")
}
sizeX := X.NumElements()
if sizeX < ind.OffsetX+(ind.N-1)*abs(ind.IncX)+1 {
return errors.New("sizeX")
}
if Y != nil {
if ind.OffsetY < 0 {
return errors.New("offsetY")
}
sizeY := Y.NumElements()
if sizeY < ind.OffsetY+(ind.N-1)*abs(ind.IncY)+1 {
return errors.New("sizeY")
}
}
}
case fspr, fdspr2, ftpsv, fspmv, ftpmv:
// ftpsv = triangular packed solve
// fspmv = symmetric packed product
// ftpmv = triangular packed
}
return nil
}
func checkGesvd(ind *linalg.IndexOpts, pars *linalg.Parameters, A, S, U, Vt matrix.Matrix) error {
if ind.M < 0 {
ind.M = A.Rows()
}
if ind.N < 0 {
ind.N = A.Cols()
}
if ind.M == 0 || ind.N == 0 {
return nil
}
if pars.Jobu == linalg.PJobO && pars.Jobvt == linalg.PJobO {
return errors.New("Gesvd: jobu and jobvt cannot both have value PJobO")
}
if pars.Jobu == linalg.PJobAll || pars.Jobu == linalg.PJobS {
if U == nil {
return errors.New("Gesvd: missing matrix U")
}
if ind.LDu == 0 {
ind.LDu = max(1, U.Rows())
}
if ind.LDu < max(1, ind.M) {
return errors.New("Gesvd: ldU")
}
} else {
if ind.LDu == 0 {
ind.LDu = 1
}
if ind.LDu < 1 {
return errors.New("Gesvd: ldU")
}
}
if pars.Jobvt == linalg.PJobAll || pars.Jobvt == linalg.PJobS {
if Vt == nil {
return errors.New("Gesvd: missing matrix Vt")
}
if ind.LDvt == 0 {
ind.LDvt = max(1, Vt.Rows())
}
if pars.Jobvt == linalg.PJobAll && ind.LDvt < max(1, ind.N) {
return errors.New("Gesvd: ldVt")
} else if pars.Jobvt != linalg.PJobAll && ind.LDvt < max(1, min(ind.M, ind.N)) {
return errors.New("Gesvd: ldVt")
}
} else {
if ind.LDvt == 0 {
ind.LDvt = 1
}
if ind.LDvt < 1 {
return errors.New("Gesvd: ldVt")
}
}
if ind.OffsetA < 0 {
return errors.New("Gesvd: offsetA")
}
sizeA := A.NumElements()
if sizeA < ind.OffsetA+(ind.N-1)*ind.LDa+ind.M {
return errors.New("Gesvd: sizeA")
}
if ind.OffsetS < 0 {
return errors.New("Gesvd: offsetS")
}
sizeS := S.NumElements()
if sizeS < ind.OffsetS+min(ind.M, ind.N) {
return errors.New("Gesvd: sizeA")
}
/*
if U != nil {
if ind.OffsetU < 0 {
return errors.New("Gesvd: OffsetU")
}
sizeU := U.NumElements()
if pars.Jobu == linalg.PJobAll && sizeU < ind.LDu*(ind.M-1) {
return errors.New("Gesvd: sizeU")
} else if pars.Jobu == linalg.PJobS && sizeU < ind.LDu*(min(ind.M,ind.N)-1) {
return errors.New("Gesvd: sizeU")
}
}
if Vt != nil {
if ind.OffsetVt < 0 {
return errors.New("Gesvd: OffsetVt")
}
sizeVt := Vt.NumElements()
if pars.Jobvt == linalg.PJobAll && sizeVt < ind.N {
return errors.New("Gesvd: sizeVt")
} else if pars.Jobvt == linalg.PJobS && sizeVt < min(ind.M, ind.N) {
return errors.New("Gesvd: sizeVt")
}
}
*/
return nil
}
