return;
}
+ if (*m == 0 || *n == 0) return;
// Constant
const float ZERO[] = { 0., 0. };
// Allocate work space
const blasint n1 = CREC_SPLIT(*n);
- const blasint mWorkl = (kv > n1) ? MAX(1, *m - *kl) : kv;
- const blasint nWorkl = (kv > n1) ? n1 : kv;
- const blasint mWorku = (*kl > n1) ? n1 : *kl;
- const blasint nWorku = (*kl > n1) ? MAX(0, *n - *kl) : *kl;
+ const blasint mWorkl = abs ( (kv > n1) ? MAX(1, *m - *kl) : kv);
+ const blasint nWorkl = abs ( (kv > n1) ? n1 : kv);
+ const blasint mWorku = abs ((*kl > n1) ? n1 : *kl);
+ const blasint nWorku = abs ((*kl > n1) ? MAX(0, *n - *kl) : *kl);
float *Workl = malloc(mWorkl * nWorkl * 2 * sizeof(float));
float *Worku = malloc(mWorku * nWorku * 2 * sizeof(float));
LAPACK(claset)("L", &mWorkl, &nWorkl, ZERO, ZERO, Workl, &mWorkl);
blasint *info
) {
- if (*n <= MAX(CROSSOVER_CGBTRF, 1)) {
+ if (*n <= MAX(CROSSOVER_CGBTRF, 1)|| *n > *kl || *ldAb == 1) {
// Unblocked
LAPACK(cgbtf2)(m, n, kl, ku, Ab, ldAb, ipiv, info);
return;
return;
}
+ if (*n == 0) return;
+
// Clean char * arguments
const char cleanuplo = lower ? 'L' : 'U';
// Allocate work space
const blasint n1 = CREC_SPLIT(*n);
- const blasint mWork = (*kd > n1) ? (lower ? *n - *kd : n1) : *kd;
- const blasint nWork = (*kd > n1) ? (lower ? n1 : *n - *kd) : *kd;
+ const blasint mWork = abs((*kd > n1) ? (lower ? *n - *kd : n1) : *kd);
+ const blasint nWork = abs((*kd > n1) ? (lower ? n1 : *n - *kd) : *kd);
float *Work = malloc(mWork * nWork * 2 * sizeof(float));
LAPACK(claset)(uplo, &mWork, &nWork, ZERO, ZERO, Work, &mWork);
blasint *info
){
- if (*n <= MAX(CROSSOVER_CPBTRF, 1)) {
+ if (*n <= MAX(CROSSOVER_CPBTRF, 1) || *ldAb==1) {
// Unblocked
LAPACK(cpbtf2)(uplo, n, kd, Ab, ldAb, info);
return;
}
// recursion(A_BR)
- if (*kd > n1)
+ if (*kd > n1 && ldA != 0)
RELAPACK_cpotrf(uplo, &n2, A_BR, ldA, info);
else
RELAPACK_cpbtrf_rec(uplo, &n2, kd, Ab_BR, ldAb, Work, ldWork, info);
return;
}
+ if (*m == 0 || *n == 0) return;
+
// Constant
const double ZERO[] = { 0. };
blasint *info
) {
- if (*n <= MAX(CROSSOVER_DGBTRF, 1)) {
+ if (*n <= MAX(CROSSOVER_DGBTRF, 1) || *n > *kl || *ldAb == 1) {
// Unblocked
LAPACK(dgbtf2)(m, n, kl, ku, Ab, ldAb, ipiv, info);
return;
// Worku = A_TRr
LAPACK(dlacpy)("L", &m1, &n22, A_TRr, ldA, Worku, ldWorku);
// Worku = A_TL \ Worku
+ if (ldWorku <= 0) return;
BLAS(dtrsm)("L", "L", "N", "U", &m1, &n22, ONE, A_TL, ldA, Worku, ldWorku);
// A_TRr = Worku
LAPACK(dlacpy)("L", &m1, &n22, Worku, ldWorku, A_TRr, ldA);
return;
}
+ if (*n == 0) return;
+
// Clean char * arguments
const char cleanuplo = lower ? 'L' : 'U';
// Allocate work space
const blasint n1 = DREC_SPLIT(*n);
- const blasint mWork = (*kd > n1) ? (lower ? *n - *kd : n1) : *kd;
- const blasint nWork = (*kd > n1) ? (lower ? n1 : *n - *kd) : *kd;
+ const blasint mWork = abs((*kd > n1) ? (lower ? *n - *kd : n1) : *kd);
+ const blasint nWork = abs((*kd > n1) ? (lower ? n1 : *n - *kd) : *kd);
double *Work = malloc(mWork * nWork * sizeof(double));
LAPACK(dlaset)(uplo, &mWork, &nWork, ZERO, ZERO, Work, &mWork);
blasint *info
){
- if (*n <= MAX(CROSSOVER_DPBTRF, 1)) {
+ if (*n <= MAX(CROSSOVER_DPBTRF, 1) || *ldAb == 1) {
// Unblocked
LAPACK(dpbtf2)(uplo, n, kd, Ab, ldAb, info);
return;
}
// recursion(A_BR)
- if (*kd > n1)
+ if (*kd > n1 && ldA != 0)
RELAPACK_dpotrf(uplo, &n2, A_BR, ldA, info);
else
RELAPACK_dpbtrf_rec(uplo, &n2, kd, Ab_BR, ldAb, Work, ldWork, info);
return;
}
+ if (*m == 0 || *n == 0) return;
+
+ if (*ldAb == 1) {
+ LAPACK(sgbtf2)(m, n, kl, ku, Ab, ldAb, ipiv, info);
+ return;
+ }
+
// Constant
const float ZERO[] = { 0. };
blasint *info
) {
+ if (*m == 0 || *n == 0) return;
- if (*n <= MAX(CROSSOVER_SGBTRF, 1)) {
+ if ( *n <= MAX(CROSSOVER_SGBTRF, 1) || *n > *kl || *ldAb == 1) {
// Unblocked
LAPACK(sgbtf2)(m, n, kl, ku, Ab, ldAb, ipiv, info);
return;
// recursion(Ab_L, ipiv_T)
RELAPACK_sgbtrf_rec(m, &n1, kl, ku, Ab_L, ldAb, ipiv_T, Workl, ldWorkl, Worku, ldWorku, info);
-
+ if (*info) return;
// Workl = A_BLb
LAPACK(slacpy)("U", &m22, &n1, A_BLb, ldA, Workl, ldWorkl);
// recursion(Ab_BR, ipiv_B)
//cause of infinite recursion here ?
-// RELAPACK_sgbtrf_rec(&m2, &n2, kl, ku, Ab_BR, ldAb, ipiv_B, Workl, ldWorkl, Worku, ldWorku, info);
- LAPACK(sgbtf2)(&m2, &n2, kl, ku, Ab_BR, ldAb, ipiv_B, info);
+ RELAPACK_sgbtrf_rec(&m2, &n2, kl, ku, Ab_BR, ldAb, ipiv_B, Workl, ldWorkl, Worku, ldWorku, info);
+// LAPACK(sgbtf2)(&m2, &n2, kl, ku, Ab_BR, ldAb, ipiv_B, info);
if (*info)
*info += n1;
// shift pivots
return;
}
+
+ if (*n == 0) return;
+
// Clean char * arguments
const char cleanuplo = lower ? 'L' : 'U';
// Allocate work space
const blasint n1 = SREC_SPLIT(*n);
- const blasint mWork = (*kd > n1) ? (lower ? *n - *kd : n1) : *kd;
- const blasint nWork = (*kd > n1) ? (lower ? n1 : *n - *kd) : *kd;
+ const blasint mWork = abs( (*kd > n1) ? (lower ? *n - *kd : n1) : *kd);
+ const blasint nWork = abs((*kd > n1) ? (lower ? n1 : *n - *kd) : *kd);
float *Work = malloc(mWork * nWork * sizeof(float));
LAPACK(slaset)(uplo, &mWork, &nWork, ZERO, ZERO, Work, &mWork);
blasint *info
){
- if (*n <= MAX(CROSSOVER_SPBTRF, 1)) {
+ if (*n == 0 ) return;
+
+ if ( *n <= MAX(CROSSOVER_SPBTRF, 1) || *ldAb == 1) {
// Unblocked
LAPACK(spbtf2)(uplo, n, kd, Ab, ldAb, info);
return;
}
// recursion(A_BR)
- if (*kd > n1)
+ if (*kd > n1 && ldA != 0)
RELAPACK_spotrf(uplo, &n2, A_BR, ldA, info);
else
RELAPACK_spbtrf_rec(uplo, &n2, kd, Ab_BR, ldAb, Work, ldWork, info);
return;
}
+ if (*m == 0 || *n == 0) return;
+
// Constant
const double ZERO[] = { 0., 0. };
blasint *info
) {
- if (*n <= MAX(CROSSOVER_ZGBTRF, 1)) {
+ if (*n <= MAX(CROSSOVER_ZGBTRF, 1) || *n > *kl || *ldAb == 1) {
// Unblocked
LAPACK(zgbtf2)(m, n, kl, ku, Ab, ldAb, ipiv, info);
return;
const double ONE[] = { 1., 0. };
const double MONE[] = { -1., 0. };
const blasint iONE[] = { 1 };
+ const blasint min11 = -11;
// Loop iterators
blasint i, j;
// recursion(Ab_L, ipiv_T)
RELAPACK_zgbtrf_rec(m, &n1, kl, ku, Ab_L, ldAb, ipiv_T, Workl, ldWorkl, Worku, ldWorku, info);
+if (*info) return;
// Workl = A_BLb
LAPACK(zlacpy)("U", &m22, &n1, A_BLb, ldA, Workl, ldWorkl);
}
// A_TRl = A_TL \ A_TRl
+ if (*ldA < MAX(1,m1)) {
+ LAPACK(xerbla)("ZGBTRF", &min11, strlen("ZGBTRF"));
+ return;
+ } else {
BLAS(ztrsm)("L", "L", "N", "U", &m1, &n21, ONE, A_TL, ldA, A_TRl, ldA);
+ }
// Worku = A_TRr
LAPACK(zlacpy)("L", &m1, &n22, A_TRr, ldA, Worku, ldWorku);
// Worku = A_TL \ Worku
+ if (*ldWorku < MAX(1,m1)) {
+ LAPACK(xerbla)("ZGBTRF", &min11, strlen("ZGBTRF"));
+ return;
+ } else {
BLAS(ztrsm)("L", "L", "N", "U", &m1, &n22, ONE, A_TL, ldA, Worku, ldWorku);
+ }
// A_TRr = Worku
LAPACK(zlacpy)("L", &m1, &n22, Worku, ldWorku, A_TRr, ldA);
// A_BRtl = A_BRtl - A_BLt * A_TRl
return;
}
+ if (*n == 0) return;
+
// Clean char * arguments
const char cleanuplo = lower ? 'L' : 'U';
// Allocate work space
const blasint n1 = ZREC_SPLIT(*n);
- const blasint mWork = (*kd > n1) ? (lower ? *n - *kd : n1) : *kd;
- const blasint nWork = (*kd > n1) ? (lower ? n1 : *n - *kd) : *kd;
+ const blasint mWork = abs((*kd > n1) ? (lower ? *n - *kd : n1) : *kd);
+ const blasint nWork = abs((*kd > n1) ? (lower ? n1 : *n - *kd) : *kd);
double *Work = malloc(mWork * nWork * 2 * sizeof(double));
+
LAPACK(zlaset)(uplo, &mWork, &nWork, ZERO, ZERO, Work, &mWork);
// Recursive kernel
blasint *info
){
- if (*n <= MAX(CROSSOVER_ZPBTRF, 1)) {
+ if (*n <= MAX(CROSSOVER_ZPBTRF, 1) || *ldAb == 1) {
// Unblocked
LAPACK(zpbtf2)(uplo, n, kd, Ab, ldAb, info);
return;
}
// recursion(A_BR)
- if (*kd > n1)
+ if (*kd > n1 && ldA != 0)
RELAPACK_zpotrf(uplo, &n2, A_BR, ldA, info);
else
RELAPACK_zpbtrf_rec(uplo, &n2, kd, Ab_BR, ldAb, Work, ldWork, info);