/* Subroutine */ int spteqr_(char *compz, integer *n, real *d__, real *e,
real *z__, integer *ldz, real *work, integer *info)
{
/* System generated locals */
integer z_dim1, z_offset, i__1;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
static real c__[1] /* was [1][1] */;
static integer i__;
extern logical lsame_(char *, char *);
static real vt[1] /* was [1][1] */;
extern /* Subroutine */ int xerbla_(char *, integer *), slaset_(
char *, integer *, integer *, real *, real *, real *, integer *), sbdsqr_(char *, integer *, integer *, integer *, integer
*, real *, real *, real *, integer *, real *, integer *, real *,
integer *, real *, integer *);
static integer icompz;
extern /* Subroutine */ int spttrf_(integer *, real *, real *, integer *);
static integer nru;
#define z___ref(a_1,a_2) z__[(a_2)*z_dim1 + a_1]
/* -- LAPACK routine (instrumented to count operations, version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
October 31, 1999
Common block to return operation count and iteration count
ITCNT is initialized to 0, OPS is only incremented
Purpose
=======
SPTEQR computes all eigenvalues and, optionally, eigenvectors of a
symmetric positive definite tridiagonal matrix by first factoring the
matrix using SPTTRF, and then calling SBDSQR to compute the singular
values of the bidiagonal factor.
This routine computes the eigenvalues of the positive definite
tridiagonal matrix to high relative accuracy. This means that if the
eigenvalues range over many orders of magnitude in size, then the
small eigenvalues and corresponding eigenvectors will be computed
more accurately than, for example, with the standard QR method.
The eigenvectors of a full or band symmetric positive definite matrix
can also be found if SSYTRD, SSPTRD, or SSBTRD has been used to
reduce this matrix to tridiagonal form. (The reduction to tridiagonal
form, however, may preclude the possibility of obtaining high
relative accuracy in the small eigenvalues of the original matrix, if
these eigenvalues range over many orders of magnitude.)
Arguments
=========
COMPZ (input) CHARACTER*1
= 'N': Compute eigenvalues only.
= 'V': Compute eigenvectors of original symmetric
matrix also. Array Z contains the orthogonal
matrix used to reduce the original matrix to
tridiagonal form.
= 'I': Compute eigenvectors of tridiagonal matrix also.
N (input) INTEGER
The order of the matrix. N >= 0.
D (input/output) REAL array, dimension (N)
On entry, the n diagonal elements of the tridiagonal
matrix.
On normal exit, D contains the eigenvalues, in descending
order.
E (input/output) REAL array, dimension (N-1)
On entry, the (n-1) subdiagonal elements of the tridiagonal
matrix.
On exit, E has been destroyed.
Z (input/output) REAL array, dimension (LDZ, N)
On entry, if COMPZ = 'V', the orthogonal matrix used in the
reduction to tridiagonal form.
On exit, if COMPZ = 'V', the orthonormal eigenvectors of the
original symmetric matrix;
if COMPZ = 'I', the orthonormal eigenvectors of the
tridiagonal matrix.
If INFO > 0 on exit, Z contains the eigenvectors associated
with only the stored eigenvalues.
If COMPZ = 'N', then Z is not referenced.
LDZ (input) INTEGER
The leading dimension of the array Z. LDZ >= 1, and if
COMPZ = 'V' or 'I', LDZ >= max(1,N).
WORK (workspace) REAL array, dimension (4*N)
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: if INFO = i, and i is:
<= N the Cholesky factorization of the matrix could
not be performed because the i-th principal minor
was not positive definite.
> N the SVD algorithm failed to converge;
if INFO = N+i, i off-diagonal elements of the
bidiagonal factor did not converge to zero.
=====================================================================
Test the input parameters.
Parameter adjustments */
--d__;
--e;
z_dim1 = *ldz;
z_offset = 1 + z_dim1 * 1;
z__ -= z_offset;
--work;
/* Function Body */
*info = 0;
if (lsame_(compz, "N")) {
icompz = 0;
} else if (lsame_(compz, "V")) {
icompz = 1;
} else if (lsame_(compz, "I")) {
icompz = 2;
} else {
icompz = -1;
}
if (icompz < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*ldz < 1 || icompz > 0 && *ldz < max(1,*n)) {
*info = -6;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SPTEQR", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
if (*n == 1) {
if (icompz > 0) {
z___ref(1, 1) = 1.f;
}
return 0;
}
if (icompz == 2) {
slaset_("Full", n, n, &c_b7, &c_b8, &z__[z_offset], ldz);
}
/* Call SPTTRF to factor the matrix. */
latime_1.ops = latime_1.ops + *n * 5 - 4;
spttrf_(n, &d__[1], &e[1], info);
if (*info != 0) {
return 0;
}
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
d__[i__] = sqrt(d__[i__]);
/* L10: */
}
i__1 = *n - 1;
for (i__ = 1; i__ <= i__1; ++i__) {
e[i__] *= d__[i__];
/* L20: */
}
/* Call SBDSQR to compute the singular values/vectors of the
bidiagonal factor. */
if (icompz > 0) {
nru = *n;
} else {
nru = 0;
}
sbdsqr_("Lower", n, &c__0, &nru, &c__0, &d__[1], &e[1], vt, &c__1, &z__[
z_offset], ldz, c__, &c__1, &work[1], info);
/* Square the singular values. */
if (*info == 0) {
latime_1.ops += *n;
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
d__[i__] *= d__[i__];
/* L30: */
}
} else {
*info = *n + *info;
}
return 0;
/* End of SPTEQR */
} /* spteqr_ */
int slasdq_(char *uplo, int *sqre, int *n, int *
ncvt, int *nru, int *ncc, float *d__, float *e, float *vt,
int *ldvt, float *u, int *ldu, float *c__, int *ldc, float *
work, int *info)
{
/* System generated locals */
int c_dim1, c_offset, u_dim1, u_offset, vt_dim1, vt_offset, i__1,
i__2;
/* Local variables */
int i__, j;
float r__, cs, sn;
int np1, isub;
float smin;
int sqre1;
extern int lsame_(char *, char *);
extern int slasr_(char *, char *, char *, int *,
int *, float *, float *, float *, int *);
int iuplo;
extern int sswap_(int *, float *, int *, float *,
int *), xerbla_(char *, int *), slartg_(float *,
float *, float *, float *, float *);
int rotate;
extern int sbdsqr_(char *, int *, int *, int
*, int *, float *, float *, float *, int *, float *, int *
, float *, int *, float *, int *);
/* -- LAPACK auxiliary routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SLASDQ computes the singular value decomposition (SVD) of a float */
/* (upper or lower) bidiagonal matrix with diagonal D and offdiagonal */
/* E, accumulating the transformations if desired. Letting B denote */
/* the input bidiagonal matrix, the algorithm computes orthogonal */
/* matrices Q and P such that B = Q * S * P' (P' denotes the transpose */
/* of P). The singular values S are overwritten on D. */
/* The input matrix U is changed to U * Q if desired. */
/* The input matrix VT is changed to P' * VT if desired. */
/* The input matrix C is changed to Q' * C if desired. */
/* See "Computing Small Singular Values of Bidiagonal Matrices With */
/* Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, */
/* LAPACK Working Note #3, for a detailed description of the algorithm. */
/* Arguments */
/* ========= */
/* UPLO (input) CHARACTER*1 */
/* On entry, UPLO specifies whether the input bidiagonal matrix */
/* is upper or lower bidiagonal, and wether it is square are */
/* not. */
/* UPLO = 'U' or 'u' B is upper bidiagonal. */
/* UPLO = 'L' or 'l' B is lower bidiagonal. */
/* SQRE (input) INTEGER */
/* = 0: then the input matrix is N-by-N. */
/* = 1: then the input matrix is N-by-(N+1) if UPLU = 'U' and */
/* (N+1)-by-N if UPLU = 'L'. */
/* The bidiagonal matrix has */
/* N = NL + NR + 1 rows and */
/* M = N + SQRE >= N columns. */
/* N (input) INTEGER */
/* On entry, N specifies the number of rows and columns */
/* in the matrix. N must be at least 0. */
/* NCVT (input) INTEGER */
/* On entry, NCVT specifies the number of columns of */
/* the matrix VT. NCVT must be at least 0. */
/* NRU (input) INTEGER */
/* On entry, NRU specifies the number of rows of */
/* the matrix U. NRU must be at least 0. */
/* NCC (input) INTEGER */
/* On entry, NCC specifies the number of columns of */
/* the matrix C. NCC must be at least 0. */
/* D (input/output) REAL array, dimension (N) */
/* On entry, D contains the diagonal entries of the */
/* bidiagonal matrix whose SVD is desired. On normal exit, */
/* D contains the singular values in ascending order. */
/* E (input/output) REAL array. */
/* dimension is (N-1) if SQRE = 0 and N if SQRE = 1. */
/* On entry, the entries of E contain the offdiagonal entries */
/* of the bidiagonal matrix whose SVD is desired. On normal */
/* exit, E will contain 0. If the algorithm does not converge, */
/* D and E will contain the diagonal and superdiagonal entries */
/* of a bidiagonal matrix orthogonally equivalent to the one */
/* given as input. */
/* VT (input/output) REAL array, dimension (LDVT, NCVT) */
/* On entry, contains a matrix which on exit has been */
/* premultiplied by P', dimension N-by-NCVT if SQRE = 0 */
/* and (N+1)-by-NCVT if SQRE = 1 (not referenced if NCVT=0). */
/* LDVT (input) INTEGER */
/* On entry, LDVT specifies the leading dimension of VT as */
/* declared in the calling (sub) program. LDVT must be at */
/* least 1. If NCVT is nonzero LDVT must also be at least N. */
/* U (input/output) REAL array, dimension (LDU, N) */
/* On entry, contains a matrix which on exit has been */
/* postmultiplied by Q, dimension NRU-by-N if SQRE = 0 */
/* and NRU-by-(N+1) if SQRE = 1 (not referenced if NRU=0). */
/* LDU (input) INTEGER */
/* On entry, LDU specifies the leading dimension of U as */
/* declared in the calling (sub) program. LDU must be at */
/* least MAX( 1, NRU ) . */
/* C (input/output) REAL array, dimension (LDC, NCC) */
/* On entry, contains an N-by-NCC matrix which on exit */
/* has been premultiplied by Q' dimension N-by-NCC if SQRE = 0 */
/* and (N+1)-by-NCC if SQRE = 1 (not referenced if NCC=0). */
/* LDC (input) INTEGER */
/* On entry, LDC specifies the leading dimension of C as */
/* declared in the calling (sub) program. LDC must be at */
/* least 1. If NCC is nonzero, LDC must also be at least N. */
/* WORK (workspace) REAL array, dimension (4*N) */
/* Workspace. Only referenced if one of NCVT, NRU, or NCC is */
/* nonzero, and if N is at least 2. */
/* INFO (output) INTEGER */
/* On exit, a value of 0 indicates a successful exit. */
/* If INFO < 0, argument number -INFO is illegal. */
/* If INFO > 0, the algorithm did not converge, and INFO */
/* specifies how many superdiagonals did not converge. */
/* Further Details */
/* =============== */
/* Based on contributions by */
/* Ming Gu and Huan Ren, Computer Science Division, University of */
/* California at Berkeley, USA */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
--d__;
--e;
vt_dim1 = *ldvt;
vt_offset = 1 + vt_dim1;
vt -= vt_offset;
u_dim1 = *ldu;
u_offset = 1 + u_dim1;
u -= u_offset;
c_dim1 = *ldc;
c_offset = 1 + c_dim1;
c__ -= c_offset;
--work;
/* Function Body */
*info = 0;
iuplo = 0;
if (lsame_(uplo, "U")) {
iuplo = 1;
}
if (lsame_(uplo, "L")) {
iuplo = 2;
}
if (iuplo == 0) {
*info = -1;
} else if (*sqre < 0 || *sqre > 1) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*ncvt < 0) {
*info = -4;
} else if (*nru < 0) {
*info = -5;
} else if (*ncc < 0) {
*info = -6;
} else if (*ncvt == 0 && *ldvt < 1 || *ncvt > 0 && *ldvt < MAX(1,*n)) {
*info = -10;
} else if (*ldu < MAX(1,*nru)) {
*info = -12;
} else if (*ncc == 0 && *ldc < 1 || *ncc > 0 && *ldc < MAX(1,*n)) {
*info = -14;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SLASDQ", &i__1);
return 0;
}
if (*n == 0) {
return 0;
}
/* ROTATE is true if any singular vectors desired, false otherwise */
rotate = *ncvt > 0 || *nru > 0 || *ncc > 0;
np1 = *n + 1;
sqre1 = *sqre;
/* If matrix non-square upper bidiagonal, rotate to be lower */
/* bidiagonal. The rotations are on the right. */
if (iuplo == 1 && sqre1 == 1) {
i__1 = *n - 1;
for (i__ = 1; i__ <= i__1; ++i__) {
slartg_(&d__[i__], &e[i__], &cs, &sn, &r__);
d__[i__] = r__;
e[i__] = sn * d__[i__ + 1];
d__[i__ + 1] = cs * d__[i__ + 1];
if (rotate) {
work[i__] = cs;
work[*n + i__] = sn;
}
/* L10: */
}
slartg_(&d__[*n], &e[*n], &cs, &sn, &r__);
d__[*n] = r__;
e[*n] = 0.f;
if (rotate) {
work[*n] = cs;
work[*n + *n] = sn;
}
iuplo = 2;
sqre1 = 0;
/* Update singular vectors if desired. */
if (*ncvt > 0) {
slasr_("L", "V", "F", &np1, ncvt, &work[1], &work[np1], &vt[
vt_offset], ldvt);
}
}
/* If matrix lower bidiagonal, rotate to be upper bidiagonal */
/* by applying Givens rotations on the left. */
if (iuplo == 2) {
i__1 = *n - 1;
for (i__ = 1; i__ <= i__1; ++i__) {
slartg_(&d__[i__], &e[i__], &cs, &sn, &r__);
d__[i__] = r__;
e[i__] = sn * d__[i__ + 1];
d__[i__ + 1] = cs * d__[i__ + 1];
if (rotate) {
work[i__] = cs;
work[*n + i__] = sn;
}
/* L20: */
}
/* If matrix (N+1)-by-N lower bidiagonal, one additional */
/* rotation is needed. */
if (sqre1 == 1) {
slartg_(&d__[*n], &e[*n], &cs, &sn, &r__);
d__[*n] = r__;
if (rotate) {
work[*n] = cs;
work[*n + *n] = sn;
}
}
/* Update singular vectors if desired. */
if (*nru > 0) {
if (sqre1 == 0) {
slasr_("R", "V", "F", nru, n, &work[1], &work[np1], &u[
u_offset], ldu);
} else {
slasr_("R", "V", "F", nru, &np1, &work[1], &work[np1], &u[
u_offset], ldu);
}
}
if (*ncc > 0) {
if (sqre1 == 0) {
slasr_("L", "V", "F", n, ncc, &work[1], &work[np1], &c__[
c_offset], ldc);
} else {
slasr_("L", "V", "F", &np1, ncc, &work[1], &work[np1], &c__[
c_offset], ldc);
}
}
}
/* Call SBDSQR to compute the SVD of the reduced float */
/* N-by-N upper bidiagonal matrix. */
sbdsqr_("U", n, ncvt, nru, ncc, &d__[1], &e[1], &vt[vt_offset], ldvt, &u[
u_offset], ldu, &c__[c_offset], ldc, &work[1], info);
/* Sort the singular values into ascending order (insertion sort on */
/* singular values, but only one transposition per singular vector) */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
/* Scan for smallest D(I). */
isub = i__;
smin = d__[i__];
i__2 = *n;
for (j = i__ + 1; j <= i__2; ++j) {
if (d__[j] < smin) {
isub = j;
smin = d__[j];
}
/* L30: */
}
if (isub != i__) {
/* Swap singular values and vectors. */
d__[isub] = d__[i__];
d__[i__] = smin;
if (*ncvt > 0) {
sswap_(ncvt, &vt[isub + vt_dim1], ldvt, &vt[i__ + vt_dim1],
ldvt);
}
if (*nru > 0) {
sswap_(nru, &u[isub * u_dim1 + 1], &c__1, &u[i__ * u_dim1 + 1]
, &c__1);
}
if (*ncc > 0) {
sswap_(ncc, &c__[isub + c_dim1], ldc, &c__[i__ + c_dim1], ldc)
;
}
}
/* L40: */
}
return 0;
/* End of SLASDQ */
} /* slasdq_ */
doublereal sqrt12_(integer *m, integer *n, real *a, integer *lda, real *s,
real *work, integer *lwork)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2;
real ret_val;
/* Local variables */
integer i__, j, mn, iscl, info;
real anrm;
extern doublereal snrm2_(integer *, real *, integer *), sasum_(integer *,
real *, integer *);
real dummy[1];
extern /* Subroutine */ int saxpy_(integer *, real *, real *, integer *,
real *, integer *), sgebd2_(integer *, integer *, real *, integer
*, real *, real *, real *, real *, real *, integer *), slabad_(
real *, real *);
extern doublereal slamch_(char *), slange_(char *, integer *,
integer *, real *, integer *, real *);
extern /* Subroutine */ int xerbla_(char *, integer *);
real bignum;
extern /* Subroutine */ int slascl_(char *, integer *, integer *, real *,
real *, integer *, integer *, real *, integer *, integer *), slaset_(char *, integer *, integer *, real *, real *,
real *, integer *), sbdsqr_(char *, integer *, integer *,
integer *, integer *, real *, real *, real *, integer *, real *,
integer *, real *, integer *, real *, integer *);
real smlnum, nrmsvl;
/* -- LAPACK test routine (version 3.1.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* January 2007 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SQRT12 computes the singular values `svlues' of the upper trapezoid */
/* of A(1:M,1:N) and returns the ratio */
/* || s - svlues||/(||svlues||*eps*max(M,N)) */
/* Arguments */
/* ========= */
/* M (input) INTEGER */
/* The number of rows of the matrix A. */
/* N (input) INTEGER */
/* The number of columns of the matrix A. */
/* A (input) REAL array, dimension (LDA,N) */
/* The M-by-N matrix A. Only the upper trapezoid is referenced. */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. */
/* S (input) REAL array, dimension (min(M,N)) */
/* The singular values of the matrix A. */
/* WORK (workspace) REAL array, dimension (LWORK) */
/* LWORK (input) INTEGER */
/* The length of the array WORK. LWORK >= max(M*N + 4*min(M,N) + */
/* max(M,N), M*N+2*MIN( M, N )+4*N). */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. Executable Statements .. */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--s;
--work;
/* Function Body */
ret_val = 0.f;
/* Test that enough workspace is supplied */
/* Computing MAX */
i__1 = *m * *n + (min(*m,*n) << 2) + max(*m,*n), i__2 = *m * *n + (min(*m,
*n) << 1) + (*n << 2);
if (*lwork < max(i__1,i__2)) {
xerbla_("SQRT12", &c__7);
return ret_val;
}
/* Quick return if possible */
mn = min(*m,*n);
if ((real) mn <= 0.f) {
return ret_val;
}
nrmsvl = snrm2_(&mn, &s[1], &c__1);
/* Copy upper triangle of A into work */
slaset_("Full", m, n, &c_b6, &c_b6, &work[1], m);
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = min(j,*m);
for (i__ = 1; i__ <= i__2; ++i__) {
work[(j - 1) * *m + i__] = a[i__ + j * a_dim1];
/* L10: */
}
/* L20: */
}
/* Get machine parameters */
smlnum = slamch_("S") / slamch_("P");
bignum = 1.f / smlnum;
slabad_(&smlnum, &bignum);
/* Scale work if max entry outside range [SMLNUM,BIGNUM] */
anrm = slange_("M", m, n, &work[1], m, dummy);
iscl = 0;
if (anrm > 0.f && anrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
slascl_("G", &c__0, &c__0, &anrm, &smlnum, m, n, &work[1], m, &info);
iscl = 1;
} else if (anrm > bignum) {
/* Scale matrix norm down to BIGNUM */
slascl_("G", &c__0, &c__0, &anrm, &bignum, m, n, &work[1], m, &info);
iscl = 1;
}
if (anrm != 0.f) {
/* Compute SVD of work */
sgebd2_(m, n, &work[1], m, &work[*m * *n + 1], &work[*m * *n + mn + 1]
, &work[*m * *n + (mn << 1) + 1], &work[*m * *n + mn * 3 + 1],
&work[*m * *n + (mn << 2) + 1], &info);
sbdsqr_("Upper", &mn, &c__0, &c__0, &c__0, &work[*m * *n + 1], &work[*
m * *n + mn + 1], dummy, &mn, dummy, &c__1, dummy, &mn, &work[
*m * *n + (mn << 1) + 1], &info);
if (iscl == 1) {
if (anrm > bignum) {
slascl_("G", &c__0, &c__0, &bignum, &anrm, &mn, &c__1, &work[*
m * *n + 1], &mn, &info);
}
if (anrm < smlnum) {
slascl_("G", &c__0, &c__0, &smlnum, &anrm, &mn, &c__1, &work[*
m * *n + 1], &mn, &info);
}
}
} else {
i__1 = mn;
for (i__ = 1; i__ <= i__1; ++i__) {
work[*m * *n + i__] = 0.f;
/* L30: */
}
}
/* Compare s and singular values of work */
saxpy_(&mn, &c_b33, &s[1], &c__1, &work[*m * *n + 1], &c__1);
ret_val = sasum_(&mn, &work[*m * *n + 1], &c__1) / (slamch_("Epsilon") * (real) max(*m,*n));
if (nrmsvl != 0.f) {
ret_val /= nrmsvl;
}
return ret_val;
/* End of SQRT12 */
} /* sqrt12_ */
doublereal sqrt12_(integer *m, integer *n, real *a, integer *lda, real *s,
real *work, integer *lwork)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2;
real ret_val;
/* Local variables */
static integer iscl, info;
static real anrm;
extern doublereal snrm2_(integer *, real *, integer *);
static integer i__, j;
extern doublereal sasum_(integer *, real *, integer *);
static real dummy[1];
extern /* Subroutine */ int saxpy_(integer *, real *, real *, integer *,
real *, integer *), sgebd2_(integer *, integer *, real *, integer
*, real *, real *, real *, real *, real *, integer *), slabad_(
real *, real *);
static integer mn;
extern doublereal slamch_(char *), slange_(char *, integer *,
integer *, real *, integer *, real *);
extern /* Subroutine */ int xerbla_(char *, integer *);
static real bignum;
extern /* Subroutine */ int slascl_(char *, integer *, integer *, real *,
real *, integer *, integer *, real *, integer *, integer *), slaset_(char *, integer *, integer *, real *, real *,
real *, integer *), sbdsqr_(char *, integer *, integer *,
integer *, integer *, real *, real *, real *, integer *, real *,
integer *, real *, integer *, real *, integer *);
static real smlnum, nrmsvl;
#define a_ref(a_1,a_2) a[(a_2)*a_dim1 + a_1]
/* -- LAPACK test routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
September 30, 1994
Purpose
=======
SQRT12 computes the singular values `svlues' of the upper trapezoid
of A(1:M,1:N) and returns the ratio
|| s - svlues||/(||svlues||*eps*max(M,N))
Arguments
=========
M (input) INTEGER
The number of rows of the matrix A.
N (input) INTEGER
The number of columns of the matrix A.
A (input) REAL array, dimension (LDA,N)
The M-by-N matrix A. Only the upper trapezoid is referenced.
LDA (input) INTEGER
The leading dimension of the array A.
S (input) REAL array, dimension (min(M,N))
The singular values of the matrix A.
WORK (workspace) REAL array, dimension (LWORK)
LWORK (input) INTEGER
The length of the array WORK. LWORK >= M*N + 4*min(M,N) +
max(M,N).
=====================================================================
Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
--s;
--work;
/* Function Body */
ret_val = 0.f;
/* Test that enough workspace is supplied */
if (*lwork < *m * *n + (min(*m,*n) << 2) + max(*m,*n)) {
xerbla_("SQRT12", &c__7);
return ret_val;
}
/* Quick return if possible */
mn = min(*m,*n);
if ((real) mn <= 0.f) {
return ret_val;
}
nrmsvl = snrm2_(&mn, &s[1], &c__1);
/* Copy upper triangle of A into work */
slaset_("Full", m, n, &c_b6, &c_b6, &work[1], m);
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = min(j,*m);
for (i__ = 1; i__ <= i__2; ++i__) {
work[(j - 1) * *m + i__] = a_ref(i__, j);
/* L10: */
}
/* L20: */
}
/* Get machine parameters */
smlnum = slamch_("S") / slamch_("P");
bignum = 1.f / smlnum;
slabad_(&smlnum, &bignum);
/* Scale work if max entry outside range [SMLNUM,BIGNUM] */
anrm = slange_("M", m, n, &work[1], m, dummy);
iscl = 0;
if (anrm > 0.f && anrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
slascl_("G", &c__0, &c__0, &anrm, &smlnum, m, n, &work[1], m, &info);
iscl = 1;
} else if (anrm > bignum) {
/* Scale matrix norm down to BIGNUM */
slascl_("G", &c__0, &c__0, &anrm, &bignum, m, n, &work[1], m, &info);
iscl = 1;
}
if (anrm != 0.f) {
/* Compute SVD of work */
sgebd2_(m, n, &work[1], m, &work[*m * *n + 1], &work[*m * *n + mn + 1]
, &work[*m * *n + (mn << 1) + 1], &work[*m * *n + mn * 3 + 1],
&work[*m * *n + (mn << 2) + 1], &info);
sbdsqr_("Upper", &mn, &c__0, &c__0, &c__0, &work[*m * *n + 1], &work[*
m * *n + mn + 1], dummy, &mn, dummy, &c__1, dummy, &mn, &work[
*m * *n + (mn << 1) + 1], &info);
if (iscl == 1) {
if (anrm > bignum) {
slascl_("G", &c__0, &c__0, &bignum, &anrm, &mn, &c__1, &work[*
m * *n + 1], &mn, &info);
}
if (anrm < smlnum) {
slascl_("G", &c__0, &c__0, &smlnum, &anrm, &mn, &c__1, &work[*
m * *n + 1], &mn, &info);
}
}
} else {
i__1 = mn;
for (i__ = 1; i__ <= i__1; ++i__) {
work[*m * *n + i__] = 0.f;
/* L30: */
}
}
/* Compare s and singular values of work */
saxpy_(&mn, &c_b33, &s[1], &c__1, &work[*m * *n + 1], &c__1);
ret_val = sasum_(&mn, &work[*m * *n + 1], &c__1) / (slamch_("Epsilon") * (real) max(*m,*n));
if (nrmsvl != 0.f) {
ret_val /= nrmsvl;
}
return ret_val;
/* End of SQRT12 */
} /* sqrt12_ */
int main( int argc, char** argv ) {
FLA_Datatype datatype = TESTTYPE;
FLA_Obj A, A_flame, A_lapack, C;
int m;
FLA_Error init_result;
FLA_Obj TU, TV, U_flame, V_flame, d_flame, e_flame, B_flame;
FLA_Obj tauq, taup, d_lapack, e_lapack, U_lapack, V_lapack, W, B_lapack;
testtype *buff_tauq, *buff_taup, *buff_d_lapack, *buff_e_lapack,
*buff_W, *buff_A_lapack, *buff_U_lapack, *buff_V_lapack;
int lwork, info, is_flame;
if ( argc == 3 ) {
m = atoi(argv[1]);
is_flame = atoi(argv[2]);
} else {
fprintf(stderr, " \n");
fprintf(stderr, "Usage: %s m is_flame\n", argv[0]);
fprintf(stderr, " m : matrix length\n");
fprintf(stderr, " is_flame : 1 yes, 0 no\n");
fprintf(stderr, " \n");
return -1;
}
if ( m == 0 )
return 0;
FLA_Init_safe( &init_result );
fprintf( stdout, "lapack2flame: %d x %d: \n", m, m);
FLA_Obj_create( datatype, m, m, 0, 0, &A );
FLA_Random_matrix( A );
FLA_Obj_create_copy_of( FLA_NO_TRANSPOSE, A, &A_flame );
FLA_Obj_create_copy_of( FLA_NO_TRANSPOSE, A, &A_lapack );
FLA_Obj_create( datatype, m, m, 0, 0, &C );
FLA_Random_matrix( C );
if ( is_flame ) {
fprintf( stdout, " flame executed\n");
FLA_Bidiag_UT_create_T( A_flame, &TU, &TV );
FLA_Bidiag_UT( A_flame, TU, TV );
FLA_Obj_create_copy_of( FLA_NO_TRANSPOSE, A_flame, &U_flame );
FLA_Obj_create_copy_of( FLA_NO_TRANSPOSE, A_flame, &V_flame );
FLA_Bidiag_UT_form_U( U_flame, TU, U_flame );
FLA_Bidiag_UT_form_V( V_flame, TV, V_flame );
FLA_Obj_create( datatype, m, 1, 0, 0, &d_flame );
FLA_Obj_create( datatype, m - 1, 1, 0, 0, &e_flame );
FLA_Bidiag_UT_extract_diagonals( A_flame, d_flame, e_flame );
FLA_Obj_create( datatype, m, m, 0, 0, &B_flame ); FLA_Set( FLA_ZERO, B_flame );
{
FLA_Obj BTL, BTR, BBL, BBR;
FLA_Part_2x2( B_flame, &BTL, &BTR, &BBL, &BBR, 1,1, FLA_BL );
FLA_Set_diagonal_matrix( d_flame, B_flame );
FLA_Set_diagonal_matrix( e_flame, BTR );
}
if (1) {
fprintf( stdout, " - FLAME ----------\n");
FLA_Obj_fshow( stdout, " - Given A - ", A, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - A - ", A_flame, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - U - ", U_flame, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - V - ", V_flame, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - d - ", d_flame, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - e - ", e_flame, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - B - ", B_flame, "% 6.4e", "------");
}
} else {
fprintf( stdout, " lapack executed\n");
FLA_Obj_create( datatype, m, 1, 0, 0, &tauq );
FLA_Obj_create( datatype, m, 1, 0, 0, &taup );
FLA_Obj_create( datatype, m, 1, 0, 0, &d_lapack );
FLA_Obj_create( datatype, m - 1, 1, 0, 0, &e_lapack );
buff_A_lapack = (testtype*)FLA_Obj_buffer_at_view( A_lapack );
buff_tauq = (testtype*)FLA_Obj_buffer_at_view( tauq );
buff_taup = (testtype*)FLA_Obj_buffer_at_view( taup );
buff_d_lapack = (testtype*)FLA_Obj_buffer_at_view( d_lapack );
buff_e_lapack = (testtype*)FLA_Obj_buffer_at_view( e_lapack );
lwork = 32*m;
FLA_Obj_create( datatype, lwork, 1, 0, 0, &W );
buff_W = (testtype*)FLA_Obj_buffer_at_view( W );
sgebrd_( &m, &m,
buff_A_lapack, &m,
buff_d_lapack,
buff_e_lapack,
buff_tauq,
buff_taup,
buff_W,
&lwork,
&info );
FLA_Obj_create( datatype, m, m, 0, 0, &U_lapack );
FLA_Obj_create( datatype, m, m, 0, 0, &V_lapack );
FLA_Copy( A_lapack, U_lapack );
FLA_Copy( A_lapack, V_lapack );
buff_U_lapack = (testtype*)FLA_Obj_buffer_at_view( U_lapack );
buff_V_lapack = (testtype*)FLA_Obj_buffer_at_view( V_lapack );
sorgbr_( "Q", &m, &m, &m,
buff_U_lapack, &m,
buff_tauq,
buff_W,
&lwork,
&info );
sorgbr_( "P", &m, &m, &m,
buff_V_lapack, &m,
buff_taup,
buff_W,
&lwork,
&info );
FLA_Obj_create( datatype, m, m, 0, 0, &B_lapack ); FLA_Set( FLA_ZERO, B_lapack );
{
FLA_Obj BTL, BTR, BBL, BBR;
FLA_Part_2x2( B_lapack, &BTL, &BTR, &BBL, &BBR, 1,1, FLA_BL );
FLA_Set_diagonal_matrix( d_lapack, B_lapack );
FLA_Set_diagonal_matrix( e_lapack, BTR );
}
FLA_Obj_free( &W );
if (1) {
fprintf( stdout, " - LAPACK ----------\n");
FLA_Obj_fshow( stdout, " - Given A - ", A, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - A - ", A_lapack, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - U - ", U_lapack, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - V - ", V_lapack, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - d - ", d_lapack, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - e - ", e_lapack, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - B - ", B_lapack, "% 6.4e", "------");
}
}
{
testtype dummy;
int zero = 0, one = 1;
FLA_Obj D_lapack;
FLA_Obj_create_conf_to( FLA_NO_TRANSPOSE, A, &D_lapack ); FLA_Set( FLA_ZERO, D_lapack );
if ( is_flame ) {
buff_d_lapack = (testtype*)FLA_Obj_buffer_at_view( d_flame );
buff_e_lapack = (testtype*)FLA_Obj_buffer_at_view( e_flame );
buff_U_lapack = (testtype*)FLA_Obj_buffer_at_view( U_flame );
buff_V_lapack = (testtype*)FLA_Obj_buffer_at_view( V_flame );
}
FLA_Obj_create( datatype, 4*m, 1, 0, 0, &W );
buff_W = (testtype*)FLA_Obj_buffer_at_view( W );
sbdsqr_( "U", &m, &m, &m, &zero,
buff_d_lapack, buff_e_lapack,
buff_V_lapack, &m,
buff_U_lapack, &m,
&dummy, &one,
buff_W, &info );
FLA_Obj_free( &W );
if (info != 0)
printf( " Error info = %d\n", info );
if ( is_flame )
FLA_Set_diagonal_matrix( d_flame, D_lapack );
else
FLA_Set_diagonal_matrix( d_lapack, D_lapack );
if ( is_flame ) {
fprintf( stdout, " - FLAME ----------\n");
FLA_Obj_fshow( stdout, " - U - ", U_flame, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - V - ", V_flame, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - d - ", d_flame, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - e - ", e_flame, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - D - ", D_lapack, "% 6.4e", "------");
} else {
fprintf( stdout, " - LAPACK ----------\n");
FLA_Obj_fshow( stdout, " - U - ", U_lapack, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - V - ", V_lapack, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - d - ", d_lapack, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - e - ", e_lapack, "% 6.4e", "------");
FLA_Obj_fshow( stdout, " - D - ", D_lapack, "% 6.4e", "------");
}
FLA_Obj_free( &D_lapack );
}
if ( is_flame ) {
FLA_Obj_free( &TU );
FLA_Obj_free( &TV );
FLA_Obj_free( &U_flame );
FLA_Obj_free( &V_flame );
FLA_Obj_free( &d_flame );
FLA_Obj_free( &e_flame );
FLA_Obj_free( &B_flame );
} else {
FLA_Obj_free( &tauq );
FLA_Obj_free( &taup );
FLA_Obj_free( &d_lapack );
FLA_Obj_free( &e_lapack );
FLA_Obj_free( &U_lapack );
FLA_Obj_free( &V_lapack );
FLA_Obj_free( &B_lapack );
}
FLA_Obj_free( &A );
FLA_Obj_free( &A_flame );
FLA_Obj_free( &A_lapack );
FLA_Obj_free( &C );
FLA_Finalize_safe( init_result );
}
/* Subroutine */ int sgelss_(integer *m, integer *n, integer *nrhs, real *a,
integer *lda, real *b, integer *ldb, real *s, real *rcond, integer *
rank, real *work, integer *lwork, integer *info)
{
/* -- LAPACK driver routine (version 2.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
September 30, 1994
Purpose
=======
SGELSS computes the minimum norm solution to a real linear least
squares problem:
Minimize 2-norm(| b - A*x |).
using the singular value decomposition (SVD) of A. A is an M-by-N
matrix which may be rank-deficient.
Several right hand side vectors b and solution vectors x can be
handled in a single call; they are stored as the columns of the
M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix
X.
The effective rank of A is determined by treating as zero those
singular values which are less than RCOND times the largest singular
value.
Arguments
=========
M (input) INTEGER
The number of rows of the matrix A. M >= 0.
N (input) INTEGER
The number of columns of the matrix A. N >= 0.
NRHS (input) INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices B and X. NRHS >= 0.
A (input/output) REAL array, dimension (LDA,N)
On entry, the M-by-N matrix A.
On exit, the first min(m,n) rows of A are overwritten with
its right singular vectors, stored rowwise.
LDA (input) INTEGER
The leading dimension of the array A. LDA >= max(1,M).
B (input/output) REAL array, dimension (LDB,NRHS)
On entry, the M-by-NRHS right hand side matrix B.
On exit, B is overwritten by the N-by-NRHS solution
matrix X. If m >= n and RANK = n, the residual
sum-of-squares for the solution in the i-th column is given
by the sum of squares of elements n+1:m in that column.
LDB (input) INTEGER
The leading dimension of the array B. LDB >= max(1,max(M,N)).
S (output) REAL array, dimension (min(M,N))
The singular values of A in decreasing order.
The condition number of A in the 2-norm = S(1)/S(min(m,n)).
RCOND (input) REAL
RCOND is used to determine the effective rank of A.
Singular values S(i) <= RCOND*S(1) are treated as zero.
If RCOND < 0, machine precision is used instead.
RANK (output) INTEGER
The effective rank of A, i.e., the number of singular values
which are greater than RCOND*S(1).
WORK (workspace/output) REAL array, dimension (LWORK)
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK. LWORK >= 1, and also:
LWORK >= 3*min(M,N) + max( 2*min(M,N), max(M,N), NRHS )
For good performance, LWORK should generally be larger.
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: the algorithm for computing the SVD failed to converge;
if INFO = i, i off-diagonal elements of an intermediate
bidiagonal form did not converge to zero.
=====================================================================
Test the input arguments
Parameter adjustments
Function Body */
/* Table of constant values */
static integer c__6 = 6;
static integer c_n1 = -1;
static integer c__1 = 1;
static integer c__0 = 0;
static real c_b74 = 0.f;
static real c_b108 = 1.f;
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3, i__4;
real r__1;
/* Local variables */
static real anrm, bnrm;
static integer itau;
static real vdum[1];
static integer i, iascl, ibscl, chunk;
extern /* Subroutine */ int sgemm_(char *, char *, integer *, integer *,
integer *, real *, real *, integer *, real *, integer *, real *,
real *, integer *);
static real sfmin;
static integer minmn, maxmn;
extern /* Subroutine */ int sgemv_(char *, integer *, integer *, real *,
real *, integer *, real *, integer *, real *, real *, integer *);
static integer itaup, itauq;
extern /* Subroutine */ int srscl_(integer *, real *, real *, integer *);
static integer mnthr, iwork;
extern /* Subroutine */ int scopy_(integer *, real *, integer *, real *,
integer *);
static integer bl, ie, il;
extern /* Subroutine */ int slabad_(real *, real *);
static integer mm, bdspac;
extern /* Subroutine */ int sgebrd_(integer *, integer *, real *, integer
*, real *, real *, real *, real *, real *, integer *, integer *);
extern doublereal slamch_(char *), slange_(char *, integer *,
integer *, real *, integer *, real *);
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
static real bignum;
extern /* Subroutine */ int sgelqf_(integer *, integer *, real *, integer
*, real *, real *, integer *, integer *), slascl_(char *, integer
*, integer *, real *, real *, integer *, integer *, real *,
integer *, integer *), sgeqrf_(integer *, integer *, real
*, integer *, real *, real *, integer *, integer *), slacpy_(char
*, integer *, integer *, real *, integer *, real *, integer *), slaset_(char *, integer *, integer *, real *, real *,
real *, integer *), sbdsqr_(char *, integer *, integer *,
integer *, integer *, real *, real *, real *, integer *, real *,
integer *, real *, integer *, real *, integer *), sorgbr_(
char *, integer *, integer *, integer *, real *, integer *, real *
, real *, integer *, integer *);
static integer ldwork;
extern /* Subroutine */ int sormbr_(char *, char *, char *, integer *,
integer *, integer *, real *, integer *, real *, real *, integer *
, real *, integer *, integer *);
static integer minwrk, maxwrk;
static real smlnum;
extern /* Subroutine */ int sormlq_(char *, char *, integer *, integer *,
integer *, real *, integer *, real *, real *, integer *, real *,
integer *, integer *), sormqr_(char *, char *,
integer *, integer *, integer *, real *, integer *, real *, real *
, integer *, real *, integer *, integer *);
static real eps, thr;
#define S(I) s[(I)-1]
#define WORK(I) work[(I)-1]
#define A(I,J) a[(I)-1 + ((J)-1)* ( *lda)]
#define B(I,J) b[(I)-1 + ((J)-1)* ( *ldb)]
*info = 0;
minmn = min(*m,*n);
maxmn = max(*m,*n);
mnthr = ilaenv_(&c__6, "SGELSS", " ", m, n, nrhs, &c_n1, 6L, 1L);
if (*m < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*nrhs < 0) {
*info = -3;
} else if (*lda < max(1,*m)) {
*info = -5;
} else if (*ldb < max(1,maxmn)) {
*info = -7;
}
/* Compute workspace
(Note: Comments in the code beginning "Workspace:" describe the
minimal amount of workspace needed at that point in the code,
as well as the preferred amount for good performance.
NB refers to the optimal block size for the immediately
following subroutine, as returned by ILAENV.) */
minwrk = 1;
if (*info == 0 && *lwork >= 1) {
maxwrk = 0;
mm = *m;
if (*m >= *n && *m >= mnthr) {
/* Path 1a - overdetermined, with many more rows than co
lumns */
mm = *n;
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *n * ilaenv_(&c__1, "SGEQRF", " ", m,
n, &c_n1, &c_n1, 6L, 1L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *nrhs * ilaenv_(&c__1, "SORMQR", "LT",
m, nrhs, n, &c_n1, 6L, 2L);
maxwrk = max(i__1,i__2);
}
if (*m >= *n) {
/* Path 1 - overdetermined or exactly determined
Compute workspace neede for SBDSQR
Computing MAX */
i__1 = 1, i__2 = *n * 5 - 4;
bdspac = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + (mm + *n) * ilaenv_(&c__1, "SGEBRD"
, " ", &mm, n, &c_n1, &c_n1, 6L, 1L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + *nrhs * ilaenv_(&c__1, "SORMBR",
"QLT", &mm, nrhs, n, &c_n1, 6L, 3L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + (*n - 1) * ilaenv_(&c__1, "SORGBR",
"P", n, n, n, &c_n1, 6L, 1L);
maxwrk = max(i__1,i__2);
maxwrk = max(maxwrk,bdspac);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * *nrhs;
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = *n * 3 + mm, i__2 = *n * 3 + *nrhs, i__1 = max(i__1,i__2);
minwrk = max(i__1,bdspac);
maxwrk = max(minwrk,maxwrk);
}
if (*n > *m) {
/* Compute workspace neede for SBDSQR
Computing MAX */
i__1 = 1, i__2 = *m * 5 - 4;
bdspac = max(i__1,i__2);
/* Computing MAX */
i__1 = *m * 3 + *nrhs, i__2 = *m * 3 + *n, i__1 = max(i__1,i__2);
minwrk = max(i__1,bdspac);
if (*n >= mnthr) {
/* Path 2a - underdetermined, with many more colu
mns
than rows */
maxwrk = *m + *m * ilaenv_(&c__1, "SGELQF", " ", m, n, &c_n1,
&c_n1, 6L, 1L);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + (*m << 1) *
ilaenv_(&c__1, "SGEBRD", " ", m, m, &c_n1, &c_n1, 6L,
1L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + *nrhs * ilaenv_(&
c__1, "SORMBR", "QLT", m, nrhs, m, &c_n1, 6L, 3L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + (*m - 1) *
ilaenv_(&c__1, "SORGBR", "P", m, m, m, &c_n1, 6L, 1L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + *m + bdspac;
maxwrk = max(i__1,i__2);
if (*nrhs > 1) {
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + *m + *m * *nrhs;
maxwrk = max(i__1,i__2);
} else {
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 1);
maxwrk = max(i__1,i__2);
}
/* Computing MAX */
i__1 = maxwrk, i__2 = *m + *nrhs * ilaenv_(&c__1, "SORMLQ",
"LT", n, nrhs, m, &c_n1, 6L, 2L);
maxwrk = max(i__1,i__2);
} else {
/* Path 2 - underdetermined */
maxwrk = *m * 3 + (*n + *m) * ilaenv_(&c__1, "SGEBRD", " ", m,
n, &c_n1, &c_n1, 6L, 1L);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + *nrhs * ilaenv_(&c__1, "SORMBR"
, "QLT", m, nrhs, m, &c_n1, 6L, 3L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + *m * ilaenv_(&c__1, "SORGBR",
"P", m, n, m, &c_n1, 6L, 1L);
maxwrk = max(i__1,i__2);
maxwrk = max(maxwrk,bdspac);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * *nrhs;
maxwrk = max(i__1,i__2);
}
}
maxwrk = max(minwrk,maxwrk);
WORK(1) = (real) maxwrk;
}
minwrk = max(minwrk,1);
if (*lwork < minwrk) {
*info = -12;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SGELSS", &i__1);
return 0;
}
/* Quick return if possible */
if (*m == 0 || *n == 0) {
*rank = 0;
return 0;
}
/* Get machine parameters */
eps = slamch_("P");
sfmin = slamch_("S");
smlnum = sfmin / eps;
bignum = 1.f / smlnum;
slabad_(&smlnum, &bignum);
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = slange_("M", m, n, &A(1,1), lda, &WORK(1));
iascl = 0;
if (anrm > 0.f && anrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
slascl_("G", &c__0, &c__0, &anrm, &smlnum, m, n, &A(1,1), lda,
info);
iascl = 1;
} else if (anrm > bignum) {
/* Scale matrix norm down to BIGNUM */
slascl_("G", &c__0, &c__0, &anrm, &bignum, m, n, &A(1,1), lda,
info);
iascl = 2;
} else if (anrm == 0.f) {
/* VISMatrix all zero. Return zero solution. */
i__1 = max(*m,*n);
slaset_("F", &i__1, nrhs, &c_b74, &c_b74, &B(1,1), ldb);
slaset_("F", &minmn, &c__1, &c_b74, &c_b74, &S(1), &c__1);
*rank = 0;
goto L70;
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = slange_("M", m, nrhs, &B(1,1), ldb, &WORK(1));
ibscl = 0;
if (bnrm > 0.f && bnrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
slascl_("G", &c__0, &c__0, &bnrm, &smlnum, m, nrhs, &B(1,1), ldb,
info);
ibscl = 1;
} else if (bnrm > bignum) {
/* Scale matrix norm down to BIGNUM */
slascl_("G", &c__0, &c__0, &bnrm, &bignum, m, nrhs, &B(1,1), ldb,
info);
ibscl = 2;
}
/* Overdetermined case */
if (*m >= *n) {
/* Path 1 - overdetermined or exactly determined */
mm = *m;
if (*m >= mnthr) {
/* Path 1a - overdetermined, with many more rows than co
lumns */
mm = *n;
itau = 1;
iwork = itau + *n;
/* Compute A=Q*R
(Workspace: need 2*N, prefer N+N*NB) */
i__1 = *lwork - iwork + 1;
sgeqrf_(m, n, &A(1,1), lda, &WORK(itau), &WORK(iwork), &i__1,
info);
/* Multiply B by transpose(Q)
(Workspace: need N+NRHS, prefer N+NRHS*NB) */
i__1 = *lwork - iwork + 1;
sormqr_("L", "T", m, nrhs, n, &A(1,1), lda, &WORK(itau), &B(1,1), ldb, &WORK(iwork), &i__1, info);
/* Zero out below R */
if (*n > 1) {
i__1 = *n - 1;
i__2 = *n - 1;
slaset_("L", &i__1, &i__2, &c_b74, &c_b74, &A(2,1),
lda);
}
}
ie = 1;
itauq = ie + *n;
itaup = itauq + *n;
iwork = itaup + *n;
/* Bidiagonalize R in A
(Workspace: need 3*N+MM, prefer 3*N+(MM+N)*NB) */
i__1 = *lwork - iwork + 1;
sgebrd_(&mm, n, &A(1,1), lda, &S(1), &WORK(ie), &WORK(itauq), &
WORK(itaup), &WORK(iwork), &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors of R
(Workspace: need 3*N+NRHS, prefer 3*N+NRHS*NB) */
i__1 = *lwork - iwork + 1;
sormbr_("Q", "L", "T", &mm, nrhs, n, &A(1,1), lda, &WORK(itauq),
&B(1,1), ldb, &WORK(iwork), &i__1, info);
/* Generate right bidiagonalizing vectors of R in A
(Workspace: need 4*N-1, prefer 3*N+(N-1)*NB) */
i__1 = *lwork - iwork + 1;
sorgbr_("P", n, n, n, &A(1,1), lda, &WORK(itaup), &WORK(iwork), &
i__1, info);
iwork = ie + *n;
/* Perform bidiagonal QR iteration
multiply B by transpose of left singular vectors
compute right singular vectors in A
(Workspace: need BDSPAC) */
sbdsqr_("U", n, n, &c__0, nrhs, &S(1), &WORK(ie), &A(1,1), lda,
vdum, &c__1, &B(1,1), ldb, &WORK(iwork), info);
if (*info != 0) {
goto L70;
}
/* Multiply B by reciprocals of singular values
Computing MAX */
r__1 = *rcond * S(1);
thr = dmax(r__1,sfmin);
if (*rcond < 0.f) {
/* Computing MAX */
r__1 = eps * S(1);
thr = dmax(r__1,sfmin);
}
*rank = 0;
i__1 = *n;
for (i = 1; i <= *n; ++i) {
if (S(i) > thr) {
srscl_(nrhs, &S(i), &B(i,1), ldb);
++(*rank);
} else {
slaset_("F", &c__1, nrhs, &c_b74, &c_b74, &B(i,1), ldb);
}
/* L10: */
}
/* Multiply B by right singular vectors
(Workspace: need N, prefer N*NRHS) */
if (*lwork >= *ldb * *nrhs && *nrhs > 1) {
sgemm_("T", "N", n, nrhs, n, &c_b108, &A(1,1), lda, &B(1,1), ldb, &c_b74, &WORK(1), ldb);
slacpy_("G", n, nrhs, &WORK(1), ldb, &B(1,1), ldb);
} else if (*nrhs > 1) {
chunk = *lwork / *n;
i__1 = *nrhs;
i__2 = chunk;
for (i = 1; chunk < 0 ? i >= *nrhs : i <= *nrhs; i += chunk) {
/* Computing MIN */
i__3 = *nrhs - i + 1;
bl = min(i__3,chunk);
sgemm_("T", "N", n, &bl, n, &c_b108, &A(1,1), lda, &B(1,1), ldb, &c_b74, &WORK(1), n);
slacpy_("G", n, &bl, &WORK(1), n, &B(1,1), ldb);
/* L20: */
}
} else {
sgemv_("T", n, n, &c_b108, &A(1,1), lda, &B(1,1), &c__1,
&c_b74, &WORK(1), &c__1);
scopy_(n, &WORK(1), &c__1, &B(1,1), &c__1);
}
} else /* if(complicated condition) */ {
/* Computing MAX */
i__2 = *m, i__1 = (*m << 1) - 4, i__2 = max(i__2,i__1), i__2 = max(
i__2,*nrhs), i__1 = *n - *m * 3;
if (*n >= mnthr && *lwork >= (*m << 2) + *m * *m + max(i__2,i__1)) {
/* Path 2a - underdetermined, with many more columns than r
ows
and sufficient workspace for an efficient algorithm */
ldwork = *m;
/* Computing MAX
Computing MAX */
i__3 = *m, i__4 = (*m << 1) - 4, i__3 = max(i__3,i__4), i__3 =
max(i__3,*nrhs), i__4 = *n - *m * 3;
i__2 = (*m << 2) + *m * *lda + max(i__3,i__4), i__1 = *m * *lda +
*m + *m * *nrhs;
if (*lwork >= max(i__2,i__1)) {
ldwork = *lda;
}
itau = 1;
iwork = *m + 1;
/* Compute A=L*Q
(Workspace: need 2*M, prefer M+M*NB) */
i__2 = *lwork - iwork + 1;
sgelqf_(m, n, &A(1,1), lda, &WORK(itau), &WORK(iwork), &i__2,
info);
il = iwork;
/* Copy L to WORK(IL), zeroing out above it */
slacpy_("L", m, m, &A(1,1), lda, &WORK(il), &ldwork);
i__2 = *m - 1;
i__1 = *m - 1;
slaset_("U", &i__2, &i__1, &c_b74, &c_b74, &WORK(il + ldwork), &
ldwork);
ie = il + ldwork * *m;
itauq = ie + *m;
itaup = itauq + *m;
iwork = itaup + *m;
/* Bidiagonalize L in WORK(IL)
(Workspace: need M*M+5*M, prefer M*M+4*M+2*M*NB) */
i__2 = *lwork - iwork + 1;
sgebrd_(m, m, &WORK(il), &ldwork, &S(1), &WORK(ie), &WORK(itauq),
&WORK(itaup), &WORK(iwork), &i__2, info);
/* Multiply B by transpose of left bidiagonalizing vectors
of L
(Workspace: need M*M+4*M+NRHS, prefer M*M+4*M+NRHS*NB)
*/
i__2 = *lwork - iwork + 1;
sormbr_("Q", "L", "T", m, nrhs, m, &WORK(il), &ldwork, &WORK(
itauq), &B(1,1), ldb, &WORK(iwork), &i__2, info);
/* Generate right bidiagonalizing vectors of R in WORK(IL)
(Workspace: need M*M+5*M-1, prefer M*M+4*M+(M-1)*NB) */
i__2 = *lwork - iwork + 1;
sorgbr_("P", m, m, m, &WORK(il), &ldwork, &WORK(itaup), &WORK(
iwork), &i__2, info);
iwork = ie + *m;
/* Perform bidiagonal QR iteration,
computing right singular vectors of L in WORK(IL) and
multiplying B by transpose of left singular vectors
(Workspace: need M*M+M+BDSPAC) */
sbdsqr_("U", m, m, &c__0, nrhs, &S(1), &WORK(ie), &WORK(il), &
ldwork, &A(1,1), lda, &B(1,1), ldb, &WORK(iwork)
, info);
if (*info != 0) {
goto L70;
}
/* Multiply B by reciprocals of singular values
Computing MAX */
r__1 = *rcond * S(1);
thr = dmax(r__1,sfmin);
if (*rcond < 0.f) {
/* Computing MAX */
r__1 = eps * S(1);
thr = dmax(r__1,sfmin);
}
*rank = 0;
i__2 = *m;
for (i = 1; i <= *m; ++i) {
if (S(i) > thr) {
srscl_(nrhs, &S(i), &B(i,1), ldb);
++(*rank);
} else {
slaset_("F", &c__1, nrhs, &c_b74, &c_b74, &B(i,1),
ldb);
}
/* L30: */
}
iwork = ie;
/* Multiply B by right singular vectors of L in WORK(IL)
(Workspace: need M*M+2*M, prefer M*M+M+M*NRHS) */
if (*lwork >= *ldb * *nrhs + iwork - 1 && *nrhs > 1) {
sgemm_("T", "N", m, nrhs, m, &c_b108, &WORK(il), &ldwork, &B(1,1), ldb, &c_b74, &WORK(iwork), ldb);
slacpy_("G", m, nrhs, &WORK(iwork), ldb, &B(1,1), ldb);
} else if (*nrhs > 1) {
chunk = (*lwork - iwork + 1) / *m;
i__2 = *nrhs;
i__1 = chunk;
for (i = 1; chunk < 0 ? i >= *nrhs : i <= *nrhs; i += chunk) {
/* Computing MIN */
i__3 = *nrhs - i + 1;
bl = min(i__3,chunk);
sgemm_("T", "N", m, &bl, m, &c_b108, &WORK(il), &ldwork, &
B(1,i), ldb, &c_b74, &WORK(iwork), n);
slacpy_("G", m, &bl, &WORK(iwork), n, &B(1,1), ldb);
/* L40: */
}
} else {
sgemv_("T", m, m, &c_b108, &WORK(il), &ldwork, &B(1,1),
&c__1, &c_b74, &WORK(iwork), &c__1);
scopy_(m, &WORK(iwork), &c__1, &B(1,1), &c__1);
}
/* Zero out below first M rows of B */
i__1 = *n - *m;
slaset_("F", &i__1, nrhs, &c_b74, &c_b74, &B(*m+1,1),
ldb);
iwork = itau + *m;
/* Multiply transpose(Q) by B
(Workspace: need M+NRHS, prefer M+NRHS*NB) */
i__1 = *lwork - iwork + 1;
sormlq_("L", "T", n, nrhs, m, &A(1,1), lda, &WORK(itau), &B(1,1), ldb, &WORK(iwork), &i__1, info);
} else {
/* Path 2 - remaining underdetermined cases */
ie = 1;
itauq = ie + *m;
itaup = itauq + *m;
iwork = itaup + *m;
/* Bidiagonalize A
(Workspace: need 3*M+N, prefer 3*M+(M+N)*NB) */
i__1 = *lwork - iwork + 1;
sgebrd_(m, n, &A(1,1), lda, &S(1), &WORK(ie), &WORK(itauq), &
WORK(itaup), &WORK(iwork), &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors
(Workspace: need 3*M+NRHS, prefer 3*M+NRHS*NB) */
i__1 = *lwork - iwork + 1;
sormbr_("Q", "L", "T", m, nrhs, n, &A(1,1), lda, &WORK(itauq)
, &B(1,1), ldb, &WORK(iwork), &i__1, info);
/* Generate right bidiagonalizing vectors in A
(Workspace: need 4*M, prefer 3*M+M*NB) */
i__1 = *lwork - iwork + 1;
sorgbr_("P", m, n, m, &A(1,1), lda, &WORK(itaup), &WORK(
iwork), &i__1, info);
iwork = ie + *m;
/* Perform bidiagonal QR iteration,
computing right singular vectors of A in A and
multiplying B by transpose of left singular vectors
(Workspace: need BDSPAC) */
sbdsqr_("L", m, n, &c__0, nrhs, &S(1), &WORK(ie), &A(1,1),
lda, vdum, &c__1, &B(1,1), ldb, &WORK(iwork), info);
if (*info != 0) {
goto L70;
}
/* Multiply B by reciprocals of singular values
Computing MAX */
r__1 = *rcond * S(1);
thr = dmax(r__1,sfmin);
if (*rcond < 0.f) {
/* Computing MAX */
r__1 = eps * S(1);
thr = dmax(r__1,sfmin);
}
*rank = 0;
i__1 = *m;
for (i = 1; i <= *m; ++i) {
if (S(i) > thr) {
srscl_(nrhs, &S(i), &B(i,1), ldb);
++(*rank);
} else {
slaset_("F", &c__1, nrhs, &c_b74, &c_b74, &B(i,1),
ldb);
}
/* L50: */
}
/* Multiply B by right singular vectors of A
(Workspace: need N, prefer N*NRHS) */
if (*lwork >= *ldb * *nrhs && *nrhs > 1) {
sgemm_("T", "N", n, nrhs, m, &c_b108, &A(1,1), lda, &B(1,1), ldb, &c_b74, &WORK(1), ldb);
slacpy_("F", n, nrhs, &WORK(1), ldb, &B(1,1), ldb);
} else if (*nrhs > 1) {
chunk = *lwork / *n;
i__1 = *nrhs;
i__2 = chunk;
for (i = 1; chunk < 0 ? i >= *nrhs : i <= *nrhs; i += chunk) {
/* Computing MIN */
i__3 = *nrhs - i + 1;
bl = min(i__3,chunk);
sgemm_("T", "N", n, &bl, m, &c_b108, &A(1,1), lda, &
B(1,i), ldb, &c_b74, &WORK(1), n);
slacpy_("F", n, &bl, &WORK(1), n, &B(1,i), ldb);
/* L60: */
}
} else {
sgemv_("T", m, n, &c_b108, &A(1,1), lda, &B(1,1), &
c__1, &c_b74, &WORK(1), &c__1);
scopy_(n, &WORK(1), &c__1, &B(1,1), &c__1);
}
}
}
/* Undo scaling */
if (iascl == 1) {
slascl_("G", &c__0, &c__0, &anrm, &smlnum, n, nrhs, &B(1,1), ldb,
info);
slascl_("G", &c__0, &c__0, &smlnum, &anrm, &minmn, &c__1, &S(1), &
minmn, info);
} else if (iascl == 2) {
slascl_("G", &c__0, &c__0, &anrm, &bignum, n, nrhs, &B(1,1), ldb,
info);
slascl_("G", &c__0, &c__0, &bignum, &anrm, &minmn, &c__1, &S(1), &
minmn, info);
}
if (ibscl == 1) {
slascl_("G", &c__0, &c__0, &smlnum, &bnrm, n, nrhs, &B(1,1), ldb,
info);
} else if (ibscl == 2) {
slascl_("G", &c__0, &c__0, &bignum, &bnrm, n, nrhs, &B(1,1), ldb,
info);
}
L70:
WORK(1) = (real) maxwrk;
return 0;
/* End of SGELSS */
} /* sgelss_ */
/* Subroutine */ int schkbd_(integer *nsizes, integer *mval, integer *nval,
integer *ntypes, logical *dotype, integer *nrhs, integer *iseed, real
*thresh, real *a, integer *lda, real *bd, real *be, real *s1, real *
s2, real *x, integer *ldx, real *y, real *z__, real *q, integer *ldq,
real *pt, integer *ldpt, real *u, real *vt, real *work, integer *
lwork, integer *iwork, integer *nout, integer *info)
{
/* Initialized data */
static integer ktype[16] = { 1,2,4,4,4,4,4,6,6,6,6,6,9,9,9,10 };
static integer kmagn[16] = { 1,1,1,1,1,2,3,1,1,1,2,3,1,2,3,0 };
static integer kmode[16] = { 0,0,4,3,1,4,4,4,3,1,4,4,0,0,0,0 };
/* Format strings */
static char fmt_9998[] = "(\002 SCHKBD: \002,a,\002 returned INFO=\002,i"
"6,\002.\002,/9x,\002M=\002,i6,\002, N=\002,i6,\002, JTYPE=\002,i"
"6,\002, ISEED=(\002,3(i5,\002,\002),i5,\002)\002)";
static char fmt_9999[] = "(\002 M=\002,i5,\002, N=\002,i5,\002, type "
"\002,i2,\002, seed=\002,4(i4,\002,\002),\002 test(\002,i2,\002)"
"=\002,g11.4)";
/* System generated locals */
integer a_dim1, a_offset, pt_dim1, pt_offset, q_dim1, q_offset, u_dim1,
u_offset, vt_dim1, vt_offset, x_dim1, x_offset, y_dim1, y_offset,
z_dim1, z_offset, i__1, i__2, i__3, i__4, i__5, i__6, i__7;
real r__1, r__2, r__3, r__4, r__5, r__6, r__7;
/* Builtin functions */
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
double log(doublereal), sqrt(doublereal), exp(doublereal);
integer s_wsfe(cilist *), do_fio(integer *, char *, ftnlen), e_wsfe(void);
/* Local variables */
integer i__, j, m, n, mq;
real dum[1], ulp, cond;
integer jcol;
char path[3];
integer idum[1], mmax, nmax;
real unfl, ovfl;
char uplo[1];
real temp1, temp2;
logical badmm, badnn;
integer nfail, imode;
extern /* Subroutine */ int sbdt01_(integer *, integer *, integer *, real
*, integer *, real *, integer *, real *, real *, real *, integer *
, real *, real *), sbdt02_(integer *, integer *, real *, integer *
, real *, integer *, real *, integer *, real *, real *), sbdt03_(
char *, integer *, integer *, real *, real *, real *, integer *,
real *, real *, integer *, real *, real *);
real dumma[1];
integer iinfo;
extern /* Subroutine */ int sgemm_(char *, char *, integer *, integer *,
integer *, real *, real *, integer *, real *, integer *, real *,
real *, integer *);
real anorm;
integer mnmin, mnmax, jsize;
extern /* Subroutine */ int sort01_(char *, integer *, integer *, real *,
integer *, real *, integer *, real *);
integer itype, jtype, ntest;
extern /* Subroutine */ int scopy_(integer *, real *, integer *, real *,
integer *), slahd2_(integer *, char *);
integer log2ui;
logical bidiag;
extern /* Subroutine */ int slabad_(real *, real *), sbdsdc_(char *, char
*, integer *, real *, real *, real *, integer *, real *, integer *
, real *, integer *, real *, integer *, integer *)
, sgebrd_(integer *, integer *, real *, integer *, real *, real *,
real *, real *, real *, integer *, integer *);
extern doublereal slamch_(char *);
extern /* Subroutine */ int xerbla_(char *, integer *);
integer ioldsd[4];
extern /* Subroutine */ int alasum_(char *, integer *, integer *, integer
*, integer *);
extern doublereal slarnd_(integer *, integer *);
real amninv;
extern /* Subroutine */ int slacpy_(char *, integer *, integer *, real *,
integer *, real *, integer *), slaset_(char *, integer *,
integer *, real *, real *, real *, integer *), sbdsqr_(
char *, integer *, integer *, integer *, integer *, real *, real *
, real *, integer *, real *, integer *, real *, integer *, real *,
integer *), sorgbr_(char *, integer *, integer *,
integer *, real *, integer *, real *, real *, integer *, integer *
), slatmr_(integer *, integer *, char *, integer *, char *
, real *, integer *, real *, real *, char *, char *, real *,
integer *, real *, real *, integer *, real *, char *, integer *,
integer *, integer *, real *, real *, char *, real *, integer *,
integer *, integer *), slatms_(integer *, integer *, char *, integer *, char *,
real *, integer *, real *, real *, integer *, integer *, char *,
real *, integer *, real *, integer *);
integer minwrk;
real rtunfl, rtovfl, ulpinv, result[19];
integer mtypes;
/* Fortran I/O blocks */
static cilist io___39 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___40 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___42 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___43 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___44 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___45 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___51 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___52 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___53 = { 0, 0, 0, fmt_9999, 0 };
/* -- LAPACK test routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SCHKBD checks the singular value decomposition (SVD) routines. */
/* SGEBRD reduces a real general m by n matrix A to upper or lower */
/* bidiagonal form B by an orthogonal transformation: Q' * A * P = B */
/* (or A = Q * B * P'). The matrix B is upper bidiagonal if m >= n */
/* and lower bidiagonal if m < n. */
/* SORGBR generates the orthogonal matrices Q and P' from SGEBRD. */
/* Note that Q and P are not necessarily square. */
/* SBDSQR computes the singular value decomposition of the bidiagonal */
/* matrix B as B = U S V'. It is called three times to compute */
/* 1) B = U S1 V', where S1 is the diagonal matrix of singular */
/* values and the columns of the matrices U and V are the left */
/* and right singular vectors, respectively, of B. */
/* 2) Same as 1), but the singular values are stored in S2 and the */
/* singular vectors are not computed. */
/* 3) A = (UQ) S (P'V'), the SVD of the original matrix A. */
/* In addition, SBDSQR has an option to apply the left orthogonal matrix */
/* U to a matrix X, useful in least squares applications. */
/* SBDSDC computes the singular value decomposition of the bidiagonal */
/* matrix B as B = U S V' using divide-and-conquer. It is called twice */
/* to compute */
/* 1) B = U S1 V', where S1 is the diagonal matrix of singular */
/* values and the columns of the matrices U and V are the left */
/* and right singular vectors, respectively, of B. */
/* 2) Same as 1), but the singular values are stored in S2 and the */
/* singular vectors are not computed. */
/* For each pair of matrix dimensions (M,N) and each selected matrix */
/* type, an M by N matrix A and an M by NRHS matrix X are generated. */
/* The problem dimensions are as follows */
/* A: M x N */
/* Q: M x min(M,N) (but M x M if NRHS > 0) */
/* P: min(M,N) x N */
/* B: min(M,N) x min(M,N) */
/* U, V: min(M,N) x min(M,N) */
/* S1, S2 diagonal, order min(M,N) */
/* X: M x NRHS */
/* For each generated matrix, 14 tests are performed: */
/* Test SGEBRD and SORGBR */
/* (1) | A - Q B PT | / ( |A| max(M,N) ulp ), PT = P' */
/* (2) | I - Q' Q | / ( M ulp ) */
/* (3) | I - PT PT' | / ( N ulp ) */
/* Test SBDSQR on bidiagonal matrix B */
/* (4) | B - U S1 VT | / ( |B| min(M,N) ulp ), VT = V' */
/* (5) | Y - U Z | / ( |Y| max(min(M,N),k) ulp ), where Y = Q' X */
/* and Z = U' Y. */
/* (6) | I - U' U | / ( min(M,N) ulp ) */
/* (7) | I - VT VT' | / ( min(M,N) ulp ) */
/* (8) S1 contains min(M,N) nonnegative values in decreasing order. */
/* (Return 0 if true, 1/ULP if false.) */
/* (9) | S1 - S2 | / ( |S1| ulp ), where S2 is computed without */
/* computing U and V. */
/* (10) 0 if the true singular values of B are within THRESH of */
/* those in S1. 2*THRESH if they are not. (Tested using */
/* SSVDCH) */
/* Test SBDSQR on matrix A */
/* (11) | A - (QU) S (VT PT) | / ( |A| max(M,N) ulp ) */
/* (12) | X - (QU) Z | / ( |X| max(M,k) ulp ) */
/* (13) | I - (QU)'(QU) | / ( M ulp ) */
/* (14) | I - (VT PT) (PT'VT') | / ( N ulp ) */
/* Test SBDSDC on bidiagonal matrix B */
/* (15) | B - U S1 VT | / ( |B| min(M,N) ulp ), VT = V' */
/* (16) | I - U' U | / ( min(M,N) ulp ) */
/* (17) | I - VT VT' | / ( min(M,N) ulp ) */
/* (18) S1 contains min(M,N) nonnegative values in decreasing order. */
/* (Return 0 if true, 1/ULP if false.) */
/* (19) | S1 - S2 | / ( |S1| ulp ), where S2 is computed without */
/* computing U and V. */
/* The possible matrix types are */
/* (1) The zero matrix. */
/* (2) The identity matrix. */
/* (3) A diagonal matrix with evenly spaced entries */
/* 1, ..., ULP and random signs. */
/* (ULP = (first number larger than 1) - 1 ) */
/* (4) A diagonal matrix with geometrically spaced entries */
/* 1, ..., ULP and random signs. */
/* (5) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP */
/* and random signs. */
/* (6) Same as (3), but multiplied by SQRT( overflow threshold ) */
/* (7) Same as (3), but multiplied by SQRT( underflow threshold ) */
/* (8) A matrix of the form U D V, where U and V are orthogonal and */
/* D has evenly spaced entries 1, ..., ULP with random signs */
/* on the diagonal. */
/* (9) A matrix of the form U D V, where U and V are orthogonal and */
/* D has geometrically spaced entries 1, ..., ULP with random */
/* signs on the diagonal. */
/* (10) A matrix of the form U D V, where U and V are orthogonal and */
/* D has "clustered" entries 1, ULP,..., ULP with random */
/* signs on the diagonal. */
/* (11) Same as (8), but multiplied by SQRT( overflow threshold ) */
/* (12) Same as (8), but multiplied by SQRT( underflow threshold ) */
/* (13) Rectangular matrix with random entries chosen from (-1,1). */
/* (14) Same as (13), but multiplied by SQRT( overflow threshold ) */
/* (15) Same as (13), but multiplied by SQRT( underflow threshold ) */
/* Special case: */
/* (16) A bidiagonal matrix with random entries chosen from a */
/* logarithmic distribution on [ulp^2,ulp^(-2)] (I.e., each */
/* entry is e^x, where x is chosen uniformly on */
/* [ 2 log(ulp), -2 log(ulp) ] .) For *this* type: */
/* (a) SGEBRD is not called to reduce it to bidiagonal form. */
/* (b) the bidiagonal is min(M,N) x min(M,N); if M<N, the */
/* matrix will be lower bidiagonal, otherwise upper. */
/* (c) only tests 5--8 and 14 are performed. */
/* A subset of the full set of matrix types may be selected through */
/* the logical array DOTYPE. */
/* Arguments */
/* ========== */
/* NSIZES (input) INTEGER */
/* The number of values of M and N contained in the vectors */
/* MVAL and NVAL. The matrix sizes are used in pairs (M,N). */
/* MVAL (input) INTEGER array, dimension (NM) */
/* The values of the matrix row dimension M. */
/* NVAL (input) INTEGER array, dimension (NM) */
/* The values of the matrix column dimension N. */
/* NTYPES (input) INTEGER */
/* The number of elements in DOTYPE. If it is zero, SCHKBD */
/* does nothing. It must be at least zero. If it is MAXTYP+1 */
/* and NSIZES is 1, then an additional type, MAXTYP+1 is */
/* defined, which is to use whatever matrices are in A and B. */
/* This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and */
/* DOTYPE(MAXTYP+1) is .TRUE. . */
/* DOTYPE (input) LOGICAL array, dimension (NTYPES) */
/* If DOTYPE(j) is .TRUE., then for each size (m,n), a matrix */
/* of type j will be generated. If NTYPES is smaller than the */
/* maximum number of types defined (PARAMETER MAXTYP), then */
/* types NTYPES+1 through MAXTYP will not be generated. If */
/* NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through */
/* DOTYPE(NTYPES) will be ignored. */
/* NRHS (input) INTEGER */
/* The number of columns in the "right-hand side" matrices X, Y, */
/* and Z, used in testing SBDSQR. If NRHS = 0, then the */
/* operations on the right-hand side will not be tested. */
/* NRHS must be at least 0. */
/* ISEED (input/output) INTEGER array, dimension (4) */
/* On entry ISEED specifies the seed of the random number */
/* generator. The array elements should be between 0 and 4095; */
/* if not they will be reduced mod 4096. Also, ISEED(4) must */
/* be odd. The values of ISEED are changed on exit, and can be */
/* used in the next call to SCHKBD to continue the same random */
/* number sequence. */
/* THRESH (input) REAL */
/* The threshold value for the test ratios. A result is */
/* included in the output file if RESULT >= THRESH. To have */
/* every test ratio printed, use THRESH = 0. Note that the */
/* expected value of the test ratios is O(1), so THRESH should */
/* be a reasonably small multiple of 1, e.g., 10 or 100. */
/* A (workspace) REAL array, dimension (LDA,NMAX) */
/* where NMAX is the maximum value of N in NVAL. */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= max(1,MMAX), */
/* where MMAX is the maximum value of M in MVAL. */
/* BD (workspace) REAL array, dimension */
/* (max(min(MVAL(j),NVAL(j)))) */
/* BE (workspace) REAL array, dimension */
/* (max(min(MVAL(j),NVAL(j)))) */
/* S1 (workspace) REAL array, dimension */
/* (max(min(MVAL(j),NVAL(j)))) */
/* S2 (workspace) REAL array, dimension */
/* (max(min(MVAL(j),NVAL(j)))) */
/* X (workspace) REAL array, dimension (LDX,NRHS) */
/* LDX (input) INTEGER */
/* The leading dimension of the arrays X, Y, and Z. */
/* LDX >= max(1,MMAX) */
/* Y (workspace) REAL array, dimension (LDX,NRHS) */
/* Z (workspace) REAL array, dimension (LDX,NRHS) */
/* Q (workspace) REAL array, dimension (LDQ,MMAX) */
/* LDQ (input) INTEGER */
/* The leading dimension of the array Q. LDQ >= max(1,MMAX). */
/* PT (workspace) REAL array, dimension (LDPT,NMAX) */
/* LDPT (input) INTEGER */
/* The leading dimension of the arrays PT, U, and V. */
/* LDPT >= max(1, max(min(MVAL(j),NVAL(j)))). */
/* U (workspace) REAL array, dimension */
/* (LDPT,max(min(MVAL(j),NVAL(j)))) */
/* V (workspace) REAL array, dimension */
/* (LDPT,max(min(MVAL(j),NVAL(j)))) */
/* WORK (workspace) REAL array, dimension (LWORK) */
/* LWORK (input) INTEGER */
/* The number of entries in WORK. This must be at least */
/* 3(M+N) and M(M + max(M,N,k) + 1) + N*min(M,N) for all */
/* pairs (M,N)=(MM(j),NN(j)) */
/* IWORK (workspace) INTEGER array, dimension at least 8*min(M,N) */
/* NOUT (input) INTEGER */
/* The FORTRAN unit number for printing out error messages */
/* (e.g., if a routine returns IINFO not equal to 0.) */
/* INFO (output) INTEGER */
/* If 0, then everything ran OK. */
/* -1: NSIZES < 0 */
/* -2: Some MM(j) < 0 */
/* -3: Some NN(j) < 0 */
/* -4: NTYPES < 0 */
/* -6: NRHS < 0 */
/* -8: THRESH < 0 */
/* -11: LDA < 1 or LDA < MMAX, where MMAX is max( MM(j) ). */
/* -17: LDB < 1 or LDB < MMAX. */
/* -21: LDQ < 1 or LDQ < MMAX. */
/* -23: LDPT< 1 or LDPT< MNMAX. */
/* -27: LWORK too small. */
/* If SLATMR, SLATMS, SGEBRD, SORGBR, or SBDSQR, */
/* returns an error code, the */
/* absolute value of it is returned. */
/* ----------------------------------------------------------------------- */
/* Some Local Variables and Parameters: */
/* ---- ----- --------- --- ---------- */
/* ZERO, ONE Real 0 and 1. */
/* MAXTYP The number of types defined. */
/* NTEST The number of tests performed, or which can */
/* be performed so far, for the current matrix. */
/* MMAX Largest value in NN. */
/* NMAX Largest value in NN. */
/* MNMIN min(MM(j), NN(j)) (the dimension of the bidiagonal */
/* matrix.) */
/* MNMAX The maximum value of MNMIN for j=1,...,NSIZES. */
/* NFAIL The number of tests which have exceeded THRESH */
/* COND, IMODE Values to be passed to the matrix generators. */
/* ANORM Norm of A; passed to matrix generators. */
/* OVFL, UNFL Overflow and underflow thresholds. */
/* RTOVFL, RTUNFL Square roots of the previous 2 values. */
/* ULP, ULPINV Finest relative precision and its inverse. */
/* The following four arrays decode JTYPE: */
/* KTYPE(j) The general type (1-10) for type "j". */
/* KMODE(j) The MODE value to be passed to the matrix */
/* generator for type "j". */
/* KMAGN(j) The order of magnitude ( O(1), */
/* O(overflow^(1/2) ), O(underflow^(1/2) ) */
/* ====================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Scalars in Common .. */
/* .. */
/* .. Common blocks .. */
/* .. */
/* .. Data statements .. */
/* Parameter adjustments */
--mval;
--nval;
--dotype;
--iseed;
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--bd;
--be;
--s1;
--s2;
z_dim1 = *ldx;
z_offset = 1 + z_dim1;
z__ -= z_offset;
y_dim1 = *ldx;
y_offset = 1 + y_dim1;
y -= y_offset;
x_dim1 = *ldx;
x_offset = 1 + x_dim1;
x -= x_offset;
q_dim1 = *ldq;
q_offset = 1 + q_dim1;
q -= q_offset;
vt_dim1 = *ldpt;
vt_offset = 1 + vt_dim1;
vt -= vt_offset;
u_dim1 = *ldpt;
u_offset = 1 + u_dim1;
u -= u_offset;
pt_dim1 = *ldpt;
pt_offset = 1 + pt_dim1;
pt -= pt_offset;
--work;
--iwork;
/* Function Body */
/* .. */
/* .. Executable Statements .. */
/* Check for errors */
*info = 0;
badmm = FALSE_;
badnn = FALSE_;
mmax = 1;
nmax = 1;
mnmax = 1;
minwrk = 1;
i__1 = *nsizes;
for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
i__2 = mmax, i__3 = mval[j];
mmax = max(i__2,i__3);
if (mval[j] < 0) {
badmm = TRUE_;
}
/* Computing MAX */
i__2 = nmax, i__3 = nval[j];
nmax = max(i__2,i__3);
if (nval[j] < 0) {
badnn = TRUE_;
}
/* Computing MAX */
/* Computing MIN */
i__4 = mval[j], i__5 = nval[j];
i__2 = mnmax, i__3 = min(i__4,i__5);
mnmax = max(i__2,i__3);
/* Computing MAX */
/* Computing MAX */
i__4 = mval[j], i__5 = nval[j], i__4 = max(i__4,i__5);
/* Computing MIN */
i__6 = nval[j], i__7 = mval[j];
i__2 = minwrk, i__3 = (mval[j] + nval[j]) * 3, i__2 = max(i__2,i__3),
i__3 = mval[j] * (mval[j] + max(i__4,*nrhs) + 1) + nval[j] *
min(i__6,i__7);
minwrk = max(i__2,i__3);
/* L10: */
}
/* Check for errors */
if (*nsizes < 0) {
*info = -1;
} else if (badmm) {
*info = -2;
} else if (badnn) {
*info = -3;
} else if (*ntypes < 0) {
*info = -4;
} else if (*nrhs < 0) {
*info = -6;
} else if (*lda < mmax) {
*info = -11;
} else if (*ldx < mmax) {
*info = -17;
} else if (*ldq < mmax) {
*info = -21;
} else if (*ldpt < mnmax) {
*info = -23;
} else if (minwrk > *lwork) {
*info = -27;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SCHKBD", &i__1);
return 0;
}
/* Initialize constants */
s_copy(path, "Single precision", (ftnlen)1, (ftnlen)16);
s_copy(path + 1, "BD", (ftnlen)2, (ftnlen)2);
nfail = 0;
ntest = 0;
unfl = slamch_("Safe minimum");
ovfl = slamch_("Overflow");
slabad_(&unfl, &ovfl);
ulp = slamch_("Precision");
ulpinv = 1.f / ulp;
log2ui = (integer) (log(ulpinv) / log(2.f));
rtunfl = sqrt(unfl);
rtovfl = sqrt(ovfl);
infoc_1.infot = 0;
/* Loop over sizes, types */
i__1 = *nsizes;
for (jsize = 1; jsize <= i__1; ++jsize) {
m = mval[jsize];
n = nval[jsize];
mnmin = min(m,n);
/* Computing MAX */
i__2 = max(m,n);
amninv = 1.f / max(i__2,1);
if (*nsizes != 1) {
mtypes = min(16,*ntypes);
} else {
mtypes = min(17,*ntypes);
}
i__2 = mtypes;
for (jtype = 1; jtype <= i__2; ++jtype) {
if (! dotype[jtype]) {
goto L190;
}
for (j = 1; j <= 4; ++j) {
ioldsd[j - 1] = iseed[j];
/* L20: */
}
for (j = 1; j <= 14; ++j) {
result[j - 1] = -1.f;
/* L30: */
}
*(unsigned char *)uplo = ' ';
/* Compute "A" */
/* Control parameters: */
/* KMAGN KMODE KTYPE */
/* =1 O(1) clustered 1 zero */
/* =2 large clustered 2 identity */
/* =3 small exponential (none) */
/* =4 arithmetic diagonal, (w/ eigenvalues) */
/* =5 random symmetric, w/ eigenvalues */
/* =6 nonsymmetric, w/ singular values */
/* =7 random diagonal */
/* =8 random symmetric */
/* =9 random nonsymmetric */
/* =10 random bidiagonal (log. distrib.) */
if (mtypes > 16) {
goto L100;
}
itype = ktype[jtype - 1];
imode = kmode[jtype - 1];
/* Compute norm */
switch (kmagn[jtype - 1]) {
case 1: goto L40;
case 2: goto L50;
case 3: goto L60;
}
L40:
anorm = 1.f;
goto L70;
L50:
anorm = rtovfl * ulp * amninv;
goto L70;
L60:
anorm = rtunfl * max(m,n) * ulpinv;
goto L70;
L70:
slaset_("Full", lda, &n, &c_b20, &c_b20, &a[a_offset], lda);
iinfo = 0;
cond = ulpinv;
bidiag = FALSE_;
if (itype == 1) {
/* Zero matrix */
iinfo = 0;
} else if (itype == 2) {
/* Identity */
i__3 = mnmin;
for (jcol = 1; jcol <= i__3; ++jcol) {
a[jcol + jcol * a_dim1] = anorm;
/* L80: */
}
} else if (itype == 4) {
/* Diagonal Matrix, [Eigen]values Specified */
slatms_(&mnmin, &mnmin, "S", &iseed[1], "N", &work[1], &imode,
&cond, &anorm, &c__0, &c__0, "N", &a[a_offset], lda,
&work[mnmin + 1], &iinfo);
} else if (itype == 5) {
/* Symmetric, eigenvalues specified */
slatms_(&mnmin, &mnmin, "S", &iseed[1], "S", &work[1], &imode,
&cond, &anorm, &m, &n, "N", &a[a_offset], lda, &work[
mnmin + 1], &iinfo);
} else if (itype == 6) {
/* Nonsymmetric, singular values specified */
slatms_(&m, &n, "S", &iseed[1], "N", &work[1], &imode, &cond,
&anorm, &m, &n, "N", &a[a_offset], lda, &work[mnmin +
1], &iinfo);
} else if (itype == 7) {
/* Diagonal, random entries */
slatmr_(&mnmin, &mnmin, "S", &iseed[1], "N", &work[1], &c__6,
&c_b37, &c_b37, "T", "N", &work[mnmin + 1], &c__1, &
c_b37, &work[(mnmin << 1) + 1], &c__1, &c_b37, "N", &
iwork[1], &c__0, &c__0, &c_b20, &anorm, "NO", &a[
a_offset], lda, &iwork[1], &iinfo);
} else if (itype == 8) {
/* Symmetric, random entries */
slatmr_(&mnmin, &mnmin, "S", &iseed[1], "S", &work[1], &c__6,
&c_b37, &c_b37, "T", "N", &work[mnmin + 1], &c__1, &
c_b37, &work[m + mnmin + 1], &c__1, &c_b37, "N", &
iwork[1], &m, &n, &c_b20, &anorm, "NO", &a[a_offset],
lda, &iwork[1], &iinfo);
} else if (itype == 9) {
/* Nonsymmetric, random entries */
slatmr_(&m, &n, "S", &iseed[1], "N", &work[1], &c__6, &c_b37,
&c_b37, "T", "N", &work[mnmin + 1], &c__1, &c_b37, &
work[m + mnmin + 1], &c__1, &c_b37, "N", &iwork[1], &
m, &n, &c_b20, &anorm, "NO", &a[a_offset], lda, &
iwork[1], &iinfo);
} else if (itype == 10) {
/* Bidiagonal, random entries */
temp1 = log(ulp) * -2.f;
i__3 = mnmin;
for (j = 1; j <= i__3; ++j) {
bd[j] = exp(temp1 * slarnd_(&c__2, &iseed[1]));
if (j < mnmin) {
be[j] = exp(temp1 * slarnd_(&c__2, &iseed[1]));
}
/* L90: */
}
iinfo = 0;
bidiag = TRUE_;
if (m >= n) {
*(unsigned char *)uplo = 'U';
} else {
*(unsigned char *)uplo = 'L';
}
} else {
iinfo = 1;
}
if (iinfo == 0) {
/* Generate Right-Hand Side */
if (bidiag) {
slatmr_(&mnmin, nrhs, "S", &iseed[1], "N", &work[1], &
c__6, &c_b37, &c_b37, "T", "N", &work[mnmin + 1],
&c__1, &c_b37, &work[(mnmin << 1) + 1], &c__1, &
c_b37, "N", &iwork[1], &mnmin, nrhs, &c_b20, &
c_b37, "NO", &y[y_offset], ldx, &iwork[1], &iinfo);
} else {
slatmr_(&m, nrhs, "S", &iseed[1], "N", &work[1], &c__6, &
c_b37, &c_b37, "T", "N", &work[m + 1], &c__1, &
c_b37, &work[(m << 1) + 1], &c__1, &c_b37, "N", &
iwork[1], &m, nrhs, &c_b20, &c_b37, "NO", &x[
x_offset], ldx, &iwork[1], &iinfo);
}
}
/* Error Exit */
if (iinfo != 0) {
io___39.ciunit = *nout;
s_wsfe(&io___39);
do_fio(&c__1, "Generator", (ftnlen)9);
do_fio(&c__1, (char *)&iinfo, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&m, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&jtype, (ftnlen)sizeof(integer));
do_fio(&c__4, (char *)&ioldsd[0], (ftnlen)sizeof(integer));
e_wsfe();
*info = abs(iinfo);
return 0;
}
L100:
/* Call SGEBRD and SORGBR to compute B, Q, and P, do tests. */
if (! bidiag) {
/* Compute transformations to reduce A to bidiagonal form: */
/* B := Q' * A * P. */
slacpy_(" ", &m, &n, &a[a_offset], lda, &q[q_offset], ldq);
i__3 = *lwork - (mnmin << 1);
sgebrd_(&m, &n, &q[q_offset], ldq, &bd[1], &be[1], &work[1], &
work[mnmin + 1], &work[(mnmin << 1) + 1], &i__3, &
iinfo);
/* Check error code from SGEBRD. */
if (iinfo != 0) {
io___40.ciunit = *nout;
s_wsfe(&io___40);
do_fio(&c__1, "SGEBRD", (ftnlen)6);
do_fio(&c__1, (char *)&iinfo, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&m, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&jtype, (ftnlen)sizeof(integer));
do_fio(&c__4, (char *)&ioldsd[0], (ftnlen)sizeof(integer))
;
e_wsfe();
*info = abs(iinfo);
return 0;
}
slacpy_(" ", &m, &n, &q[q_offset], ldq, &pt[pt_offset], ldpt);
if (m >= n) {
*(unsigned char *)uplo = 'U';
} else {
*(unsigned char *)uplo = 'L';
}
/* Generate Q */
mq = m;
if (*nrhs <= 0) {
mq = mnmin;
}
i__3 = *lwork - (mnmin << 1);
sorgbr_("Q", &m, &mq, &n, &q[q_offset], ldq, &work[1], &work[(
mnmin << 1) + 1], &i__3, &iinfo);
/* Check error code from SORGBR. */
if (iinfo != 0) {
io___42.ciunit = *nout;
s_wsfe(&io___42);
do_fio(&c__1, "SORGBR(Q)", (ftnlen)9);
do_fio(&c__1, (char *)&iinfo, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&m, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&jtype, (ftnlen)sizeof(integer));
do_fio(&c__4, (char *)&ioldsd[0], (ftnlen)sizeof(integer))
;
e_wsfe();
*info = abs(iinfo);
return 0;
}
/* Generate P' */
i__3 = *lwork - (mnmin << 1);
sorgbr_("P", &mnmin, &n, &m, &pt[pt_offset], ldpt, &work[
mnmin + 1], &work[(mnmin << 1) + 1], &i__3, &iinfo);
/* Check error code from SORGBR. */
if (iinfo != 0) {
io___43.ciunit = *nout;
s_wsfe(&io___43);
do_fio(&c__1, "SORGBR(P)", (ftnlen)9);
do_fio(&c__1, (char *)&iinfo, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&m, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&jtype, (ftnlen)sizeof(integer));
do_fio(&c__4, (char *)&ioldsd[0], (ftnlen)sizeof(integer))
;
e_wsfe();
*info = abs(iinfo);
return 0;
}
/* Apply Q' to an M by NRHS matrix X: Y := Q' * X. */
sgemm_("Transpose", "No transpose", &m, nrhs, &m, &c_b37, &q[
q_offset], ldq, &x[x_offset], ldx, &c_b20, &y[
y_offset], ldx);
/* Test 1: Check the decomposition A := Q * B * PT */
/* 2: Check the orthogonality of Q */
/* 3: Check the orthogonality of PT */
sbdt01_(&m, &n, &c__1, &a[a_offset], lda, &q[q_offset], ldq, &
bd[1], &be[1], &pt[pt_offset], ldpt, &work[1], result)
;
sort01_("Columns", &m, &mq, &q[q_offset], ldq, &work[1],
lwork, &result[1]);
sort01_("Rows", &mnmin, &n, &pt[pt_offset], ldpt, &work[1],
lwork, &result[2]);
}
/* Use SBDSQR to form the SVD of the bidiagonal matrix B: */
/* B := U * S1 * VT, and compute Z = U' * Y. */
scopy_(&mnmin, &bd[1], &c__1, &s1[1], &c__1);
if (mnmin > 0) {
i__3 = mnmin - 1;
scopy_(&i__3, &be[1], &c__1, &work[1], &c__1);
}
slacpy_(" ", &m, nrhs, &y[y_offset], ldx, &z__[z_offset], ldx);
slaset_("Full", &mnmin, &mnmin, &c_b20, &c_b37, &u[u_offset],
ldpt);
slaset_("Full", &mnmin, &mnmin, &c_b20, &c_b37, &vt[vt_offset],
ldpt);
sbdsqr_(uplo, &mnmin, &mnmin, &mnmin, nrhs, &s1[1], &work[1], &vt[
vt_offset], ldpt, &u[u_offset], ldpt, &z__[z_offset], ldx,
&work[mnmin + 1], &iinfo);
/* Check error code from SBDSQR. */
if (iinfo != 0) {
io___44.ciunit = *nout;
s_wsfe(&io___44);
do_fio(&c__1, "SBDSQR(vects)", (ftnlen)13);
do_fio(&c__1, (char *)&iinfo, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&m, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&jtype, (ftnlen)sizeof(integer));
do_fio(&c__4, (char *)&ioldsd[0], (ftnlen)sizeof(integer));
e_wsfe();
*info = abs(iinfo);
if (iinfo < 0) {
return 0;
} else {
result[3] = ulpinv;
goto L170;
}
}
/* Use SBDSQR to compute only the singular values of the */
/* bidiagonal matrix B; U, VT, and Z should not be modified. */
scopy_(&mnmin, &bd[1], &c__1, &s2[1], &c__1);
if (mnmin > 0) {
i__3 = mnmin - 1;
scopy_(&i__3, &be[1], &c__1, &work[1], &c__1);
}
sbdsqr_(uplo, &mnmin, &c__0, &c__0, &c__0, &s2[1], &work[1], &vt[
vt_offset], ldpt, &u[u_offset], ldpt, &z__[z_offset], ldx,
&work[mnmin + 1], &iinfo);
/* Check error code from SBDSQR. */
if (iinfo != 0) {
io___45.ciunit = *nout;
s_wsfe(&io___45);
do_fio(&c__1, "SBDSQR(values)", (ftnlen)14);
do_fio(&c__1, (char *)&iinfo, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&m, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&jtype, (ftnlen)sizeof(integer));
do_fio(&c__4, (char *)&ioldsd[0], (ftnlen)sizeof(integer));
e_wsfe();
*info = abs(iinfo);
if (iinfo < 0) {
return 0;
} else {
result[8] = ulpinv;
goto L170;
}
}
/* Test 4: Check the decomposition B := U * S1 * VT */
/* 5: Check the computation Z := U' * Y */
/* 6: Check the orthogonality of U */
/* 7: Check the orthogonality of VT */
sbdt03_(uplo, &mnmin, &c__1, &bd[1], &be[1], &u[u_offset], ldpt, &
s1[1], &vt[vt_offset], ldpt, &work[1], &result[3]);
sbdt02_(&mnmin, nrhs, &y[y_offset], ldx, &z__[z_offset], ldx, &u[
u_offset], ldpt, &work[1], &result[4]);
sort01_("Columns", &mnmin, &mnmin, &u[u_offset], ldpt, &work[1],
lwork, &result[5]);
sort01_("Rows", &mnmin, &mnmin, &vt[vt_offset], ldpt, &work[1],
lwork, &result[6]);
/* Test 8: Check that the singular values are sorted in */
/* non-increasing order and are non-negative */
result[7] = 0.f;
i__3 = mnmin - 1;
for (i__ = 1; i__ <= i__3; ++i__) {
if (s1[i__] < s1[i__ + 1]) {
result[7] = ulpinv;
}
if (s1[i__] < 0.f) {
result[7] = ulpinv;
}
/* L110: */
}
if (mnmin >= 1) {
if (s1[mnmin] < 0.f) {
result[7] = ulpinv;
}
}
/* Test 9: Compare SBDSQR with and without singular vectors */
temp2 = 0.f;
i__3 = mnmin;
for (j = 1; j <= i__3; ++j) {
/* Computing MAX */
/* Computing MAX */
r__6 = (r__1 = s1[j], dabs(r__1)), r__7 = (r__2 = s2[j], dabs(
r__2));
r__4 = sqrt(unfl) * dmax(s1[1],1.f), r__5 = ulp * dmax(r__6,
r__7);
temp1 = (r__3 = s1[j] - s2[j], dabs(r__3)) / dmax(r__4,r__5);
temp2 = dmax(temp1,temp2);
/* L120: */
}
result[8] = temp2;
/* Test 10: Sturm sequence test of singular values */
/* Go up by factors of two until it succeeds */
temp1 = *thresh * (.5f - ulp);
i__3 = log2ui;
for (j = 0; j <= i__3; ++j) {
/* CALL SSVDCH( MNMIN, BD, BE, S1, TEMP1, IINFO ) */
if (iinfo == 0) {
goto L140;
}
temp1 *= 2.f;
/* L130: */
}
L140:
result[9] = temp1;
/* Use SBDSQR to form the decomposition A := (QU) S (VT PT) */
/* from the bidiagonal form A := Q B PT. */
if (! bidiag) {
scopy_(&mnmin, &bd[1], &c__1, &s2[1], &c__1);
if (mnmin > 0) {
i__3 = mnmin - 1;
scopy_(&i__3, &be[1], &c__1, &work[1], &c__1);
}
sbdsqr_(uplo, &mnmin, &n, &m, nrhs, &s2[1], &work[1], &pt[
pt_offset], ldpt, &q[q_offset], ldq, &y[y_offset],
ldx, &work[mnmin + 1], &iinfo);
/* Test 11: Check the decomposition A := Q*U * S2 * VT*PT */
/* 12: Check the computation Z := U' * Q' * X */
/* 13: Check the orthogonality of Q*U */
/* 14: Check the orthogonality of VT*PT */
sbdt01_(&m, &n, &c__0, &a[a_offset], lda, &q[q_offset], ldq, &
s2[1], dumma, &pt[pt_offset], ldpt, &work[1], &result[
10]);
sbdt02_(&m, nrhs, &x[x_offset], ldx, &y[y_offset], ldx, &q[
q_offset], ldq, &work[1], &result[11]);
sort01_("Columns", &m, &mq, &q[q_offset], ldq, &work[1],
lwork, &result[12]);
sort01_("Rows", &mnmin, &n, &pt[pt_offset], ldpt, &work[1],
lwork, &result[13]);
}
/* Use SBDSDC to form the SVD of the bidiagonal matrix B: */
/* B := U * S1 * VT */
scopy_(&mnmin, &bd[1], &c__1, &s1[1], &c__1);
if (mnmin > 0) {
i__3 = mnmin - 1;
scopy_(&i__3, &be[1], &c__1, &work[1], &c__1);
}
slaset_("Full", &mnmin, &mnmin, &c_b20, &c_b37, &u[u_offset],
ldpt);
slaset_("Full", &mnmin, &mnmin, &c_b20, &c_b37, &vt[vt_offset],
ldpt);
sbdsdc_(uplo, "I", &mnmin, &s1[1], &work[1], &u[u_offset], ldpt, &
vt[vt_offset], ldpt, dum, idum, &work[mnmin + 1], &iwork[
1], &iinfo);
/* Check error code from SBDSDC. */
if (iinfo != 0) {
io___51.ciunit = *nout;
s_wsfe(&io___51);
do_fio(&c__1, "SBDSDC(vects)", (ftnlen)13);
do_fio(&c__1, (char *)&iinfo, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&m, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&jtype, (ftnlen)sizeof(integer));
do_fio(&c__4, (char *)&ioldsd[0], (ftnlen)sizeof(integer));
e_wsfe();
*info = abs(iinfo);
if (iinfo < 0) {
return 0;
} else {
result[14] = ulpinv;
goto L170;
}
}
/* Use SBDSDC to compute only the singular values of the */
/* bidiagonal matrix B; U and VT should not be modified. */
scopy_(&mnmin, &bd[1], &c__1, &s2[1], &c__1);
if (mnmin > 0) {
i__3 = mnmin - 1;
scopy_(&i__3, &be[1], &c__1, &work[1], &c__1);
}
sbdsdc_(uplo, "N", &mnmin, &s2[1], &work[1], dum, &c__1, dum, &
c__1, dum, idum, &work[mnmin + 1], &iwork[1], &iinfo);
/* Check error code from SBDSDC. */
if (iinfo != 0) {
io___52.ciunit = *nout;
s_wsfe(&io___52);
do_fio(&c__1, "SBDSDC(values)", (ftnlen)14);
do_fio(&c__1, (char *)&iinfo, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&m, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&jtype, (ftnlen)sizeof(integer));
do_fio(&c__4, (char *)&ioldsd[0], (ftnlen)sizeof(integer));
e_wsfe();
*info = abs(iinfo);
if (iinfo < 0) {
return 0;
} else {
result[17] = ulpinv;
goto L170;
}
}
/* Test 15: Check the decomposition B := U * S1 * VT */
/* 16: Check the orthogonality of U */
/* 17: Check the orthogonality of VT */
sbdt03_(uplo, &mnmin, &c__1, &bd[1], &be[1], &u[u_offset], ldpt, &
s1[1], &vt[vt_offset], ldpt, &work[1], &result[14]);
sort01_("Columns", &mnmin, &mnmin, &u[u_offset], ldpt, &work[1],
lwork, &result[15]);
sort01_("Rows", &mnmin, &mnmin, &vt[vt_offset], ldpt, &work[1],
lwork, &result[16]);
/* Test 18: Check that the singular values are sorted in */
/* non-increasing order and are non-negative */
result[17] = 0.f;
i__3 = mnmin - 1;
for (i__ = 1; i__ <= i__3; ++i__) {
if (s1[i__] < s1[i__ + 1]) {
result[17] = ulpinv;
}
if (s1[i__] < 0.f) {
result[17] = ulpinv;
}
/* L150: */
}
if (mnmin >= 1) {
if (s1[mnmin] < 0.f) {
result[17] = ulpinv;
}
}
/* Test 19: Compare SBDSQR with and without singular vectors */
temp2 = 0.f;
i__3 = mnmin;
for (j = 1; j <= i__3; ++j) {
/* Computing MAX */
/* Computing MAX */
r__4 = dabs(s1[1]), r__5 = dabs(s2[1]);
r__2 = sqrt(unfl) * dmax(s1[1],1.f), r__3 = ulp * dmax(r__4,
r__5);
temp1 = (r__1 = s1[j] - s2[j], dabs(r__1)) / dmax(r__2,r__3);
temp2 = dmax(temp1,temp2);
/* L160: */
}
result[18] = temp2;
/* End of Loop -- Check for RESULT(j) > THRESH */
L170:
for (j = 1; j <= 19; ++j) {
if (result[j - 1] >= *thresh) {
if (nfail == 0) {
slahd2_(nout, path);
}
io___53.ciunit = *nout;
s_wsfe(&io___53);
do_fio(&c__1, (char *)&m, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&jtype, (ftnlen)sizeof(integer));
do_fio(&c__4, (char *)&ioldsd[0], (ftnlen)sizeof(integer))
;
do_fio(&c__1, (char *)&j, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&result[j - 1], (ftnlen)sizeof(real)
);
e_wsfe();
++nfail;
}
/* L180: */
}
if (! bidiag) {
ntest += 19;
} else {
ntest += 5;
}
L190:
;
}
/* L200: */
}
/* Summary */
alasum_(path, nout, &nfail, &ntest, &c__0);
return 0;
/* End of SCHKBD */
} /* schkbd_ */
int spteqr_(char *compz, int *n, float *d__, float *e,
float *z__, int *ldz, float *work, int *info)
{
/* System generated locals */
int z_dim1, z_offset, i__1;
/* Builtin functions */
double sqrt(double);
/* Local variables */
float c__[1] /* was [1][1] */;
int i__;
float vt[1] /* was [1][1] */;
int nru;
extern int lsame_(char *, char *);
extern int xerbla_(char *, int *), slaset_(
char *, int *, int *, float *, float *, float *, int *), sbdsqr_(char *, int *, int *, int *, int
*, float *, float *, float *, int *, float *, int *, float *,
int *, float *, int *);
int icompz;
extern int spttrf_(int *, float *, float *, int *);
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SPTEQR computes all eigenvalues and, optionally, eigenvectors of a */
/* symmetric positive definite tridiagonal matrix by first factoring the */
/* matrix using SPTTRF, and then calling SBDSQR to compute the singular */
/* values of the bidiagonal factor. */
/* This routine computes the eigenvalues of the positive definite */
/* tridiagonal matrix to high relative accuracy. This means that if the */
/* eigenvalues range over many orders of magnitude in size, then the */
/* small eigenvalues and corresponding eigenvectors will be computed */
/* more accurately than, for example, with the standard QR method. */
/* The eigenvectors of a full or band symmetric positive definite matrix */
/* can also be found if SSYTRD, SSPTRD, or SSBTRD has been used to */
/* reduce this matrix to tridiagonal form. (The reduction to tridiagonal */
/* form, however, may preclude the possibility of obtaining high */
/* relative accuracy in the small eigenvalues of the original matrix, if */
/* these eigenvalues range over many orders of magnitude.) */
/* Arguments */
/* ========= */
/* COMPZ (input) CHARACTER*1 */
/* = 'N': Compute eigenvalues only. */
/* = 'V': Compute eigenvectors of original symmetric */
/* matrix also. Array Z contains the orthogonal */
/* matrix used to reduce the original matrix to */
/* tridiagonal form. */
/* = 'I': Compute eigenvectors of tridiagonal matrix also. */
/* N (input) INTEGER */
/* The order of the matrix. N >= 0. */
/* D (input/output) REAL array, dimension (N) */
/* On entry, the n diagonal elements of the tridiagonal */
/* matrix. */
/* On normal exit, D contains the eigenvalues, in descending */
/* order. */
/* E (input/output) REAL array, dimension (N-1) */
/* On entry, the (n-1) subdiagonal elements of the tridiagonal */
/* matrix. */
/* On exit, E has been destroyed. */
/* Z (input/output) REAL array, dimension (LDZ, N) */
/* On entry, if COMPZ = 'V', the orthogonal matrix used in the */
/* reduction to tridiagonal form. */
/* On exit, if COMPZ = 'V', the orthonormal eigenvectors of the */
/* original symmetric matrix; */
/* if COMPZ = 'I', the orthonormal eigenvectors of the */
/* tridiagonal matrix. */
/* If INFO > 0 on exit, Z contains the eigenvectors associated */
/* with only the stored eigenvalues. */
/* If COMPZ = 'N', then Z is not referenced. */
/* LDZ (input) INTEGER */
/* The leading dimension of the array Z. LDZ >= 1, and if */
/* COMPZ = 'V' or 'I', LDZ >= MAX(1,N). */
/* WORK (workspace) REAL array, dimension (4*N) */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* > 0: if INFO = i, and i is: */
/* <= N the Cholesky factorization of the matrix could */
/* not be performed because the i-th principal minor */
/* was not positive definite. */
/* > N the SVD algorithm failed to converge; */
/* if INFO = N+i, i off-diagonal elements of the */
/* bidiagonal factor did not converge to zero. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
--d__;
--e;
z_dim1 = *ldz;
z_offset = 1 + z_dim1;
z__ -= z_offset;
--work;
/* Function Body */
*info = 0;
if (lsame_(compz, "N")) {
icompz = 0;
} else if (lsame_(compz, "V")) {
icompz = 1;
} else if (lsame_(compz, "I")) {
icompz = 2;
} else {
icompz = -1;
}
if (icompz < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*ldz < 1 || icompz > 0 && *ldz < MAX(1,*n)) {
*info = -6;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SPTEQR", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
if (*n == 1) {
if (icompz > 0) {
z__[z_dim1 + 1] = 1.f;
}
return 0;
}
if (icompz == 2) {
slaset_("Full", n, n, &c_b7, &c_b8, &z__[z_offset], ldz);
}
/* Call SPTTRF to factor the matrix. */
spttrf_(n, &d__[1], &e[1], info);
if (*info != 0) {
return 0;
}
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
d__[i__] = sqrt(d__[i__]);
/* L10: */
}
i__1 = *n - 1;
for (i__ = 1; i__ <= i__1; ++i__) {
e[i__] *= d__[i__];
/* L20: */
}
/* Call SBDSQR to compute the singular values/vectors of the */
/* bidiagonal factor. */
if (icompz > 0) {
nru = *n;
} else {
nru = 0;
}
sbdsqr_("Lower", n, &c__0, &nru, &c__0, &d__[1], &e[1], vt, &c__1, &z__[
z_offset], ldz, c__, &c__1, &work[1], info);
/* Square the singular values. */
if (*info == 0) {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
d__[i__] *= d__[i__];
/* L30: */
}
} else {
*info = *n + *info;
}
return 0;
/* End of SPTEQR */
} /* spteqr_ */
