/* Subroutine */ int zgelss_(integer *m, integer *n, integer *nrhs,
doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb,
doublereal *s, doublereal *rcond, integer *rank, doublecomplex *work,
integer *lwork, doublereal *rwork, 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
=======
ZGELSS computes the minimum norm solution to a complex 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) COMPLEX*16 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) COMPLEX*16 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,M,N).
S (output) DOUBLE PRECISION 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) DOUBLE PRECISION
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) COMPLEX*16 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 >= 2*min(M,N) + max(M,N,NRHS)
For good performance, LWORK should generally be larger.
RWORK (workspace) DOUBLE PRECISION array, dimension (5*min(M,N)-1)
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 doublecomplex c_b1 = {0.,0.};
static doublecomplex c_b2 = {1.,0.};
static integer c__6 = 6;
static integer c_n1 = -1;
static integer c__1 = 1;
static integer c__0 = 0;
static doublereal c_b78 = 0.;
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3;
doublereal d__1;
/* Local variables */
static doublereal anrm, bnrm;
static integer itau;
static doublecomplex vdum[1];
static integer i, iascl, ibscl, chunk;
static doublereal sfmin;
static integer minmn;
extern /* Subroutine */ int zgemm_(char *, char *, integer *, integer *,
integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *);
static integer maxmn, itaup, itauq, mnthr;
extern /* Subroutine */ int zgemv_(char *, integer *, integer *,
doublecomplex *, doublecomplex *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *);
static integer iwork;
extern /* Subroutine */ int zcopy_(integer *, doublecomplex *, integer *,
doublecomplex *, integer *), dlabad_(doublereal *, doublereal *);
static integer bl, ie, il;
extern doublereal dlamch_(char *);
static integer mm;
extern /* Subroutine */ int dlascl_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, integer *, doublereal *,
integer *, integer *), dlaset_(char *, integer *, integer
*, doublereal *, doublereal *, doublereal *, integer *),
xerbla_(char *, integer *), zgebrd_(integer *, integer *,
doublecomplex *, integer *, doublereal *, doublereal *,
doublecomplex *, doublecomplex *, doublecomplex *, integer *,
integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *,
integer *, doublereal *);
static doublereal bignum;
extern /* Subroutine */ int zgelqf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
), zlascl_(char *, integer *, integer *, doublereal *, doublereal
*, integer *, integer *, doublecomplex *, integer *, integer *), zgeqrf_(integer *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, integer *, integer *), zdrscl_(
integer *, doublereal *, doublecomplex *, integer *);
static integer ldwork;
extern /* Subroutine */ int zlacpy_(char *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *),
zlaset_(char *, integer *, integer *, doublecomplex *,
doublecomplex *, doublecomplex *, integer *), zbdsqr_(
char *, integer *, integer *, integer *, integer *, doublereal *,
doublereal *, doublecomplex *, integer *, doublecomplex *,
integer *, doublecomplex *, integer *, doublereal *, integer *);
static integer minwrk, maxwrk;
extern /* Subroutine */ int zungbr_(char *, integer *, integer *, integer
*, doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *);
static doublereal smlnum;
static integer irwork;
extern /* Subroutine */ int zunmbr_(char *, char *, char *, integer *,
integer *, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
), zunmlq_(char *, char *, integer *,
integer *, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
), zunmqr_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
static doublereal eps, thr;
#define VDUM(I) vdum[(I)]
#define S(I) s[(I)-1]
#define WORK(I) work[(I)-1]
#define RWORK(I) rwork[(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, "ZGELSS", " ", 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.
CWorkspace refers to complex workspace, and RWorkspace refers
to real workspace. 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
Space needed for ZBDSQR is BDSPAC = 5*N-1 */
mm = *n;
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *n * ilaenv_(&c__1, "ZGEQRF", " ", 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, "ZUNMQR", "LT",
m, nrhs, n, &c_n1, 6L, 2L);
maxwrk = max(i__1,i__2);
}
if (*m >= *n) {
/* Path 1 - overdetermined or exactly determined
Space needed for ZBDSQR is BDSPC = 7*N+12
Computing MAX */
i__1 = maxwrk, i__2 = (*n << 1) + (mm + *n) * ilaenv_(&c__1,
"ZGEBRD", " ", &mm, n, &c_n1, &c_n1, 6L, 1L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*n << 1) + *nrhs * ilaenv_(&c__1, "ZUNMBR",
"QLC", &mm, nrhs, n, &c_n1, 6L, 3L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*n << 1) + (*n - 1) * ilaenv_(&c__1, "ZUN"
"GBR", "P", n, n, n, &c_n1, 6L, 1L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * *nrhs;
maxwrk = max(i__1,i__2);
minwrk = (*n << 1) + max(*nrhs,*m);
}
if (*n > *m) {
minwrk = (*m << 1) + max(*nrhs,*n);
if (*n >= mnthr) {
/* Path 2a - underdetermined, with many more colu
mns
than rows
Space needed for ZBDSQR is BDSPAC = 5*M-1 */
maxwrk = *m + *m * ilaenv_(&c__1, "ZGELQF", " ", m, n, &c_n1,
&c_n1, 6L, 1L);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + *m * *m + (*m << 1) * ilaenv_(&
c__1, "ZGEBRD", " ", m, m, &c_n1, &c_n1, 6L, 1L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + *m * *m + *nrhs * ilaenv_(&
c__1, "ZUNMBR", "QLC", m, nrhs, m, &c_n1, 6L, 3L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + *m * *m + (*m - 1) * ilaenv_(&
c__1, "ZUNGBR", "P", m, m, m, &c_n1, 6L, 1L);
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, "ZUNMLQ",
"LT", n, nrhs, m, &c_n1, 6L, 2L);
maxwrk = max(i__1,i__2);
} else {
/* Path 2 - underdetermined
Space needed for ZBDSQR is BDSPAC = 5*M-1 */
maxwrk = (*m << 1) + (*n + *m) * ilaenv_(&c__1, "ZGEBRD",
" ", m, n, &c_n1, &c_n1, 6L, 1L);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*m << 1) + *nrhs * ilaenv_(&c__1,
"ZUNMBR", "QLT", m, nrhs, m, &c_n1, 6L, 3L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*m << 1) + *m * ilaenv_(&c__1, "ZUNGBR"
, "P", m, n, m, &c_n1, 6L, 1L);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * *nrhs;
maxwrk = max(i__1,i__2);
}
}
minwrk = max(minwrk,1);
maxwrk = max(minwrk,maxwrk);
WORK(1).r = (doublereal) maxwrk, WORK(1).i = 0.;
}
if (*lwork < minwrk) {
*info = -12;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGELSS", &i__1);
return 0;
}
/* Quick return if possible */
if (*m == 0 || *n == 0) {
*rank = 0;
return 0;
}
/* Get machine parameters */
eps = dlamch_("P");
sfmin = dlamch_("S");
smlnum = sfmin / eps;
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", m, n, &A(1,1), lda, &RWORK(1));
iascl = 0;
if (anrm > 0. && anrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
zlascl_("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 */
zlascl_("G", &c__0, &c__0, &anrm, &bignum, m, n, &A(1,1), lda,
info);
iascl = 2;
} else if (anrm == 0.) {
/* VISMatrix all zero. Return zero solution. */
i__1 = max(*m,*n);
zlaset_("F", &i__1, nrhs, &c_b1, &c_b1, &B(1,1), ldb);
dlaset_("F", &minmn, &c__1, &c_b78, &c_b78, &S(1), &minmn);
*rank = 0;
goto L70;
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = zlange_("M", m, nrhs, &B(1,1), ldb, &RWORK(1));
ibscl = 0;
if (bnrm > 0. && bnrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
zlascl_("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 */
zlascl_("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
(CWorkspace: need 2*N, prefer N+N*NB)
(RWorkspace: none) */
i__1 = *lwork - iwork + 1;
zgeqrf_(m, n, &A(1,1), lda, &WORK(itau), &WORK(iwork), &i__1,
info);
/* Multiply B by transpose(Q)
(CWorkspace: need N+NRHS, prefer N+NRHS*NB)
(RWorkspace: none) */
i__1 = *lwork - iwork + 1;
zunmqr_("L", "C", 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;
zlaset_("L", &i__1, &i__2, &c_b1, &c_b1, &A(2,1), lda);
}
}
ie = 1;
itauq = 1;
itaup = itauq + *n;
iwork = itaup + *n;
/* Bidiagonalize R in A
(CWorkspace: need 2*N+MM, prefer 2*N+(MM+N)*NB)
(RWorkspace: need N) */
i__1 = *lwork - iwork + 1;
zgebrd_(&mm, n, &A(1,1), lda, &S(1), &RWORK(ie), &WORK(itauq), &
WORK(itaup), &WORK(iwork), &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors of R
(CWorkspace: need 2*N+NRHS, prefer 2*N+NRHS*NB)
(RWorkspace: none) */
i__1 = *lwork - iwork + 1;
zunmbr_("Q", "L", "C", &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
(CWorkspace: need 3*N-1, prefer 2*N+(N-1)*NB)
(RWorkspace: none) */
i__1 = *lwork - iwork + 1;
zungbr_("P", n, n, n, &A(1,1), lda, &WORK(itaup), &WORK(iwork), &
i__1, info);
irwork = ie + *n;
/* Perform bidiagonal QR iteration
multiply B by transpose of left singular vectors
compute right singular vectors in A
(CWorkspace: none)
(RWorkspace: need BDSPAC) */
zbdsqr_("U", n, n, &c__0, nrhs, &S(1), &RWORK(ie), &A(1,1), lda,
vdum, &c__1, &B(1,1), ldb, &RWORK(irwork), info);
if (*info != 0) {
goto L70;
}
/* Multiply B by reciprocals of singular values
Computing MAX */
d__1 = *rcond * S(1);
thr = max(d__1,sfmin);
if (*rcond < 0.) {
/* Computing MAX */
d__1 = eps * S(1);
thr = max(d__1,sfmin);
}
*rank = 0;
i__1 = *n;
for (i = 1; i <= *n; ++i) {
if (S(i) > thr) {
zdrscl_(nrhs, &S(i), &B(i,1), ldb);
++(*rank);
} else {
zlaset_("F", &c__1, nrhs, &c_b1, &c_b1, &B(i,1), ldb);
}
/* L10: */
}
/* Multiply B by right singular vectors
(CWorkspace: need N, prefer N*NRHS)
(RWorkspace: none) */
if (*lwork >= *ldb * *nrhs && *nrhs > 1) {
zgemm_("C", "N", n, nrhs, n, &c_b2, &A(1,1), lda, &B(1,1), ldb, &c_b1, &WORK(1), ldb);
zlacpy_("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);
zgemm_("C", "N", n, &bl, n, &c_b2, &A(1,1), lda, &B(1,1), ldb, &c_b1, &WORK(1), n);
zlacpy_("G", n, &bl, &WORK(1), n, &B(1,1), ldb);
/* L20: */
}
} else {
zgemv_("C", n, n, &c_b2, &A(1,1), lda, &B(1,1), &c__1, &
c_b1, &WORK(1), &c__1);
zcopy_(n, &WORK(1), &c__1, &B(1,1), &c__1);
}
} else /* if(complicated condition) */ {
/* Computing MAX */
i__2 = max(*m,*nrhs), i__1 = *n - (*m << 1);
if (*n >= mnthr && *lwork >= *m * 3 + *m * *m + max(i__2,i__1)) {
/* Underdetermined case, M much less than N
Path 2a - underdetermined, with many more columns than r
ows
and sufficient workspace for an efficient algorithm */
ldwork = *m;
/* Computing MAX */
i__2 = max(*m,*nrhs), i__1 = *n - (*m << 1);
if (*lwork >= *m * 3 + *m * *lda + max(i__2,i__1)) {
ldwork = *lda;
}
itau = 1;
iwork = *m + 1;
/* Compute A=L*Q
(CWorkspace: need 2*M, prefer M+M*NB)
(RWorkspace: none) */
i__2 = *lwork - iwork + 1;
zgelqf_(m, n, &A(1,1), lda, &WORK(itau), &WORK(iwork), &i__2,
info);
il = iwork;
/* Copy L to WORK(IL), zeroing out above it */
zlacpy_("L", m, m, &A(1,1), lda, &WORK(il), &ldwork);
i__2 = *m - 1;
i__1 = *m - 1;
zlaset_("U", &i__2, &i__1, &c_b1, &c_b1, &WORK(il + ldwork), &
ldwork);
ie = 1;
itauq = il + ldwork * *m;
itaup = itauq + *m;
iwork = itaup + *m;
/* Bidiagonalize L in WORK(IL)
(CWorkspace: need M*M+4*M, prefer M*M+3*M+2*M*NB)
(RWorkspace: need M) */
i__2 = *lwork - iwork + 1;
zgebrd_(m, m, &WORK(il), &ldwork, &S(1), &RWORK(ie), &WORK(itauq),
&WORK(itaup), &WORK(iwork), &i__2, info);
/* Multiply B by transpose of left bidiagonalizing vectors
of L
(CWorkspace: need M*M+3*M+NRHS, prefer M*M+3*M+NRHS*NB)
(RWorkspace: none) */
i__2 = *lwork - iwork + 1;
zunmbr_("Q", "L", "C", 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)
(CWorkspace: need M*M+4*M-1, prefer M*M+3*M+(M-1)*NB)
(RWorkspace: none) */
i__2 = *lwork - iwork + 1;
zungbr_("P", m, m, m, &WORK(il), &ldwork, &WORK(itaup), &WORK(
iwork), &i__2, info);
irwork = ie + *m;
/* Perform bidiagonal QR iteration, computing right singula
r
vectors of L in WORK(IL) and multiplying B by transpose
of
left singular vectors
(CWorkspace: need M*M)
(RWorkspace: need BDSPAC) */
zbdsqr_("U", m, m, &c__0, nrhs, &S(1), &RWORK(ie), &WORK(il), &
ldwork, &A(1,1), lda, &B(1,1), ldb, &RWORK(
irwork), info);
if (*info != 0) {
goto L70;
}
/* Multiply B by reciprocals of singular values
Computing MAX */
d__1 = *rcond * S(1);
thr = max(d__1,sfmin);
if (*rcond < 0.) {
/* Computing MAX */
d__1 = eps * S(1);
thr = max(d__1,sfmin);
}
*rank = 0;
i__2 = *m;
for (i = 1; i <= *m; ++i) {
if (S(i) > thr) {
zdrscl_(nrhs, &S(i), &B(i,1), ldb);
++(*rank);
} else {
zlaset_("F", &c__1, nrhs, &c_b1, &c_b1, &B(i,1),
ldb);
}
/* L30: */
}
iwork = il + *m * ldwork;
/* Multiply B by right singular vectors of L in WORK(IL)
(CWorkspace: need M*M+2*M, prefer M*M+M+M*NRHS)
(RWorkspace: none) */
if (*lwork >= *ldb * *nrhs + iwork - 1 && *nrhs > 1) {
zgemm_("C", "N", m, nrhs, m, &c_b2, &WORK(il), &ldwork, &B(1,1), ldb, &c_b1, &WORK(iwork), ldb);
zlacpy_("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);
zgemm_("C", "N", m, &bl, m, &c_b2, &WORK(il), &ldwork, &B(1,i), ldb, &c_b1, &WORK(iwork), n);
zlacpy_("G", m, &bl, &WORK(iwork), n, &B(1,1), ldb);
/* L40: */
}
} else {
zgemv_("C", m, m, &c_b2, &WORK(il), &ldwork, &B(1,1), &
c__1, &c_b1, &WORK(iwork), &c__1);
zcopy_(m, &WORK(iwork), &c__1, &B(1,1), &c__1);
}
/* Zero out below first M rows of B */
i__1 = *n - *m;
zlaset_("F", &i__1, nrhs, &c_b1, &c_b1, &B(*m+1,1), ldb);
iwork = itau + *m;
/* Multiply transpose(Q) by B
(CWorkspace: need M+NRHS, prefer M+NHRS*NB)
(RWorkspace: none) */
i__1 = *lwork - iwork + 1;
zunmlq_("L", "C", 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 = 1;
itaup = itauq + *m;
iwork = itaup + *m;
/* Bidiagonalize A
(CWorkspace: need 3*M, prefer 2*M+(M+N)*NB)
(RWorkspace: need N) */
i__1 = *lwork - iwork + 1;
zgebrd_(m, n, &A(1,1), lda, &S(1), &RWORK(ie), &WORK(itauq),
&WORK(itaup), &WORK(iwork), &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors
(CWorkspace: need 2*M+NRHS, prefer 2*M+NRHS*NB)
(RWorkspace: none) */
i__1 = *lwork - iwork + 1;
zunmbr_("Q", "L", "C", m, nrhs, n, &A(1,1), lda, &WORK(itauq)
, &B(1,1), ldb, &WORK(iwork), &i__1, info);
/* Generate right bidiagonalizing vectors in A
(CWorkspace: need 3*M, prefer 2*M+M*NB)
(RWorkspace: none) */
i__1 = *lwork - iwork + 1;
zungbr_("P", m, n, m, &A(1,1), lda, &WORK(itaup), &WORK(
iwork), &i__1, info);
irwork = ie + *m;
/* Perform bidiagonal QR iteration,
computing right singular vectors of A in A and
multiplying B by transpose of left singular vectors
(CWorkspace: none)
(RWorkspace: need BDSPAC) */
zbdsqr_("L", m, n, &c__0, nrhs, &S(1), &RWORK(ie), &A(1,1),
lda, vdum, &c__1, &B(1,1), ldb, &RWORK(irwork), info);
if (*info != 0) {
goto L70;
}
/* Multiply B by reciprocals of singular values
Computing MAX */
d__1 = *rcond * S(1);
thr = max(d__1,sfmin);
if (*rcond < 0.) {
/* Computing MAX */
d__1 = eps * S(1);
thr = max(d__1,sfmin);
}
*rank = 0;
i__1 = *m;
for (i = 1; i <= *m; ++i) {
if (S(i) > thr) {
zdrscl_(nrhs, &S(i), &B(i,1), ldb);
++(*rank);
} else {
zlaset_("F", &c__1, nrhs, &c_b1, &c_b1, &B(i,1),
ldb);
}
/* L50: */
}
/* Multiply B by right singular vectors of A
(CWorkspace: need N, prefer N*NRHS)
(RWorkspace: none) */
if (*lwork >= *ldb * *nrhs && *nrhs > 1) {
zgemm_("C", "N", n, nrhs, m, &c_b2, &A(1,1), lda, &B(1,1), ldb, &c_b1, &WORK(1), ldb);
zlacpy_("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);
zgemm_("C", "N", n, &bl, m, &c_b2, &A(1,1), lda, &B(1,i), ldb, &c_b1, &WORK(1), n);
zlacpy_("F", n, &bl, &WORK(1), n, &B(1,i), ldb);
/* L60: */
}
} else {
zgemv_("C", m, n, &c_b2, &A(1,1), lda, &B(1,1), &
c__1, &c_b1, &WORK(1), &c__1);
zcopy_(n, &WORK(1), &c__1, &B(1,1), &c__1);
}
}
}
/* Undo scaling */
if (iascl == 1) {
zlascl_("G", &c__0, &c__0, &anrm, &smlnum, n, nrhs, &B(1,1), ldb,
info);
dlascl_("G", &c__0, &c__0, &smlnum, &anrm, &minmn, &c__1, &S(1), &
minmn, info);
} else if (iascl == 2) {
zlascl_("G", &c__0, &c__0, &anrm, &bignum, n, nrhs, &B(1,1), ldb,
info);
dlascl_("G", &c__0, &c__0, &bignum, &anrm, &minmn, &c__1, &S(1), &
minmn, info);
}
if (ibscl == 1) {
zlascl_("G", &c__0, &c__0, &smlnum, &bnrm, n, nrhs, &B(1,1), ldb,
info);
} else if (ibscl == 2) {
zlascl_("G", &c__0, &c__0, &bignum, &bnrm, n, nrhs, &B(1,1), ldb,
info);
}
L70:
WORK(1).r = (doublereal) maxwrk, WORK(1).i = 0.;
return 0;
/* End of ZGELSS */
} /* zgelss_ */
/* Subroutine */ int zggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp
delctg, char *sense, integer *n, doublecomplex *a, integer *lda,
doublecomplex *b, integer *ldb, integer *sdim, doublecomplex *alpha,
doublecomplex *beta, doublecomplex *vsl, integer *ldvsl,
doublecomplex *vsr, integer *ldvsr, doublereal *rconde, doublereal *
rcondv, doublecomplex *work, integer *lwork, doublereal *rwork,
integer *iwork, integer *liwork, logical *bwork, integer *info,
ftnlen jobvsl_len, ftnlen jobvsr_len, ftnlen sort_len, ftnlen
sense_len)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vsl_dim1, vsl_offset,
vsr_dim1, vsr_offset, i__1, i__2;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
static integer i__;
static doublereal pl, pr, dif[2];
static integer ihi, ilo;
static doublereal eps;
static integer ijob;
static doublereal anrm, bnrm;
static integer ierr, itau, iwrk;
extern logical lsame_(char *, char *, ftnlen, ftnlen);
static integer ileft, icols;
static logical cursl, ilvsl, ilvsr;
static integer irwrk, irows;
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *);
extern doublereal dlamch_(char *, ftnlen);
extern /* Subroutine */ int zggbak_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublecomplex *,
integer *, integer *, ftnlen, ftnlen), zggbal_(char *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
, integer *, doublereal *, doublereal *, doublereal *, integer *,
ftnlen);
static logical ilascl, ilbscl;
extern /* Subroutine */ int xerbla_(char *, integer *, ftnlen);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *,
integer *, doublereal *, ftnlen);
static doublereal bignum;
static integer ijobvl, iright;
extern /* Subroutine */ int zgghrd_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
, ftnlen, ftnlen), zlascl_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, integer *, doublecomplex *,
integer *, integer *, ftnlen);
static integer ijobvr;
static logical wantsb;
static integer liwmin;
static logical wantse, lastsl;
static doublereal anrmto, bnrmto;
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
);
static integer maxwrk;
static logical wantsn;
static integer minwrk;
static doublereal smlnum;
extern /* Subroutine */ int zhgeqz_(char *, char *, char *, integer *,
integer *, integer *, doublecomplex *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, doublecomplex *,
integer *, doublecomplex *, integer *, doublecomplex *, integer *,
doublereal *, integer *, ftnlen, ftnlen, ftnlen), zlacpy_(char *,
integer *, integer *, doublecomplex *, integer *, doublecomplex *
, integer *, ftnlen), zlaset_(char *, integer *, integer *,
doublecomplex *, doublecomplex *, doublecomplex *, integer *,
ftnlen);
static logical wantst;
extern /* Subroutine */ int ztgsen_(integer *, logical *, logical *,
logical *, integer *, doublecomplex *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, doublecomplex *,
integer *, doublecomplex *, integer *, integer *, doublereal *,
doublereal *, doublereal *, doublecomplex *, integer *, integer *,
integer *, integer *);
static logical wantsv;
extern /* Subroutine */ int zungqr_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *), zunmqr_(char *, char *, integer *, integer
*, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *,
ftnlen, ftnlen);
/* -- LAPACK driver routine (version 3.0) -- */
/* Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd., */
/* Courant Institute, Argonne National Lab, and Rice University */
/* June 30, 1999 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* .. Function Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZGGESX computes for a pair of N-by-N complex nonsymmetric matrices */
/* (A,B), the generalized eigenvalues, the complex Schur form (S,T), */
/* and, optionally, the left and/or right matrices of Schur vectors (VSL */
/* and VSR). This gives the generalized Schur factorization */
/* (A,B) = ( (VSL) S (VSR)**H, (VSL) T (VSR)**H ) */
/* where (VSR)**H is the conjugate-transpose of VSR. */
/* Optionally, it also orders the eigenvalues so that a selected cluster */
/* of eigenvalues appears in the leading diagonal blocks of the upper */
/* triangular matrix S and the upper triangular matrix T; computes */
/* a reciprocal condition number for the average of the selected */
/* eigenvalues (RCONDE); and computes a reciprocal condition number for */
/* the right and left deflating subspaces corresponding to the selected */
/* eigenvalues (RCONDV). The leading columns of VSL and VSR then form */
/* an orthonormal basis for the corresponding left and right eigenspaces */
/* (deflating subspaces). */
/* A generalized eigenvalue for a pair of matrices (A,B) is a scalar w */
/* or a ratio alpha/beta = w, such that A - w*B is singular. It is */
/* usually represented as the pair (alpha,beta), as there is a */
/* reasonable interpretation for beta=0 or for both being zero. */
/* A pair of matrices (S,T) is in generalized complex Schur form if T is */
/* upper triangular with non-negative diagonal and S is upper */
/* triangular. */
/* Arguments */
/* ========= */
/* JOBVSL (input) CHARACTER*1 */
/* = 'N': do not compute the left Schur vectors; */
/* = 'V': compute the left Schur vectors. */
/* JOBVSR (input) CHARACTER*1 */
/* = 'N': do not compute the right Schur vectors; */
/* = 'V': compute the right Schur vectors. */
/* SORT (input) CHARACTER*1 */
/* Specifies whether or not to order the eigenvalues on the */
/* diagonal of the generalized Schur form. */
/* = 'N': Eigenvalues are not ordered; */
/* = 'S': Eigenvalues are ordered (see DELZTG). */
/* DELZTG (input) LOGICAL FUNCTION of two COMPLEX*16 arguments */
/* DELZTG must be declared EXTERNAL in the calling subroutine. */
/* If SORT = 'N', DELZTG is not referenced. */
/* If SORT = 'S', DELZTG is used to select eigenvalues to sort */
/* to the top left of the Schur form. */
/* Note that a selected complex eigenvalue may no longer satisfy */
/* DELZTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since */
/* ordering may change the value of complex eigenvalues */
/* (especially if the eigenvalue is ill-conditioned), in this */
/* case INFO is set to N+3 see INFO below). */
/* SENSE (input) CHARACTER */
/* Determines which reciprocal condition numbers are computed. */
/* = 'N' : None are computed; */
/* = 'E' : Computed for average of selected eigenvalues only; */
/* = 'V' : Computed for selected deflating subspaces only; */
/* = 'B' : Computed for both. */
/* If SENSE = 'E', 'V', or 'B', SORT must equal 'S'. */
/* N (input) INTEGER */
/* The order of the matrices A, B, VSL, and VSR. N >= 0. */
/* A (input/output) COMPLEX*16 array, dimension (LDA, N) */
/* On entry, the first of the pair of matrices. */
/* On exit, A has been overwritten by its generalized Schur */
/* form S. */
/* LDA (input) INTEGER */
/* The leading dimension of A. LDA >= max(1,N). */
/* B (input/output) COMPLEX*16 array, dimension (LDB, N) */
/* On entry, the second of the pair of matrices. */
/* On exit, B has been overwritten by its generalized Schur */
/* form T. */
/* LDB (input) INTEGER */
/* The leading dimension of B. LDB >= max(1,N). */
/* SDIM (output) INTEGER */
/* If SORT = 'N', SDIM = 0. */
/* If SORT = 'S', SDIM = number of eigenvalues (after sorting) */
/* for which DELZTG is true. */
/* ALPHA (output) COMPLEX*16 array, dimension (N) */
/* BETA (output) COMPLEX*16 array, dimension (N) */
/* On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the */
/* generalized eigenvalues. ALPHA(j) and BETA(j),j=1,...,N are */
/* the diagonals of the complex Schur form (S,T). BETA(j) will */
/* be non-negative real. */
/* Note: the quotients ALPHA(j)/BETA(j) may easily over- or */
/* underflow, and BETA(j) may even be zero. Thus, the user */
/* should avoid naively computing the ratio alpha/beta. */
/* However, ALPHA will be always less than and usually */
/* comparable with norm(A) in magnitude, and BETA always less */
/* than and usually comparable with norm(B). */
/* VSL (output) COMPLEX*16 array, dimension (LDVSL,N) */
/* If JOBVSL = 'V', VSL will contain the left Schur vectors. */
/* Not referenced if JOBVSL = 'N'. */
/* LDVSL (input) INTEGER */
/* The leading dimension of the matrix VSL. LDVSL >=1, and */
/* if JOBVSL = 'V', LDVSL >= N. */
/* VSR (output) COMPLEX*16 array, dimension (LDVSR,N) */
/* If JOBVSR = 'V', VSR will contain the right Schur vectors. */
/* Not referenced if JOBVSR = 'N'. */
/* LDVSR (input) INTEGER */
/* The leading dimension of the matrix VSR. LDVSR >= 1, and */
/* if JOBVSR = 'V', LDVSR >= N. */
/* RCONDE (output) DOUBLE PRECISION array, dimension ( 2 ) */
/* If SENSE = 'E' or 'B', RCONDE(1) and RCONDE(2) contain the */
/* reciprocal condition numbers for the average of the selected */
/* eigenvalues. */
/* Not referenced if SENSE = 'N' or 'V'. */
/* RCONDV (output) DOUBLE PRECISION array, dimension ( 2 ) */
/* If SENSE = 'V' or 'B', RCONDV(1) and RCONDV(2) contain the */
/* reciprocal condition number for the selected deflating */
/* subspaces. */
/* Not referenced if SENSE = 'N' or 'E'. */
/* WORK (workspace/output) COMPLEX*16 array, dimension (LWORK) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= 2*N. */
/* If SENSE = 'E', 'V', or 'B', */
/* LWORK >= MAX(2*N, 2*SDIM*(N-SDIM)). */
/* RWORK (workspace) DOUBLE PRECISION array, dimension ( 8*N ) */
/* Real workspace. */
/* IWORK (workspace/output) INTEGER array, dimension (LIWORK) */
/* Not referenced if SENSE = 'N'. */
/* On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. */
/* LIWORK (input) INTEGER */
/* The dimension of the array WORK. LIWORK >= N+2. */
/* BWORK (workspace) LOGICAL array, dimension (N) */
/* Not referenced if SORT = 'N'. */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* = 1,...,N: */
/* The QZ iteration failed. (A,B) are not in Schur */
/* form, but ALPHA(j) and BETA(j) should be correct for */
/* j=INFO+1,...,N. */
/* > N: =N+1: other than QZ iteration failed in ZHGEQZ */
/* =N+2: after reordering, roundoff changed values of */
/* some complex eigenvalues so that leading */
/* eigenvalues in the Generalized Schur form no */
/* longer satisfy DELZTG=.TRUE. This could also */
/* be caused due to scaling. */
/* =N+3: reordering failed in ZTGSEN. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Decode the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
--alpha;
--beta;
vsl_dim1 = *ldvsl;
vsl_offset = 1 + vsl_dim1;
vsl -= vsl_offset;
vsr_dim1 = *ldvsr;
vsr_offset = 1 + vsr_dim1;
vsr -= vsr_offset;
--rconde;
--rcondv;
--work;
--rwork;
--iwork;
--bwork;
/* Function Body */
if (lsame_(jobvsl, "N", (ftnlen)1, (ftnlen)1)) {
ijobvl = 1;
ilvsl = FALSE_;
} else if (lsame_(jobvsl, "V", (ftnlen)1, (ftnlen)1)) {
ijobvl = 2;
ilvsl = TRUE_;
} else {
ijobvl = -1;
ilvsl = FALSE_;
}
if (lsame_(jobvsr, "N", (ftnlen)1, (ftnlen)1)) {
ijobvr = 1;
ilvsr = FALSE_;
} else if (lsame_(jobvsr, "V", (ftnlen)1, (ftnlen)1)) {
ijobvr = 2;
ilvsr = TRUE_;
} else {
ijobvr = -1;
ilvsr = FALSE_;
}
wantst = lsame_(sort, "S", (ftnlen)1, (ftnlen)1);
wantsn = lsame_(sense, "N", (ftnlen)1, (ftnlen)1);
wantse = lsame_(sense, "E", (ftnlen)1, (ftnlen)1);
wantsv = lsame_(sense, "V", (ftnlen)1, (ftnlen)1);
wantsb = lsame_(sense, "B", (ftnlen)1, (ftnlen)1);
if (wantsn) {
ijob = 0;
iwork[1] = 1;
} else if (wantse) {
ijob = 1;
} else if (wantsv) {
ijob = 2;
} else if (wantsb) {
ijob = 4;
}
/* Test the input arguments */
*info = 0;
if (ijobvl <= 0) {
*info = -1;
} else if (ijobvr <= 0) {
*info = -2;
} else if (! wantst && ! lsame_(sort, "N", (ftnlen)1, (ftnlen)1)) {
*info = -3;
} else if (! (wantsn || wantse || wantsv || wantsb) || ! wantst && !
wantsn) {
*info = -5;
} else if (*n < 0) {
*info = -6;
} else if (*lda < max(1,*n)) {
*info = -8;
} else if (*ldb < max(1,*n)) {
*info = -10;
} else if (*ldvsl < 1 || ilvsl && *ldvsl < *n) {
*info = -15;
} else if (*ldvsr < 1 || ilvsr && *ldvsr < *n) {
*info = -17;
}
/* 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) {
/* Computing MAX */
i__1 = 1, i__2 = *n << 1;
minwrk = max(i__1,i__2);
maxwrk = *n + *n * ilaenv_(&c__1, "ZGEQRF", " ", n, &c__1, n, &c__0, (
ftnlen)6, (ftnlen)1);
if (ilvsl) {
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *n * ilaenv_(&c__1, "ZUNGQR", " ", n, &
c__1, n, &c_n1, (ftnlen)6, (ftnlen)1);
maxwrk = max(i__1,i__2);
}
work[1].r = (doublereal) maxwrk, work[1].i = 0.;
}
if (! wantsn) {
liwmin = *n + 2;
} else {
liwmin = 1;
}
iwork[1] = liwmin;
if (*info == 0 && *lwork < minwrk) {
*info = -21;
} else if (*info == 0 && ijob >= 1) {
if (*liwork < liwmin) {
*info = -24;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGGESX", &i__1, (ftnlen)6);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
*sdim = 0;
return 0;
}
/* Get machine constants */
eps = dlamch_("P", (ftnlen)1);
smlnum = dlamch_("S", (ftnlen)1);
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
smlnum = sqrt(smlnum) / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", n, n, &a[a_offset], lda, &rwork[1], (ftnlen)1);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE_;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, &
ierr, (ftnlen)1);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = zlange_("M", n, n, &b[b_offset], ldb, &rwork[1], (ftnlen)1);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE_;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, &
ierr, (ftnlen)1);
}
/* Permute the matrix to make it more nearly triangular */
/* (Real Workspace: need 6*N) */
ileft = 1;
iright = *n + 1;
irwrk = iright + *n;
zggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &rwork[
ileft], &rwork[iright], &rwork[irwrk], &ierr, (ftnlen)1);
/* Reduce B to triangular form (QR decomposition of B) */
/* (Complex Workspace: need N, prefer N*NB) */
irows = ihi + 1 - ilo;
icols = *n + 1 - ilo;
itau = 1;
iwrk = itau + irows;
i__1 = *lwork + 1 - iwrk;
zgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[
iwrk], &i__1, &ierr);
/* Apply the unitary transformation to matrix A */
/* (Complex Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
zunmqr_("L", "C", &irows, &icols, &irows, &b[ilo + ilo * b_dim1], ldb, &
work[itau], &a[ilo + ilo * a_dim1], lda, &work[iwrk], &i__1, &
ierr, (ftnlen)1, (ftnlen)1);
/* Initialize VSL */
/* (Complex Workspace: need N, prefer N*NB) */
if (ilvsl) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vsl[vsl_offset], ldvsl, (ftnlen)
4);
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vsl[ilo
+ 1 + ilo * vsl_dim1], ldvsl, (ftnlen)1);
i__1 = *lwork + 1 - iwrk;
zungqr_(&irows, &irows, &irows, &vsl[ilo + ilo * vsl_dim1], ldvsl, &
work[itau], &work[iwrk], &i__1, &ierr);
}
/* Initialize VSR */
if (ilvsr) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vsr[vsr_offset], ldvsr, (ftnlen)
4);
}
/* Reduce to generalized Hessenberg form */
/* (Workspace: none needed) */
zgghrd_(jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vsl[vsl_offset], ldvsl, &vsr[vsr_offset], ldvsr, &ierr, (
ftnlen)1, (ftnlen)1);
*sdim = 0;
/* Perform QZ algorithm, computing Schur vectors if desired */
/* (Complex Workspace: need N) */
/* (Real Workspace: need N) */
iwrk = itau;
i__1 = *lwork + 1 - iwrk;
zhgeqz_("S", jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alpha[1], &beta[1], &vsl[vsl_offset], ldvsl, &
vsr[vsr_offset], ldvsr, &work[iwrk], &i__1, &rwork[irwrk], &ierr,
(ftnlen)1, (ftnlen)1, (ftnlen)1);
if (ierr != 0) {
if (ierr > 0 && ierr <= *n) {
*info = ierr;
} else if (ierr > *n && ierr <= *n << 1) {
*info = ierr - *n;
} else {
*info = *n + 1;
}
goto L40;
}
/* Sort eigenvalues ALPHA/BETA and compute the reciprocal of */
/* condition number(s) */
if (wantst) {
/* Undo scaling on eigenvalues before DELZTGing */
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alpha[1], n,
&ierr, (ftnlen)1);
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n,
&ierr, (ftnlen)1);
}
/* Select eigenvalues */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
bwork[i__] = (*delctg)(&alpha[i__], &beta[i__]);
/* L10: */
}
/* Reorder eigenvalues, transform Generalized Schur vectors, and */
/* compute reciprocal condition numbers */
/* (Complex Workspace: If IJOB >= 1, need MAX(1, 2*SDIM*(N-SDIM)) */
/* otherwise, need 1 ) */
i__1 = *lwork - iwrk + 1;
ztgsen_(&ijob, &ilvsl, &ilvsr, &bwork[1], n, &a[a_offset], lda, &b[
b_offset], ldb, &alpha[1], &beta[1], &vsl[vsl_offset], ldvsl,
&vsr[vsr_offset], ldvsr, sdim, &pl, &pr, dif, &work[iwrk], &
i__1, &iwork[1], liwork, &ierr);
if (ijob >= 1) {
/* Computing MAX */
i__1 = maxwrk, i__2 = (*sdim << 1) * (*n - *sdim);
maxwrk = max(i__1,i__2);
}
if (ierr == -21) {
/* not enough complex workspace */
*info = -21;
} else {
rconde[1] = pl;
rconde[2] = pl;
rcondv[1] = dif[0];
rcondv[2] = dif[1];
if (ierr == 1) {
*info = *n + 3;
}
}
}
/* Apply permutation to VSL and VSR */
/* (Workspace: none needed) */
if (ilvsl) {
zggbak_("P", "L", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, &
vsl[vsl_offset], ldvsl, &ierr, (ftnlen)1, (ftnlen)1);
}
if (ilvsr) {
zggbak_("P", "R", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, &
vsr[vsr_offset], ldvsr, &ierr, (ftnlen)1, (ftnlen)1);
}
/* Undo scaling */
if (ilascl) {
zlascl_("U", &c__0, &c__0, &anrmto, &anrm, n, n, &a[a_offset], lda, &
ierr, (ftnlen)1);
zlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alpha[1], n, &
ierr, (ftnlen)1);
}
if (ilbscl) {
zlascl_("U", &c__0, &c__0, &bnrmto, &bnrm, n, n, &b[b_offset], ldb, &
ierr, (ftnlen)1);
zlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, &
ierr, (ftnlen)1);
}
/* L20: */
if (wantst) {
/* Check if reordering is correct */
lastsl = TRUE_;
*sdim = 0;
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
cursl = (*delctg)(&alpha[i__], &beta[i__]);
if (cursl) {
++(*sdim);
}
if (cursl && ! lastsl) {
*info = *n + 2;
}
lastsl = cursl;
/* L30: */
}
}
L40:
work[1].r = (doublereal) maxwrk, work[1].i = 0.;
iwork[1] = liwmin;
return 0;
/* End of ZGGESX */
} /* zggesx_ */
/* Subroutine */ int zgges_(char *jobvsl, char *jobvsr, char *sort, L_fp
delctg, integer *n, doublecomplex *a, integer *lda, doublecomplex *b,
integer *ldb, integer *sdim, doublecomplex *alpha, doublecomplex *
beta, doublecomplex *vsl, integer *ldvsl, doublecomplex *vsr, integer
*ldvsr, doublecomplex *work, integer *lwork, doublereal *rwork,
logical *bwork, integer *info)
{
/* -- LAPACK driver routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
June 30, 1999
Purpose
=======
ZGGES computes for a pair of N-by-N complex nonsymmetric matrices
(A,B), the generalized eigenvalues, the generalized complex Schur
form (S, T), and optionally left and/or right Schur vectors (VSL
and VSR). This gives the generalized Schur factorization
(A,B) = ( (VSL)*S*(VSR)**H, (VSL)*T*(VSR)**H )
where (VSR)**H is the conjugate-transpose of VSR.
Optionally, it also orders the eigenvalues so that a selected cluster
of eigenvalues appears in the leading diagonal blocks of the upper
triangular matrix S and the upper triangular matrix T. The leading
columns of VSL and VSR then form an unitary basis for the
corresponding left and right eigenspaces (deflating subspaces).
(If only the generalized eigenvalues are needed, use the driver
ZGGEV instead, which is faster.)
A generalized eigenvalue for a pair of matrices (A,B) is a scalar w
or a ratio alpha/beta = w, such that A - w*B is singular. It is
usually represented as the pair (alpha,beta), as there is a
reasonable interpretation for beta=0, and even for both being zero.
A pair of matrices (S,T) is in generalized complex Schur form if S
and T are upper triangular and, in addition, the diagonal elements
of T are non-negative real numbers.
Arguments
=========
JOBVSL (input) CHARACTER*1
= 'N': do not compute the left Schur vectors;
= 'V': compute the left Schur vectors.
JOBVSR (input) CHARACTER*1
= 'N': do not compute the right Schur vectors;
= 'V': compute the right Schur vectors.
SORT (input) CHARACTER*1
Specifies whether or not to order the eigenvalues on the
diagonal of the generalized Schur form.
= 'N': Eigenvalues are not ordered;
= 'S': Eigenvalues are ordered (see DELZTG).
DELZTG (input) LOGICAL FUNCTION of two COMPLEX*16 arguments
DELZTG must be declared EXTERNAL in the calling subroutine.
If SORT = 'N', DELZTG is not referenced.
If SORT = 'S', DELZTG is used to select eigenvalues to sort
to the top left of the Schur form.
An eigenvalue ALPHA(j)/BETA(j) is selected if
DELZTG(ALPHA(j),BETA(j)) is true.
Note that a selected complex eigenvalue may no longer satisfy
DELZTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since
ordering may change the value of complex eigenvalues
(especially if the eigenvalue is ill-conditioned), in this
case INFO is set to N+2 (See INFO below).
N (input) INTEGER
The order of the matrices A, B, VSL, and VSR. N >= 0.
A (input/output) COMPLEX*16 array, dimension (LDA, N)
On entry, the first of the pair of matrices.
On exit, A has been overwritten by its generalized Schur
form S.
LDA (input) INTEGER
The leading dimension of A. LDA >= max(1,N).
B (input/output) COMPLEX*16 array, dimension (LDB, N)
On entry, the second of the pair of matrices.
On exit, B has been overwritten by its generalized Schur
form T.
LDB (input) INTEGER
The leading dimension of B. LDB >= max(1,N).
SDIM (output) INTEGER
If SORT = 'N', SDIM = 0.
If SORT = 'S', SDIM = number of eigenvalues (after sorting)
for which DELZTG is true.
ALPHA (output) COMPLEX*16 array, dimension (N)
BETA (output) COMPLEX*16 array, dimension (N)
On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the
generalized eigenvalues. ALPHA(j), j=1,...,N and BETA(j),
j=1,...,N are the diagonals of the complex Schur form (A,B)
output by ZGGES. The BETA(j) will be non-negative real.
Note: the quotients ALPHA(j)/BETA(j) may easily over- or
underflow, and BETA(j) may even be zero. Thus, the user
should avoid naively computing the ratio alpha/beta.
However, ALPHA will be always less than and usually
comparable with norm(A) in magnitude, and BETA always less
than and usually comparable with norm(B).
VSL (output) COMPLEX*16 array, dimension (LDVSL,N)
If JOBVSL = 'V', VSL will contain the left Schur vectors.
Not referenced if JOBVSL = 'N'.
LDVSL (input) INTEGER
The leading dimension of the matrix VSL. LDVSL >= 1, and
if JOBVSL = 'V', LDVSL >= N.
VSR (output) COMPLEX*16 array, dimension (LDVSR,N)
If JOBVSR = 'V', VSR will contain the right Schur vectors.
Not referenced if JOBVSR = 'N'.
LDVSR (input) INTEGER
The leading dimension of the matrix VSR. LDVSR >= 1, and
if JOBVSR = 'V', LDVSR >= N.
WORK (workspace/output) COMPLEX*16 array, dimension (LWORK)
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK. LWORK >= max(1,2*N).
For good performance, LWORK must generally be larger.
If LWORK = -1, then a workspace query is assumed; the routine
only calculates the optimal size of the WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
RWORK (workspace) DOUBLE PRECISION array, dimension (8*N)
BWORK (workspace) LOGICAL array, dimension (N)
Not referenced if SORT = 'N'.
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value.
=1,...,N:
The QZ iteration failed. (A,B) are not in Schur
form, but ALPHA(j) and BETA(j) should be correct for
j=INFO+1,...,N.
> N: =N+1: other than QZ iteration failed in ZHGEQZ
=N+2: after reordering, roundoff changed values of
some complex eigenvalues so that leading
eigenvalues in the Generalized Schur form no
longer satisfy DELZTG=.TRUE. This could also
be caused due to scaling.
=N+3: reordering falied in ZTGSEN.
=====================================================================
Decode the input arguments
Parameter adjustments */
/* Table of constant values */
static doublecomplex c_b1 = {0.,0.};
static doublecomplex c_b2 = {1.,0.};
static integer c__1 = 1;
static integer c__0 = 0;
static integer c_n1 = -1;
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vsl_dim1, vsl_offset,
vsr_dim1, vsr_offset, i__1, i__2;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
static doublereal anrm, bnrm;
static integer idum[1], ierr, itau, iwrk;
static doublereal pvsl, pvsr;
static integer i__;
extern logical lsame_(char *, char *);
static integer ileft, icols;
static logical cursl, ilvsl, ilvsr;
static integer irwrk, irows;
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *);
extern doublereal dlamch_(char *);
extern /* Subroutine */ int zggbak_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublecomplex *,
integer *, integer *), zggbal_(char *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
, integer *, doublereal *, doublereal *, doublereal *, integer *);
static logical ilascl, ilbscl;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *,
integer *, doublereal *);
static doublereal bignum;
static integer ijobvl, iright;
extern /* Subroutine */ int zgghrd_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
), zlascl_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, integer *, doublecomplex *,
integer *, integer *);
static integer ijobvr;
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
);
static doublereal anrmto;
static integer lwkmin;
static logical lastsl;
static doublereal bnrmto;
extern /* Subroutine */ int zlacpy_(char *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *),
zlaset_(char *, integer *, integer *, doublecomplex *,
doublecomplex *, doublecomplex *, integer *), zhgeqz_(
char *, char *, char *, integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *,
doublereal *, integer *), ztgsen_(integer
*, logical *, logical *, logical *, integer *, doublecomplex *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, doublecomplex *, integer *, doublecomplex *,
integer *, integer *, doublereal *, doublereal *, doublereal *,
doublecomplex *, integer *, integer *, integer *, integer *);
static doublereal smlnum;
static logical wantst, lquery;
static integer lwkopt;
extern /* Subroutine */ int zungqr_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *), zunmqr_(char *, char *, integer *, integer
*, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
static doublereal dif[2];
static integer ihi, ilo;
static doublereal eps;
#define a_subscr(a_1,a_2) (a_2)*a_dim1 + a_1
#define a_ref(a_1,a_2) a[a_subscr(a_1,a_2)]
#define b_subscr(a_1,a_2) (a_2)*b_dim1 + a_1
#define b_ref(a_1,a_2) b[b_subscr(a_1,a_2)]
#define vsl_subscr(a_1,a_2) (a_2)*vsl_dim1 + a_1
#define vsl_ref(a_1,a_2) vsl[vsl_subscr(a_1,a_2)]
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
--alpha;
--beta;
vsl_dim1 = *ldvsl;
vsl_offset = 1 + vsl_dim1 * 1;
vsl -= vsl_offset;
vsr_dim1 = *ldvsr;
vsr_offset = 1 + vsr_dim1 * 1;
vsr -= vsr_offset;
--work;
--rwork;
--bwork;
/* Function Body */
if (lsame_(jobvsl, "N")) {
ijobvl = 1;
ilvsl = FALSE_;
} else if (lsame_(jobvsl, "V")) {
ijobvl = 2;
ilvsl = TRUE_;
} else {
ijobvl = -1;
ilvsl = FALSE_;
}
if (lsame_(jobvsr, "N")) {
ijobvr = 1;
ilvsr = FALSE_;
} else if (lsame_(jobvsr, "V")) {
ijobvr = 2;
ilvsr = TRUE_;
} else {
ijobvr = -1;
ilvsr = FALSE_;
}
wantst = lsame_(sort, "S");
/* Test the input arguments */
*info = 0;
lquery = *lwork == -1;
if (ijobvl <= 0) {
*info = -1;
} else if (ijobvr <= 0) {
*info = -2;
} else if (! wantst && ! lsame_(sort, "N")) {
*info = -3;
} else if (*n < 0) {
*info = -5;
} else if (*lda < max(1,*n)) {
*info = -7;
} else if (*ldb < max(1,*n)) {
*info = -9;
} else if (*ldvsl < 1 || ilvsl && *ldvsl < *n) {
*info = -14;
} else if (*ldvsr < 1 || ilvsr && *ldvsr < *n) {
*info = -16;
}
/* 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.) */
lwkmin = 1;
if (*info == 0 && (*lwork >= 1 || lquery)) {
/* Computing MAX */
i__1 = 1, i__2 = *n << 1;
lwkmin = max(i__1,i__2);
lwkopt = *n + *n * ilaenv_(&c__1, "ZGEQRF", " ", n, &c__1, n, &c__0, (
ftnlen)6, (ftnlen)1);
if (ilvsl) {
/* Computing MAX */
i__1 = lwkopt, i__2 = *n + *n * ilaenv_(&c__1, "ZUNGQR", " ", n, &
c__1, n, &c_n1, (ftnlen)6, (ftnlen)1);
lwkopt = max(i__1,i__2);
}
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
}
if (*lwork < lwkmin && ! lquery) {
*info = -18;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGGES ", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
if (*n == 0) {
*sdim = 0;
return 0;
}
/* Get machine constants */
eps = dlamch_("P");
smlnum = dlamch_("S");
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
smlnum = sqrt(smlnum) / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", n, n, &a[a_offset], lda, &rwork[1]);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE_;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, &
ierr);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = zlange_("M", n, n, &b[b_offset], ldb, &rwork[1]);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE_;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, &
ierr);
}
/* Permute the matrix to make it more nearly triangular
(Real Workspace: need 6*N) */
ileft = 1;
iright = *n + 1;
irwrk = iright + *n;
zggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &rwork[
ileft], &rwork[iright], &rwork[irwrk], &ierr);
/* Reduce B to triangular form (QR decomposition of B)
(Complex Workspace: need N, prefer N*NB) */
irows = ihi + 1 - ilo;
icols = *n + 1 - ilo;
itau = 1;
iwrk = itau + irows;
i__1 = *lwork + 1 - iwrk;
zgeqrf_(&irows, &icols, &b_ref(ilo, ilo), ldb, &work[itau], &work[iwrk], &
i__1, &ierr);
/* Apply the orthogonal transformation to matrix A
(Complex Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
zunmqr_("L", "C", &irows, &icols, &irows, &b_ref(ilo, ilo), ldb, &work[
itau], &a_ref(ilo, ilo), lda, &work[iwrk], &i__1, &ierr);
/* Initialize VSL
(Complex Workspace: need N, prefer N*NB) */
if (ilvsl) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vsl[vsl_offset], ldvsl);
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &b_ref(ilo + 1, ilo), ldb, &vsl_ref(ilo +
1, ilo), ldvsl);
i__1 = *lwork + 1 - iwrk;
zungqr_(&irows, &irows, &irows, &vsl_ref(ilo, ilo), ldvsl, &work[itau]
, &work[iwrk], &i__1, &ierr);
}
/* Initialize VSR */
if (ilvsr) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vsr[vsr_offset], ldvsr);
}
/* Reduce to generalized Hessenberg form
(Workspace: none needed) */
zgghrd_(jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vsl[vsl_offset], ldvsl, &vsr[vsr_offset], ldvsr, &ierr);
*sdim = 0;
/* Perform QZ algorithm, computing Schur vectors if desired
(Complex Workspace: need N)
(Real Workspace: need N) */
iwrk = itau;
i__1 = *lwork + 1 - iwrk;
zhgeqz_("S", jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alpha[1], &beta[1], &vsl[vsl_offset], ldvsl, &
vsr[vsr_offset], ldvsr, &work[iwrk], &i__1, &rwork[irwrk], &ierr);
if (ierr != 0) {
if (ierr > 0 && ierr <= *n) {
*info = ierr;
} else if (ierr > *n && ierr <= *n << 1) {
*info = ierr - *n;
} else {
*info = *n + 1;
}
goto L30;
}
/* Sort eigenvalues ALPHA/BETA if desired
(Workspace: none needed) */
if (wantst) {
/* Undo scaling on eigenvalues before selecting */
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, &c__1, &alpha[1], n,
&ierr);
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, &c__1, &beta[1], n,
&ierr);
}
/* Select eigenvalues */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
bwork[i__] = (*delctg)(&alpha[i__], &beta[i__]);
/* L10: */
}
i__1 = *lwork - iwrk + 1;
ztgsen_(&c__0, &ilvsl, &ilvsr, &bwork[1], n, &a[a_offset], lda, &b[
b_offset], ldb, &alpha[1], &beta[1], &vsl[vsl_offset], ldvsl,
&vsr[vsr_offset], ldvsr, sdim, &pvsl, &pvsr, dif, &work[iwrk],
&i__1, idum, &c__1, &ierr);
if (ierr == 1) {
*info = *n + 3;
}
}
/* Apply back-permutation to VSL and VSR
(Workspace: none needed) */
if (ilvsl) {
zggbak_("P", "L", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, &
vsl[vsl_offset], ldvsl, &ierr);
}
if (ilvsr) {
zggbak_("P", "R", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, &
vsr[vsr_offset], ldvsr, &ierr);
}
/* Undo scaling */
if (ilascl) {
zlascl_("U", &c__0, &c__0, &anrmto, &anrm, n, n, &a[a_offset], lda, &
ierr);
zlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alpha[1], n, &
ierr);
}
if (ilbscl) {
zlascl_("U", &c__0, &c__0, &bnrmto, &bnrm, n, n, &b[b_offset], ldb, &
ierr);
zlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, &
ierr);
}
if (wantst) {
/* Check if reordering is correct */
lastsl = TRUE_;
*sdim = 0;
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
cursl = (*delctg)(&alpha[i__], &beta[i__]);
if (cursl) {
++(*sdim);
}
if (cursl && ! lastsl) {
*info = *n + 2;
}
lastsl = cursl;
/* L20: */
}
}
L30:
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
return 0;
/* End of ZGGES */
} /* zgges_ */
int main(void)
{
/* Local scalars */
lapack_int m, m_i;
lapack_int n, n_i;
lapack_int lda, lda_i;
lapack_int lda_r;
lapack_int lwork, lwork_i;
lapack_int info, info_i;
lapack_int i;
int failed;
/* Local arrays */
lapack_complex_double *a = NULL, *a_i = NULL;
lapack_complex_double *tau = NULL, *tau_i = NULL;
lapack_complex_double *work = NULL, *work_i = NULL;
lapack_complex_double *a_save = NULL;
lapack_complex_double *tau_save = NULL;
lapack_complex_double *a_r = NULL;
/* Iniitialize the scalar parameters */
init_scalars_zgeqrf( &m, &n, &lda, &lwork );
lda_r = n+2;
m_i = m;
n_i = n;
lda_i = lda;
lwork_i = lwork;
/* Allocate memory for the LAPACK routine arrays */
a = (lapack_complex_double *)
LAPACKE_malloc( lda*n * sizeof(lapack_complex_double) );
tau = (lapack_complex_double *)
LAPACKE_malloc( MIN(m,n) * sizeof(lapack_complex_double) );
work = (lapack_complex_double *)
LAPACKE_malloc( lwork * sizeof(lapack_complex_double) );
/* Allocate memory for the C interface function arrays */
a_i = (lapack_complex_double *)
LAPACKE_malloc( lda*n * sizeof(lapack_complex_double) );
tau_i = (lapack_complex_double *)
LAPACKE_malloc( MIN(m,n) * sizeof(lapack_complex_double) );
work_i = (lapack_complex_double *)
LAPACKE_malloc( lwork * sizeof(lapack_complex_double) );
/* Allocate memory for the backup arrays */
a_save = (lapack_complex_double *)
LAPACKE_malloc( lda*n * sizeof(lapack_complex_double) );
tau_save = (lapack_complex_double *)
LAPACKE_malloc( MIN(m,n) * sizeof(lapack_complex_double) );
/* Allocate memory for the row-major arrays */
a_r = (lapack_complex_double *)
LAPACKE_malloc( m*(n+2) * sizeof(lapack_complex_double) );
/* Initialize input arrays */
init_a( lda*n, a );
init_tau( (MIN(m,n)), tau );
init_work( lwork, work );
/* Backup the ouptut arrays */
for( i = 0; i < lda*n; i++ ) {
a_save[i] = a[i];
}
for( i = 0; i < (MIN(m,n)); i++ ) {
tau_save[i] = tau[i];
}
/* Call the LAPACK routine */
zgeqrf_( &m, &n, a, &lda, tau, work, &lwork, &info );
/* Initialize input data, call the column-major middle-level
* interface to LAPACK routine and check the results */
for( i = 0; i < lda*n; i++ ) {
a_i[i] = a_save[i];
}
for( i = 0; i < (MIN(m,n)); i++ ) {
tau_i[i] = tau_save[i];
}
for( i = 0; i < lwork; i++ ) {
work_i[i] = work[i];
}
info_i = LAPACKE_zgeqrf_work( LAPACK_COL_MAJOR, m_i, n_i, a_i, lda_i, tau_i,
work_i, lwork_i );
failed = compare_zgeqrf( a, a_i, tau, tau_i, info, info_i, lda, m, n );
if( failed == 0 ) {
printf( "PASSED: column-major middle-level interface to zgeqrf\n" );
} else {
printf( "FAILED: column-major middle-level interface to zgeqrf\n" );
}
/* Initialize input data, call the column-major high-level
* interface to LAPACK routine and check the results */
for( i = 0; i < lda*n; i++ ) {
a_i[i] = a_save[i];
}
for( i = 0; i < (MIN(m,n)); i++ ) {
tau_i[i] = tau_save[i];
}
for( i = 0; i < lwork; i++ ) {
work_i[i] = work[i];
}
info_i = LAPACKE_zgeqrf( LAPACK_COL_MAJOR, m_i, n_i, a_i, lda_i, tau_i );
failed = compare_zgeqrf( a, a_i, tau, tau_i, info, info_i, lda, m, n );
if( failed == 0 ) {
printf( "PASSED: column-major high-level interface to zgeqrf\n" );
} else {
printf( "FAILED: column-major high-level interface to zgeqrf\n" );
}
/* Initialize input data, call the row-major middle-level
* interface to LAPACK routine and check the results */
for( i = 0; i < lda*n; i++ ) {
a_i[i] = a_save[i];
}
for( i = 0; i < (MIN(m,n)); i++ ) {
tau_i[i] = tau_save[i];
}
for( i = 0; i < lwork; i++ ) {
work_i[i] = work[i];
}
LAPACKE_zge_trans( LAPACK_COL_MAJOR, m, n, a_i, lda, a_r, n+2 );
info_i = LAPACKE_zgeqrf_work( LAPACK_ROW_MAJOR, m_i, n_i, a_r, lda_r, tau_i,
work_i, lwork_i );
LAPACKE_zge_trans( LAPACK_ROW_MAJOR, m, n, a_r, n+2, a_i, lda );
failed = compare_zgeqrf( a, a_i, tau, tau_i, info, info_i, lda, m, n );
if( failed == 0 ) {
printf( "PASSED: row-major middle-level interface to zgeqrf\n" );
} else {
printf( "FAILED: row-major middle-level interface to zgeqrf\n" );
}
/* Initialize input data, call the row-major high-level
* interface to LAPACK routine and check the results */
for( i = 0; i < lda*n; i++ ) {
a_i[i] = a_save[i];
}
for( i = 0; i < (MIN(m,n)); i++ ) {
tau_i[i] = tau_save[i];
}
for( i = 0; i < lwork; i++ ) {
work_i[i] = work[i];
}
/* Init row_major arrays */
LAPACKE_zge_trans( LAPACK_COL_MAJOR, m, n, a_i, lda, a_r, n+2 );
info_i = LAPACKE_zgeqrf( LAPACK_ROW_MAJOR, m_i, n_i, a_r, lda_r, tau_i );
LAPACKE_zge_trans( LAPACK_ROW_MAJOR, m, n, a_r, n+2, a_i, lda );
failed = compare_zgeqrf( a, a_i, tau, tau_i, info, info_i, lda, m, n );
if( failed == 0 ) {
printf( "PASSED: row-major high-level interface to zgeqrf\n" );
} else {
printf( "FAILED: row-major high-level interface to zgeqrf\n" );
}
/* Release memory */
if( a != NULL ) {
LAPACKE_free( a );
}
if( a_i != NULL ) {
LAPACKE_free( a_i );
}
if( a_r != NULL ) {
LAPACKE_free( a_r );
}
if( a_save != NULL ) {
LAPACKE_free( a_save );
}
if( tau != NULL ) {
LAPACKE_free( tau );
}
if( tau_i != NULL ) {
LAPACKE_free( tau_i );
}
if( tau_save != NULL ) {
LAPACKE_free( tau_save );
}
if( work != NULL ) {
LAPACKE_free( work );
}
if( work_i != NULL ) {
LAPACKE_free( work_i );
}
return 0;
}
/* Subroutine */ int zggrqf_(integer *m, integer *p, integer *n,
doublecomplex *a, integer *lda, doublecomplex *taua, doublecomplex *b,
integer *ldb, doublecomplex *taub, doublecomplex *work, integer *
lwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3;
/* Local variables */
integer nb, nb1, nb2, nb3, lopt;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
), zgerqf_(integer *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, integer *, integer *);
integer lwkopt;
logical lquery;
extern /* Subroutine */ int zunmrq_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZGGRQF computes a generalized RQ factorization of an M-by-N matrix A */
/* and a P-by-N matrix B: */
/* A = R*Q, B = Z*T*Q, */
/* where Q is an N-by-N unitary matrix, Z is a P-by-P unitary */
/* matrix, and R and T assume one of the forms: */
/* if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, */
/* N-M M ( R21 ) N */
/* N */
/* where R12 or R21 is upper triangular, and */
/* if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, */
/* ( 0 ) P-N P N-P */
/* N */
/* where T11 is upper triangular. */
/* In particular, if B is square and nonsingular, the GRQ factorization */
/* of A and B implicitly gives the RQ factorization of A*inv(B): */
/* A*inv(B) = (R*inv(T))*Z' */
/* where inv(B) denotes the inverse of the matrix B, and Z' denotes the */
/* conjugate transpose of the matrix Z. */
/* Arguments */
/* ========= */
/* M (input) INTEGER */
/* The number of rows of the matrix A. M >= 0. */
/* P (input) INTEGER */
/* The number of rows of the matrix B. P >= 0. */
/* N (input) INTEGER */
/* The number of columns of the matrices A and B. N >= 0. */
/* A (input/output) COMPLEX*16 array, dimension (LDA,N) */
/* On entry, the M-by-N matrix A. */
/* On exit, if M <= N, the upper triangle of the subarray */
/* A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R; */
/* if M > N, the elements on and above the (M-N)-th subdiagonal */
/* contain the M-by-N upper trapezoidal matrix R; the remaining */
/* elements, with the array TAUA, represent the unitary */
/* matrix Q as a product of elementary reflectors (see Further */
/* Details). */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= max(1,M). */
/* TAUA (output) COMPLEX*16 array, dimension (min(M,N)) */
/* The scalar factors of the elementary reflectors which */
/* represent the unitary matrix Q (see Further Details). */
/* B (input/output) COMPLEX*16 array, dimension (LDB,N) */
/* On entry, the P-by-N matrix B. */
/* On exit, the elements on and above the diagonal of the array */
/* contain the min(P,N)-by-N upper trapezoidal matrix T (T is */
/* upper triangular if P >= N); the elements below the diagonal, */
/* with the array TAUB, represent the unitary matrix Z as a */
/* product of elementary reflectors (see Further Details). */
/* LDB (input) INTEGER */
/* The leading dimension of the array B. LDB >= max(1,P). */
/* TAUB (output) COMPLEX*16 array, dimension (min(P,N)) */
/* The scalar factors of the elementary reflectors which */
/* represent the unitary matrix Z (see Further Details). */
/* WORK (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= max(1,N,M,P). */
/* For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3), */
/* where NB1 is the optimal blocksize for the RQ factorization */
/* of an M-by-N matrix, NB2 is the optimal blocksize for the */
/* QR factorization of a P-by-N matrix, and NB3 is the optimal */
/* blocksize for a call of ZUNMRQ. */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the WORK array, returns */
/* this value as the first entry of the WORK array, and no error */
/* message related to LWORK is issued by XERBLA. */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO=-i, the i-th argument had an illegal value. */
/* Further Details */
/* =============== */
/* The matrix Q is represented as a product of elementary reflectors */
/* Q = H(1) H(2) . . . H(k), where k = min(m,n). */
/* Each H(i) has the form */
/* H(i) = I - taua * v * v' */
/* where taua is a complex scalar, and v is a complex vector with */
/* v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in */
/* A(m-k+i,1:n-k+i-1), and taua in TAUA(i). */
/* To form Q explicitly, use LAPACK subroutine ZUNGRQ. */
/* To use Q to update another matrix, use LAPACK subroutine ZUNMRQ. */
/* The matrix Z is represented as a product of elementary reflectors */
/* Z = H(1) H(2) . . . H(k), where k = min(p,n). */
/* Each H(i) has the form */
/* H(i) = I - taub * v * v' */
/* where taub is a complex scalar, and v is a complex vector with */
/* v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i), */
/* and taub in TAUB(i). */
/* To form Z explicitly, use LAPACK subroutine ZUNGQR. */
/* To use Z to update another matrix, use LAPACK subroutine ZUNMQR. */
/* ===================================================================== */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--taua;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
--taub;
--work;
/* Function Body */
*info = 0;
nb1 = ilaenv_(&c__1, "ZGERQF", " ", m, n, &c_n1, &c_n1);
nb2 = ilaenv_(&c__1, "ZGEQRF", " ", p, n, &c_n1, &c_n1);
nb3 = ilaenv_(&c__1, "ZUNMRQ", " ", m, n, p, &c_n1);
/* Computing MAX */
i__1 = max(nb1,nb2);
nb = max(i__1,nb3);
/* Computing MAX */
i__1 = max(*n,*m);
lwkopt = max(i__1,*p) * nb;
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
lquery = *lwork == -1;
if (*m < 0) {
*info = -1;
} else if (*p < 0) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*lda < max(1,*m)) {
*info = -5;
} else if (*ldb < max(1,*p)) {
*info = -8;
} else /* if(complicated condition) */ {
/* Computing MAX */
i__1 = max(1,*m), i__1 = max(i__1,*p);
if (*lwork < max(i__1,*n) && ! lquery) {
*info = -11;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGGRQF", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* RQ factorization of M-by-N matrix A: A = R*Q */
zgerqf_(m, n, &a[a_offset], lda, &taua[1], &work[1], lwork, info);
lopt = (integer) work[1].r;
/* Update B := B*Q' */
i__1 = min(*m,*n);
/* Computing MAX */
i__2 = 1, i__3 = *m - *n + 1;
zunmrq_("Right", "Conjugate Transpose", p, n, &i__1, &a[max(i__2, i__3)+
a_dim1], lda, &taua[1], &b[b_offset], ldb, &work[1], lwork, info);
/* Computing MAX */
i__1 = lopt, i__2 = (integer) work[1].r;
lopt = max(i__1,i__2);
/* QR factorization of P-by-N matrix B: B = Z*T */
zgeqrf_(p, n, &b[b_offset], ldb, &taub[1], &work[1], lwork, info);
/* Computing MAX */
i__2 = lopt, i__3 = (integer) work[1].r;
i__1 = max(i__2,i__3);
work[1].r = (doublereal) i__1, work[1].i = 0.;
return 0;
/* End of ZGGRQF */
} /* zggrqf_ */
/* Subroutine */ int zlaqzh_(logical *ilq, logical *ilz, integer *n, integer *
ilo, integer *ihi, doublecomplex *a, integer *lda, doublecomplex *b,
integer *ldb, doublecomplex *q, integer *ldq, doublecomplex *z__,
integer *ldz, doublecomplex *work, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, q_dim1, q_offset, z_dim1,
z_offset, i__1, i__2;
/* Local variables */
static integer iinfo, icols;
static char compq[1], compz[1];
static integer irows;
extern /* Subroutine */ int zgghrd_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
), zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *)
, zlacpy_(char *, integer *, integer *, doublecomplex *, integer *
, doublecomplex *, integer *), zlaset_(char *, integer *,
integer *, doublecomplex *, doublecomplex *, doublecomplex *,
integer *), zungqr_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *), zunmqr_(char *, char *, integer *, integer
*, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
#define a_subscr(a_1,a_2) (a_2)*a_dim1 + a_1
#define a_ref(a_1,a_2) a[a_subscr(a_1,a_2)]
#define b_subscr(a_1,a_2) (a_2)*b_dim1 + a_1
#define b_ref(a_1,a_2) b[b_subscr(a_1,a_2)]
#define q_subscr(a_1,a_2) (a_2)*q_dim1 + a_1
#define q_ref(a_1,a_2) q[q_subscr(a_1,a_2)]
/* -- LAPACK timing 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
=======
This calls the LAPACK routines to perform the function of
QZHES. It is similar in function to ZGGHRD, except that
B is not assumed to be upper-triangular.
It reduces a pair of matrices (A,B) to a Hessenberg-triangular
pair (H,T). More specifically, it computes unitary matrices
Q and Z, an (upper) Hessenberg matrix H, and an upper triangular
matrix T such that:
A = Q H Z* and B = Q T Z*
where * means conjugate transpose.
Arguments
=========
ILQ (input) LOGICAL
= .FALSE. do not compute Q.
= .TRUE. compute Q.
ILZ (input) LOGICAL
= .FALSE. do not compute Z.
= .TRUE. compute Z.
N (input) INTEGER
The number of rows and columns in the matrices A, B, Q, and
Z. N must be at least 0.
ILO (input) INTEGER
Columns 1 through ILO-1 of A and B are assumed to be in
upper triangular form already, and will not be modified.
ILO must be at least 1.
IHI (input) INTEGER
Rows IHI+1 through N of A and B are assumed to be in upper
triangular form already, and will not be touched. IHI may
not be greater than N.
A (input/output) COMPLEX*16 array, dimension (LDA, N)
On entry, the first of the pair of N x N general matrices to
be reduced.
On exit, the upper triangle and the first subdiagonal of A
are overwritten with the Hessenberg matrix H, and the rest
is set to zero.
LDA (input) INTEGER
The leading dimension of A as declared in the calling
program. LDA must be at least max ( 1, N ) .
B (input/output) COMPLEX*16 array, dimension (LDB, N)
On entry, the second of the pair of N x N general matrices to
be reduced.
On exit, the transformed matrix T = Q* B Z, which is upper
triangular.
LDB (input) INTEGER
The leading dimension of B as declared in the calling
program. LDB must be at least max ( 1, N ) .
Q (output) COMPLEX*16 array, dimension (LDQ,N)
If ILQ = .TRUE., Q will contain the unitary matrix Q.
(See "Purpose", above.)
Will not be referenced if ILQ = .FALSE.
LDQ (input) INTEGER
The leading dimension of the matrix Q. LDQ must be at
least 1 and at least N.
Z (output) COMPLEX*16 array, dimension (LDZ,N)
If ILZ = .TRUE., Z will contain the unitary matrix Z.
(See "Purpose", above.)
May be referenced even if ILZ = .FALSE.
LDZ (input) INTEGER
The leading dimension of the matrix Z. LDZ must be at
least 1 and at least N.
WORK (workspace) COMPLEX*16 array, dimension (N)
Workspace.
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: errors that usually indicate LAPACK problems:
= 2: error return from ZGEQRF;
= 3: error return from ZUNMQR;
= 4: error return from ZUNGQR;
= 5: error return from ZGGHRD.
=====================================================================
Quick return if possible
Parameter adjustments */
--work;
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
q_dim1 = *ldq;
q_offset = 1 + q_dim1 * 1;
q -= q_offset;
z_dim1 = *ldz;
z_offset = 1 + z_dim1 * 1;
z__ -= z_offset;
/* Function Body */
if (*n == 0) {
return 0;
}
/* Reduce B to triangular form, and initialize Q and/or Z */
irows = *ihi + 1 - *ilo;
icols = *n + 1 - *ilo;
i__1 = *n * *ldz;
zgeqrf_(&irows, &icols, &b_ref(*ilo, *ilo), ldb, &work[1], &z__[z_offset],
&i__1, &iinfo);
if (iinfo != 0) {
*info = 2;
goto L10;
}
i__1 = *n * *ldz;
zunmqr_("L", "C", &irows, &icols, &irows, &b_ref(*ilo, *ilo), ldb, &work[
1], &a_ref(*ilo, *ilo), lda, &z__[z_offset], &i__1, &iinfo);
if (iinfo != 0) {
*info = 3;
goto L10;
}
if (*ilq) {
zlaset_("Full", n, n, &c_b1, &c_b2, &q[q_offset], ldq);
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &b_ref(*ilo + 1, *ilo), ldb, &q_ref(*ilo +
1, *ilo), ldq);
i__1 = *n * *ldz;
zungqr_(&irows, &irows, &irows, &q_ref(*ilo, *ilo), ldq, &work[1], &
z__[z_offset], &i__1, &iinfo);
if (iinfo != 0) {
*info = 4;
goto L10;
}
}
/* Reduce to generalized Hessenberg form */
if (*ilq) {
*(unsigned char *)compq = 'V';
} else {
*(unsigned char *)compq = 'N';
}
if (*ilz) {
*(unsigned char *)compz = 'I';
} else {
*(unsigned char *)compz = 'N';
}
zgghrd_(compq, compz, n, ilo, ihi, &a[a_offset], lda, &b[b_offset], ldb, &
q[q_offset], ldq, &z__[z_offset], ldz, &iinfo);
if (iinfo != 0) {
*info = 5;
goto L10;
}
/* End */
L10:
return 0;
/* End of ZLAQZH */
} /* zlaqzh_ */
/* Subroutine */ int zgelsd_(integer *m, integer *n, integer *nrhs,
doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb,
doublereal *s, doublereal *rcond, integer *rank, doublecomplex *work,
integer *lwork, doublereal *rwork, integer *iwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3, i__4;
/* Local variables */
integer ie, il, mm;
doublereal eps, anrm, bnrm;
integer itau, nlvl, iascl, ibscl;
doublereal sfmin;
integer minmn, maxmn, itaup, itauq, mnthr, nwork;
doublereal bignum;
integer ldwork;
integer liwork, minwrk, maxwrk;
doublereal smlnum;
integer lrwork;
logical lquery;
integer nrwork, smlsiz;
/* -- LAPACK driver routine (version 3.2) -- */
/* November 2006 */
/* Purpose */
/* ======= */
/* ZGELSD 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 problem is solved in three steps: */
/* (1) Reduce the coefficient matrix A to bidiagonal form with */
/* Householder tranformations, reducing the original problem */
/* into a "bidiagonal least squares problem" (BLS) */
/* (2) Solve the BLS using a divide and conquer approach. */
/* (3) Apply back all the Householder tranformations to solve */
/* the original least squares problem. */
/* The effective rank of A is determined by treating as zero those */
/* singular values which are less than RCOND times the largest singular */
/* value. */
/* The divide and conquer algorithm makes very mild assumptions about */
/* floating point arithmetic. It will work on machines with a guard */
/* digit in add/subtract, or on those binary machines without guard */
/* digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or */
/* Cray-2. It could conceivably fail on hexadecimal or decimal machines */
/* without guard digits, but we know of none. */
/* 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) COMPLEX*16 array, dimension (LDA,N) */
/* On entry, the M-by-N matrix A. */
/* On exit, A has been destroyed. */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= max(1,M). */
/* B (input/output) COMPLEX*16 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 the modulus of elements n+1:m in that column. */
/* LDB (input) INTEGER */
/* The leading dimension of the array B. LDB >= max(1,M,N). */
/* S (output) DOUBLE PRECISION 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) DOUBLE PRECISION */
/* 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) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK must be at least 1. */
/* The exact minimum amount of workspace needed depends on M, */
/* N and NRHS. As long as LWORK is at least */
/* 2*N + N*NRHS */
/* if M is greater than or equal to N or */
/* 2*M + M*NRHS */
/* if M is less than N, the code will execute correctly. */
/* For good performance, LWORK should generally be larger. */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the array WORK and the */
/* minimum sizes of the arrays RWORK and IWORK, and returns */
/* these values as the first entries of the WORK, RWORK and */
/* IWORK arrays, and no error message related to LWORK is issued */
/* by XERBLA. */
/* RWORK (workspace) DOUBLE PRECISION array, dimension (MAX(1,LRWORK)) */
/* LRWORK >= */
/* 10*N + 2*N*SMLSIZ + 8*N*NLVL + 3*SMLSIZ*NRHS + */
/* (SMLSIZ+1)**2 */
/* if M is greater than or equal to N or */
/* 10*M + 2*M*SMLSIZ + 8*M*NLVL + 3*SMLSIZ*NRHS + */
/* (SMLSIZ+1)**2 */
/* if M is less than N, the code will execute correctly. */
/* SMLSIZ is returned by ILAENV and is equal to the maximum */
/* size of the subproblems at the bottom of the computation */
/* tree (usually about 25), and */
/* NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 ) */
/* On exit, if INFO = 0, RWORK(1) returns the minimum LRWORK. */
/* IWORK (workspace) INTEGER array, dimension (MAX(1,LIWORK)) */
/* LIWORK >= max(1, 3*MINMN*NLVL + 11*MINMN), */
/* where MINMN = MIN( M,N ). */
/* On exit, if INFO = 0, IWORK(1) returns the minimum LIWORK. */
/* 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. */
/* Further Details */
/* =============== */
/* Based on contributions by */
/* Ming Gu and Ren-Cang Li, Computer Science Division, University of */
/* California at Berkeley, USA */
/* Osni Marques, LBNL/NERSC, USA */
/* ===================================================================== */
/* Test the input arguments. */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
--s;
--work;
--rwork;
--iwork;
/* Function Body */
*info = 0;
minmn = min(*m,*n);
maxmn = max(*m,*n);
lquery = *lwork == -1;
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.) */
if (*info == 0) {
minwrk = 1;
maxwrk = 1;
liwork = 1;
lrwork = 1;
if (minmn > 0) {
smlsiz = ilaenv_(&c__9, "ZGELSD", " ", &c__0, &c__0, &c__0, &c__0);
mnthr = ilaenv_(&c__6, "ZGELSD", " ", m, n, nrhs, &c_n1);
/* Computing MAX */
i__1 = (integer) (log((doublereal) minmn / (doublereal) (smlsiz +
1)) / log(2.)) + 1;
nlvl = max(i__1,0);
liwork = minmn * 3 * nlvl + minmn * 11;
mm = *m;
if (*m >= *n && *m >= mnthr) {
/* Path 1a - overdetermined, with many more rows than */
/* columns. */
mm = *n;
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * ilaenv_(&c__1, "ZGEQRF", " ", m, n,
&c_n1, &c_n1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *nrhs * ilaenv_(&c__1, "ZUNMQR", "LC",
m, nrhs, n, &c_n1);
maxwrk = max(i__1,i__2);
}
if (*m >= *n) {
/* Path 1 - overdetermined or exactly determined. */
/* Computing 2nd power */
i__1 = smlsiz + 1;
lrwork = *n * 10 + (*n << 1) * smlsiz + (*n << 3) * nlvl +
smlsiz * 3 * *nrhs + i__1 * i__1;
/* Computing MAX */
i__1 = maxwrk, i__2 = (*n << 1) + (mm + *n) * ilaenv_(&c__1,
"ZGEBRD", " ", &mm, n, &c_n1, &c_n1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*n << 1) + *nrhs * ilaenv_(&c__1,
"ZUNMBR", "QLC", &mm, nrhs, n, &c_n1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*n << 1) + (*n - 1) * ilaenv_(&c__1,
"ZUNMBR", "PLN", n, nrhs, n, &c_n1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*n << 1) + *n * *nrhs;
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = (*n << 1) + mm, i__2 = (*n << 1) + *n * *nrhs;
minwrk = max(i__1,i__2);
}
if (*n > *m) {
/* Computing 2nd power */
i__1 = smlsiz + 1;
lrwork = *m * 10 + (*m << 1) * smlsiz + (*m << 3) * nlvl +
smlsiz * 3 * *nrhs + i__1 * i__1;
if (*n >= mnthr) {
/* Path 2a - underdetermined, with many more columns */
/* than rows. */
maxwrk = *m + *m * ilaenv_(&c__1, "ZGELQF", " ", m, n, &
c_n1, &c_n1);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + (*m << 1) *
ilaenv_(&c__1, "ZGEBRD", " ", m, m, &c_n1, &c_n1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + *nrhs *
ilaenv_(&c__1, "ZUNMBR", "QLC", m, nrhs, m, &c_n1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + (*m - 1) *
ilaenv_(&c__1, "ZUNMLQ", "LC", n, nrhs, m, &c_n1);
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 * *m + (*m << 2) + *m * *nrhs;
maxwrk = max(i__1,i__2);
/* XXX: Ensure the Path 2a case below is triggered. The workspace */
/* calculation should use queries for all routines eventually. */
/* 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__1 = maxwrk, i__2 = (*m << 2) + *m * *m + max(i__3,i__4)
;
maxwrk = max(i__1,i__2);
} else {
/* Path 2 - underdetermined. */
maxwrk = (*m << 1) + (*n + *m) * ilaenv_(&c__1, "ZGEBRD",
" ", m, n, &c_n1, &c_n1);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*m << 1) + *nrhs * ilaenv_(&c__1,
"ZUNMBR", "QLC", m, nrhs, m, &c_n1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*m << 1) + *m * ilaenv_(&c__1,
"ZUNMBR", "PLN", n, nrhs, m, &c_n1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = (*m << 1) + *m * *nrhs;
maxwrk = max(i__1,i__2);
}
/* Computing MAX */
i__1 = (*m << 1) + *n, i__2 = (*m << 1) + *m * *nrhs;
minwrk = max(i__1,i__2);
}
}
minwrk = min(minwrk,maxwrk);
work[1].r = (doublereal) maxwrk, work[1].i = 0.;
iwork[1] = liwork;
rwork[1] = (doublereal) lrwork;
if (*lwork < minwrk && ! lquery) {
*info = -12;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGELSD", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible. */
if (*m == 0 || *n == 0) {
*rank = 0;
return 0;
}
/* Get machine parameters. */
eps = dlamch_("P");
sfmin = dlamch_("S");
smlnum = sfmin / eps;
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
/* Scale A if max entry outside range [SMLNUM,BIGNUM]. */
anrm = zlange_("M", m, n, &a[a_offset], lda, &rwork[1]);
iascl = 0;
if (anrm > 0. && anrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
zlascl_("G", &c__0, &c__0, &anrm, &smlnum, m, n, &a[a_offset], lda,
info);
iascl = 1;
} else if (anrm > bignum) {
/* Scale matrix norm down to BIGNUM. */
zlascl_("G", &c__0, &c__0, &anrm, &bignum, m, n, &a[a_offset], lda,
info);
iascl = 2;
} else if (anrm == 0.) {
/* Matrix all zero. Return zero solution. */
i__1 = max(*m,*n);
zlaset_("F", &i__1, nrhs, &c_b1, &c_b1, &b[b_offset], ldb);
dlaset_("F", &minmn, &c__1, &c_b80, &c_b80, &s[1], &c__1);
*rank = 0;
goto L10;
}
/* Scale B if max entry outside range [SMLNUM,BIGNUM]. */
bnrm = zlange_("M", m, nrhs, &b[b_offset], ldb, &rwork[1]);
ibscl = 0;
if (bnrm > 0. && bnrm < smlnum) {
/* Scale matrix norm up to SMLNUM. */
zlascl_("G", &c__0, &c__0, &bnrm, &smlnum, m, nrhs, &b[b_offset], ldb,
info);
ibscl = 1;
} else if (bnrm > bignum) {
/* Scale matrix norm down to BIGNUM. */
zlascl_("G", &c__0, &c__0, &bnrm, &bignum, m, nrhs, &b[b_offset], ldb,
info);
ibscl = 2;
}
/* If M < N make sure B(M+1:N,:) = 0 */
if (*m < *n) {
i__1 = *n - *m;
zlaset_("F", &i__1, nrhs, &c_b1, &c_b1, &b[*m + 1 + b_dim1], ldb);
}
/* Overdetermined case. */
if (*m >= *n) {
/* Path 1 - overdetermined or exactly determined. */
mm = *m;
if (*m >= mnthr) {
/* Path 1a - overdetermined, with many more rows than columns */
mm = *n;
itau = 1;
nwork = itau + *n;
/* Compute A=Q*R. */
/* (RWorkspace: need N) */
/* (CWorkspace: need N, prefer N*NB) */
i__1 = *lwork - nwork + 1;
zgeqrf_(m, n, &a[a_offset], lda, &work[itau], &work[nwork], &i__1,
info);
/* Multiply B by transpose(Q). */
/* (RWorkspace: need N) */
/* (CWorkspace: need NRHS, prefer NRHS*NB) */
i__1 = *lwork - nwork + 1;
zunmqr_("L", "C", m, nrhs, n, &a[a_offset], lda, &work[itau], &b[
b_offset], ldb, &work[nwork], &i__1, info);
/* Zero out below R. */
if (*n > 1) {
i__1 = *n - 1;
i__2 = *n - 1;
zlaset_("L", &i__1, &i__2, &c_b1, &c_b1, &a[a_dim1 + 2], lda);
}
}
itauq = 1;
itaup = itauq + *n;
nwork = itaup + *n;
ie = 1;
nrwork = ie + *n;
/* Bidiagonalize R in A. */
/* (RWorkspace: need N) */
/* (CWorkspace: need 2*N+MM, prefer 2*N+(MM+N)*NB) */
i__1 = *lwork - nwork + 1;
zgebrd_(&mm, n, &a[a_offset], lda, &s[1], &rwork[ie], &work[itauq], &
work[itaup], &work[nwork], &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors of R. */
/* (CWorkspace: need 2*N+NRHS, prefer 2*N+NRHS*NB) */
i__1 = *lwork - nwork + 1;
zunmbr_("Q", "L", "C", &mm, nrhs, n, &a[a_offset], lda, &work[itauq],
&b[b_offset], ldb, &work[nwork], &i__1, info);
/* Solve the bidiagonal least squares problem. */
zlalsd_("U", &smlsiz, n, nrhs, &s[1], &rwork[ie], &b[b_offset], ldb,
rcond, rank, &work[nwork], &rwork[nrwork], &iwork[1], info);
if (*info != 0) {
goto L10;
}
/* Multiply B by right bidiagonalizing vectors of R. */
i__1 = *lwork - nwork + 1;
zunmbr_("P", "L", "N", n, nrhs, n, &a[a_offset], lda, &work[itaup], &
b[b_offset], ldb, &work[nwork], &i__1, info);
} else /* if(complicated condition) */ {
/* Computing MAX */
i__1 = *m, i__2 = (*m << 1) - 4, i__1 = max(i__1,i__2), i__1 = max(
i__1,*nrhs), i__2 = *n - *m * 3;
if (*n >= mnthr && *lwork >= (*m << 2) + *m * *m + max(i__1,i__2)) {
/* Path 2a - underdetermined, with many more columns than rows */
/* 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__1 = (*m << 2) + *m * *lda + max(i__3,i__4), i__2 = *m * *lda +
*m + *m * *nrhs;
if (*lwork >= max(i__1,i__2)) {
ldwork = *lda;
}
itau = 1;
nwork = *m + 1;
/* Compute A=L*Q. */
/* (CWorkspace: need 2*M, prefer M+M*NB) */
i__1 = *lwork - nwork + 1;
zgelqf_(m, n, &a[a_offset], lda, &work[itau], &work[nwork], &i__1,
info);
il = nwork;
/* Copy L to WORK(IL), zeroing out above its diagonal. */
zlacpy_("L", m, m, &a[a_offset], lda, &work[il], &ldwork);
i__1 = *m - 1;
i__2 = *m - 1;
zlaset_("U", &i__1, &i__2, &c_b1, &c_b1, &work[il + ldwork], &
ldwork);
itauq = il + ldwork * *m;
itaup = itauq + *m;
nwork = itaup + *m;
ie = 1;
nrwork = ie + *m;
/* Bidiagonalize L in WORK(IL). */
/* (RWorkspace: need M) */
/* (CWorkspace: need M*M+4*M, prefer M*M+4*M+2*M*NB) */
i__1 = *lwork - nwork + 1;
zgebrd_(m, m, &work[il], &ldwork, &s[1], &rwork[ie], &work[itauq],
&work[itaup], &work[nwork], &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors of L. */
/* (CWorkspace: need M*M+4*M+NRHS, prefer M*M+4*M+NRHS*NB) */
i__1 = *lwork - nwork + 1;
zunmbr_("Q", "L", "C", m, nrhs, m, &work[il], &ldwork, &work[
itauq], &b[b_offset], ldb, &work[nwork], &i__1, info);
/* Solve the bidiagonal least squares problem. */
zlalsd_("U", &smlsiz, m, nrhs, &s[1], &rwork[ie], &b[b_offset],
ldb, rcond, rank, &work[nwork], &rwork[nrwork], &iwork[1],
info);
if (*info != 0) {
goto L10;
}
/* Multiply B by right bidiagonalizing vectors of L. */
i__1 = *lwork - nwork + 1;
zunmbr_("P", "L", "N", m, nrhs, m, &work[il], &ldwork, &work[
itaup], &b[b_offset], ldb, &work[nwork], &i__1, info);
/* Zero out below first M rows of B. */
i__1 = *n - *m;
zlaset_("F", &i__1, nrhs, &c_b1, &c_b1, &b[*m + 1 + b_dim1], ldb);
nwork = itau + *m;
/* Multiply transpose(Q) by B. */
/* (CWorkspace: need NRHS, prefer NRHS*NB) */
i__1 = *lwork - nwork + 1;
zunmlq_("L", "C", n, nrhs, m, &a[a_offset], lda, &work[itau], &b[
b_offset], ldb, &work[nwork], &i__1, info);
} else {
/* Path 2 - remaining underdetermined cases. */
itauq = 1;
itaup = itauq + *m;
nwork = itaup + *m;
ie = 1;
nrwork = ie + *m;
/* Bidiagonalize A. */
/* (RWorkspace: need M) */
/* (CWorkspace: need 2*M+N, prefer 2*M+(M+N)*NB) */
i__1 = *lwork - nwork + 1;
zgebrd_(m, n, &a[a_offset], lda, &s[1], &rwork[ie], &work[itauq],
&work[itaup], &work[nwork], &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors. */
/* (CWorkspace: need 2*M+NRHS, prefer 2*M+NRHS*NB) */
i__1 = *lwork - nwork + 1;
zunmbr_("Q", "L", "C", m, nrhs, n, &a[a_offset], lda, &work[itauq]
, &b[b_offset], ldb, &work[nwork], &i__1, info);
/* Solve the bidiagonal least squares problem. */
zlalsd_("L", &smlsiz, m, nrhs, &s[1], &rwork[ie], &b[b_offset],
ldb, rcond, rank, &work[nwork], &rwork[nrwork], &iwork[1],
info);
if (*info != 0) {
goto L10;
}
/* Multiply B by right bidiagonalizing vectors of A. */
i__1 = *lwork - nwork + 1;
zunmbr_("P", "L", "N", n, nrhs, m, &a[a_offset], lda, &work[itaup]
, &b[b_offset], ldb, &work[nwork], &i__1, info);
}
}
/* Undo scaling. */
if (iascl == 1) {
zlascl_("G", &c__0, &c__0, &anrm, &smlnum, n, nrhs, &b[b_offset], ldb,
info);
dlascl_("G", &c__0, &c__0, &smlnum, &anrm, &minmn, &c__1, &s[1], &
minmn, info);
} else if (iascl == 2) {
zlascl_("G", &c__0, &c__0, &anrm, &bignum, n, nrhs, &b[b_offset], ldb,
info);
dlascl_("G", &c__0, &c__0, &bignum, &anrm, &minmn, &c__1, &s[1], &
minmn, info);
}
if (ibscl == 1) {
zlascl_("G", &c__0, &c__0, &smlnum, &bnrm, n, nrhs, &b[b_offset], ldb,
info);
} else if (ibscl == 2) {
zlascl_("G", &c__0, &c__0, &bignum, &bnrm, n, nrhs, &b[b_offset], ldb,
info);
}
L10:
work[1].r = (doublereal) maxwrk, work[1].i = 0.;
iwork[1] = liwork;
rwork[1] = (doublereal) lrwork;
return 0;
/* End of ZGELSD */
} /* zgelsd_ */
/* Subroutine */ int zggev_(char *jobvl, char *jobvr, integer *n,
doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb,
doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer
*ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer
*lwork, doublereal *rwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vl_dim1, vl_offset, vr_dim1,
vr_offset, i__1, i__2, i__3, i__4;
doublereal d__1, d__2, d__3, d__4;
doublecomplex z__1;
/* Builtin functions */
double sqrt(doublereal), d_imag(doublecomplex *);
/* Local variables */
integer jc, in, jr, ihi, ilo;
doublereal eps;
logical ilv;
doublereal anrm, bnrm;
integer ierr, itau;
doublereal temp;
logical ilvl, ilvr;
integer iwrk;
extern logical lsame_(char *, char *);
integer ileft, icols, irwrk, irows;
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *);
extern doublereal dlamch_(char *);
extern /* Subroutine */ int zggbak_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublecomplex *,
integer *, integer *), zggbal_(char *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
, integer *, doublereal *, doublereal *, doublereal *, integer *);
logical ilascl, ilbscl;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
logical ldumma[1];
char chtemp[1];
doublereal bignum;
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *,
integer *, doublereal *);
integer ijobvl, iright;
extern /* Subroutine */ int zgghrd_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
), zlascl_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, integer *, doublecomplex *,
integer *, integer *);
integer ijobvr;
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
);
doublereal anrmto;
integer lwkmin;
doublereal bnrmto;
extern /* Subroutine */ int zlacpy_(char *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *),
zlaset_(char *, integer *, integer *, doublecomplex *,
doublecomplex *, doublecomplex *, integer *), ztgevc_(
char *, char *, logical *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, integer *, integer *, doublecomplex *,
doublereal *, integer *), zhgeqz_(char *, char *,
char *, integer *, integer *, integer *, doublecomplex *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, doublecomplex *, integer *, doublecomplex *,
integer *, doublecomplex *, integer *, doublereal *, integer *);
doublereal smlnum;
integer lwkopt;
logical lquery;
extern /* Subroutine */ int zungqr_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *), zunmqr_(char *, char *, integer *, integer
*, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
/* -- LAPACK driver routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZGGEV computes for a pair of N-by-N complex nonsymmetric matrices */
/* (A,B), the generalized eigenvalues, and optionally, the left and/or */
/* right generalized eigenvectors. */
/* A generalized eigenvalue for a pair of matrices (A,B) is a scalar */
/* lambda or a ratio alpha/beta = lambda, such that A - lambda*B is */
/* singular. It is usually represented as the pair (alpha,beta), as */
/* there is a reasonable interpretation for beta=0, and even for both */
/* being zero. */
/* The right generalized eigenvector v(j) corresponding to the */
/* generalized eigenvalue lambda(j) of (A,B) satisfies */
/* A * v(j) = lambda(j) * B * v(j). */
/* The left generalized eigenvector u(j) corresponding to the */
/* generalized eigenvalues lambda(j) of (A,B) satisfies */
/* u(j)**H * A = lambda(j) * u(j)**H * B */
/* where u(j)**H is the conjugate-transpose of u(j). */
/* Arguments */
/* ========= */
/* JOBVL (input) CHARACTER*1 */
/* = 'N': do not compute the left generalized eigenvectors; */
/* = 'V': compute the left generalized eigenvectors. */
/* JOBVR (input) CHARACTER*1 */
/* = 'N': do not compute the right generalized eigenvectors; */
/* = 'V': compute the right generalized eigenvectors. */
/* N (input) INTEGER */
/* The order of the matrices A, B, VL, and VR. N >= 0. */
/* A (input/output) COMPLEX*16 array, dimension (LDA, N) */
/* On entry, the matrix A in the pair (A,B). */
/* On exit, A has been overwritten. */
/* LDA (input) INTEGER */
/* The leading dimension of A. LDA >= max(1,N). */
/* B (input/output) COMPLEX*16 array, dimension (LDB, N) */
/* On entry, the matrix B in the pair (A,B). */
/* On exit, B has been overwritten. */
/* LDB (input) INTEGER */
/* The leading dimension of B. LDB >= max(1,N). */
/* ALPHA (output) COMPLEX*16 array, dimension (N) */
/* BETA (output) COMPLEX*16 array, dimension (N) */
/* On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the */
/* generalized eigenvalues. */
/* Note: the quotients ALPHA(j)/BETA(j) may easily over- or */
/* underflow, and BETA(j) may even be zero. Thus, the user */
/* should avoid naively computing the ratio alpha/beta. */
/* However, ALPHA will be always less than and usually */
/* comparable with norm(A) in magnitude, and BETA always less */
/* than and usually comparable with norm(B). */
/* VL (output) COMPLEX*16 array, dimension (LDVL,N) */
/* If JOBVL = 'V', the left generalized eigenvectors u(j) are */
/* stored one after another in the columns of VL, in the same */
/* order as their eigenvalues. */
/* Each eigenvector is scaled so the largest component has */
/* abs(real part) + abs(imag. part) = 1. */
/* Not referenced if JOBVL = 'N'. */
/* LDVL (input) INTEGER */
/* The leading dimension of the matrix VL. LDVL >= 1, and */
/* if JOBVL = 'V', LDVL >= N. */
/* VR (output) COMPLEX*16 array, dimension (LDVR,N) */
/* If JOBVR = 'V', the right generalized eigenvectors v(j) are */
/* stored one after another in the columns of VR, in the same */
/* order as their eigenvalues. */
/* Each eigenvector is scaled so the largest component has */
/* abs(real part) + abs(imag. part) = 1. */
/* Not referenced if JOBVR = 'N'. */
/* LDVR (input) INTEGER */
/* The leading dimension of the matrix VR. LDVR >= 1, and */
/* if JOBVR = 'V', LDVR >= N. */
/* WORK (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= max(1,2*N). */
/* For good performance, LWORK must generally be larger. */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the WORK array, returns */
/* this value as the first entry of the WORK array, and no error */
/* message related to LWORK is issued by XERBLA. */
/* RWORK (workspace/output) DOUBLE PRECISION array, dimension (8*N) */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* =1,...,N: */
/* The QZ iteration failed. No eigenvectors have been */
/* calculated, but ALPHA(j) and BETA(j) should be */
/* correct for j=INFO+1,...,N. */
/* > N: =N+1: other then QZ iteration failed in DHGEQZ, */
/* =N+2: error return from DTGEVC. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Statement Functions .. */
/* .. */
/* .. Statement Function definitions .. */
/* .. */
/* .. Executable Statements .. */
/* Decode the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
--alpha;
--beta;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1;
vr -= vr_offset;
--work;
--rwork;
/* Function Body */
if (lsame_(jobvl, "N")) {
ijobvl = 1;
ilvl = FALSE_;
} else if (lsame_(jobvl, "V")) {
ijobvl = 2;
ilvl = TRUE_;
} else {
ijobvl = -1;
ilvl = FALSE_;
}
if (lsame_(jobvr, "N")) {
ijobvr = 1;
ilvr = FALSE_;
} else if (lsame_(jobvr, "V")) {
ijobvr = 2;
ilvr = TRUE_;
} else {
ijobvr = -1;
ilvr = FALSE_;
}
ilv = ilvl || ilvr;
/* Test the input arguments */
*info = 0;
lquery = *lwork == -1;
if (ijobvl <= 0) {
*info = -1;
} else if (ijobvr <= 0) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*lda < max(1,*n)) {
*info = -5;
} else if (*ldb < max(1,*n)) {
*info = -7;
} else if (*ldvl < 1 || ilvl && *ldvl < *n) {
*info = -11;
} else if (*ldvr < 1 || ilvr && *ldvr < *n) {
*info = -13;
}
/* 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. The workspace is */
/* computed assuming ILO = 1 and IHI = N, the worst case.) */
if (*info == 0) {
/* Computing MAX */
i__1 = 1, i__2 = *n << 1;
lwkmin = max(i__1,i__2);
/* Computing MAX */
i__1 = 1, i__2 = *n + *n * ilaenv_(&c__1, "ZGEQRF", " ", n, &c__1, n,
&c__0);
lwkopt = max(i__1,i__2);
/* Computing MAX */
i__1 = lwkopt, i__2 = *n + *n * ilaenv_(&c__1, "ZUNMQR", " ", n, &
c__1, n, &c__0);
lwkopt = max(i__1,i__2);
if (ilvl) {
/* Computing MAX */
i__1 = lwkopt, i__2 = *n + *n * ilaenv_(&c__1, "ZUNGQR", " ", n, &
c__1, n, &c_n1);
lwkopt = max(i__1,i__2);
}
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
if (*lwork < lwkmin && ! lquery) {
*info = -15;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGGEV ", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Get machine constants */
eps = dlamch_("E") * dlamch_("B");
smlnum = dlamch_("S");
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
smlnum = sqrt(smlnum) / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", n, n, &a[a_offset], lda, &rwork[1]);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE_;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, &
ierr);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = zlange_("M", n, n, &b[b_offset], ldb, &rwork[1]);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE_;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, &
ierr);
}
/* Permute the matrices A, B to isolate eigenvalues if possible */
/* (Real Workspace: need 6*N) */
ileft = 1;
iright = *n + 1;
irwrk = iright + *n;
zggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &rwork[
ileft], &rwork[iright], &rwork[irwrk], &ierr);
/* Reduce B to triangular form (QR decomposition of B) */
/* (Complex Workspace: need N, prefer N*NB) */
irows = ihi + 1 - ilo;
if (ilv) {
icols = *n + 1 - ilo;
} else {
icols = irows;
}
itau = 1;
iwrk = itau + irows;
i__1 = *lwork + 1 - iwrk;
zgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[
iwrk], &i__1, &ierr);
/* Apply the orthogonal transformation to matrix A */
/* (Complex Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
zunmqr_("L", "C", &irows, &icols, &irows, &b[ilo + ilo * b_dim1], ldb, &
work[itau], &a[ilo + ilo * a_dim1], lda, &work[iwrk], &i__1, &
ierr);
/* Initialize VL */
/* (Complex Workspace: need N, prefer N*NB) */
if (ilvl) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vl[vl_offset], ldvl);
if (irows > 1) {
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vl[
ilo + 1 + ilo * vl_dim1], ldvl);
}
i__1 = *lwork + 1 - iwrk;
zungqr_(&irows, &irows, &irows, &vl[ilo + ilo * vl_dim1], ldvl, &work[
itau], &work[iwrk], &i__1, &ierr);
}
/* Initialize VR */
if (ilvr) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vr[vr_offset], ldvr);
}
/* Reduce to generalized Hessenberg form */
if (ilv) {
/* Eigenvectors requested -- work on whole matrix. */
zgghrd_(jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, &ierr);
} else {
zgghrd_("N", "N", &irows, &c__1, &irows, &a[ilo + ilo * a_dim1], lda,
&b[ilo + ilo * b_dim1], ldb, &vl[vl_offset], ldvl, &vr[
vr_offset], ldvr, &ierr);
}
/* Perform QZ algorithm (Compute eigenvalues, and optionally, the */
/* Schur form and Schur vectors) */
/* (Complex Workspace: need N) */
/* (Real Workspace: need N) */
iwrk = itau;
if (ilv) {
*(unsigned char *)chtemp = 'S';
} else {
*(unsigned char *)chtemp = 'E';
}
i__1 = *lwork + 1 - iwrk;
zhgeqz_(chtemp, jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alpha[1], &beta[1], &vl[vl_offset], ldvl, &vr[
vr_offset], ldvr, &work[iwrk], &i__1, &rwork[irwrk], &ierr);
if (ierr != 0) {
if (ierr > 0 && ierr <= *n) {
*info = ierr;
} else if (ierr > *n && ierr <= *n << 1) {
*info = ierr - *n;
} else {
*info = *n + 1;
}
goto L70;
}
/* Compute Eigenvectors */
/* (Real Workspace: need 2*N) */
/* (Complex Workspace: need 2*N) */
if (ilv) {
if (ilvl) {
if (ilvr) {
*(unsigned char *)chtemp = 'B';
} else {
*(unsigned char *)chtemp = 'L';
}
} else {
*(unsigned char *)chtemp = 'R';
}
ztgevc_(chtemp, "B", ldumma, n, &a[a_offset], lda, &b[b_offset], ldb,
&vl[vl_offset], ldvl, &vr[vr_offset], ldvr, n, &in, &work[
iwrk], &rwork[irwrk], &ierr);
if (ierr != 0) {
*info = *n + 2;
goto L70;
}
/* Undo balancing on VL and VR and normalization */
/* (Workspace: none needed) */
if (ilvl) {
zggbak_("P", "L", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n,
&vl[vl_offset], ldvl, &ierr);
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
temp = 0.;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
i__3 = jr + jc * vl_dim1;
d__3 = temp, d__4 = (d__1 = vl[i__3].r, abs(d__1)) + (
d__2 = d_imag(&vl[jr + jc * vl_dim1]), abs(d__2));
temp = max(d__3,d__4);
/* L10: */
}
if (temp < smlnum) {
goto L30;
}
temp = 1. / temp;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
i__3 = jr + jc * vl_dim1;
i__4 = jr + jc * vl_dim1;
z__1.r = temp * vl[i__4].r, z__1.i = temp * vl[i__4].i;
vl[i__3].r = z__1.r, vl[i__3].i = z__1.i;
/* L20: */
}
L30:
;
}
}
if (ilvr) {
zggbak_("P", "R", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n,
&vr[vr_offset], ldvr, &ierr);
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
temp = 0.;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
i__3 = jr + jc * vr_dim1;
d__3 = temp, d__4 = (d__1 = vr[i__3].r, abs(d__1)) + (
d__2 = d_imag(&vr[jr + jc * vr_dim1]), abs(d__2));
temp = max(d__3,d__4);
/* L40: */
}
if (temp < smlnum) {
goto L60;
}
temp = 1. / temp;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
i__3 = jr + jc * vr_dim1;
i__4 = jr + jc * vr_dim1;
z__1.r = temp * vr[i__4].r, z__1.i = temp * vr[i__4].i;
vr[i__3].r = z__1.r, vr[i__3].i = z__1.i;
/* L50: */
}
L60:
;
}
}
}
/* Undo scaling if necessary */
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alpha[1], n, &
ierr);
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, &
ierr);
}
L70:
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
return 0;
/* End of ZGGEV */
} /* zggev_ */
/* Subroutine */ int zgegs_(char *jobvsl, char *jobvsr, integer *n,
doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb,
doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl,
integer *ldvsl, doublecomplex *vsr, integer *ldvsr, doublecomplex *
work, integer *lwork, doublereal *rwork, 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
=======
DGEGS computes for a pair of N-by-N complex nonsymmetric matrices A,
B: the generalized eigenvalues (alpha, beta), the complex Schur
form (A, B), and optionally left and/or right Schur vectors
(VSL and VSR).
(If only the generalized eigenvalues are needed, use the driver ZGEGV
instead.)
A generalized eigenvalue for a pair of matrices (A,B) is, roughly
speaking, a scalar w or a ratio alpha/beta = w, such that A - w*B
is singular. It is usually represented as the pair (alpha,beta),
as there is a reasonable interpretation for beta=0, and even for
both being zero. A good beginning reference is the book, "VISMatrix
Computations", by G. Golub & C. van Loan (Johns Hopkins U. Press)
The (generalized) Schur form of a pair of matrices is the result of
multiplying both matrices on the left by one unitary matrix and
both on the right by another unitary matrix, these two unitary
matrices being chosen so as to bring the pair of matrices into
upper triangular form with the diagonal elements of B being
non-negative real numbers (this is also called complex Schur form.)
The left and right Schur vectors are the columns of VSL and VSR,
respectively, where VSL and VSR are the unitary matrices
which reduce A and B to Schur form:
Schur form of (A,B) = ( (VSL)**H A (VSR), (VSL)**H B (VSR) )
Arguments
=========
JOBVSL (input) CHARACTER*1
= 'N': do not compute the left Schur vectors;
= 'V': compute the left Schur vectors.
JOBVSR (input) CHARACTER*1
= 'N': do not compute the right Schur vectors;
= 'V': compute the right Schur vectors.
N (input) INTEGER
The order of the matrices A, B, VSL, and VSR. N >= 0.
A (input/output) COMPLEX*16 array, dimension (LDA, N)
On entry, the first of the pair of matrices whose generalized
eigenvalues and (optionally) Schur vectors are to be
computed.
On exit, the generalized Schur form of A.
LDA (input) INTEGER
The leading dimension of A. LDA >= max(1,N).
B (input/output) COMPLEX*16 array, dimension (LDB, N)
On entry, the second of the pair of matrices whose
generalized eigenvalues and (optionally) Schur vectors are
to be computed.
On exit, the generalized Schur form of B.
LDB (input) INTEGER
The leading dimension of B. LDB >= max(1,N).
ALPHA (output) COMPLEX*16 array, dimension (N)
BETA (output) COMPLEX*16 array, dimension (N)
On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the
generalized eigenvalues. ALPHA(j), j=1,...,N and BETA(j),
j=1,...,N are the diagonals of the complex Schur form (A,B)
output by ZGEGS. The BETA(j) will be non-negative real.
Note: the quotients ALPHA(j)/BETA(j) may easily over- or
underflow, and BETA(j) may even be zero. Thus, the user
should avoid naively computing the ratio alpha/beta.
However, ALPHA will be always less than and usually
comparable with norm(A) in magnitude, and BETA always less
than and usually comparable with norm(B).
VSL (output) COMPLEX*16 array, dimension (LDVSL,N)
If JOBVSL = 'V', VSL will contain the left Schur vectors.
(See "Purpose", above.)
Not referenced if JOBVSL = 'N'.
LDVSL (input) INTEGER
The leading dimension of the matrix VSL. LDVSL >= 1, and
if JOBVSL = 'V', LDVSL >= N.
VSR (output) COMPLEX*16 array, dimension (LDVSR,N)
If JOBVSR = 'V', VSR will contain the right Schur vectors.
(See "Purpose", above.)
Not referenced if JOBVSR = 'N'.
LDVSR (input) INTEGER
The leading dimension of the matrix VSR. LDVSR >= 1, and
if JOBVSR = 'V', LDVSR >= N.
WORK (workspace/output) COMPLEX*16 array, dimension (LWORK)
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK. LWORK >= max(1,2*N).
For good performance, LWORK must generally be larger.
To compute the optimal value of LWORK, call ILAENV to get
blocksizes (for ZGEQRF, ZUNMQR, and CUNGQR.) Then compute:
NB -- MAX of the blocksizes for ZGEQRF, ZUNMQR, and CUNGQR;
the optimal LWORK is N*(NB+1).
RWORK (workspace) DOUBLE PRECISION array, dimension (3*N)
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value.
=1,...,N:
The QZ iteration failed. (A,B) are not in Schur
form, but ALPHA(j) and BETA(j) should be correct for
j=INFO+1,...,N.
> N: errors that usually indicate LAPACK problems:
=N+1: error return from ZGGBAL
=N+2: error return from ZGEQRF
=N+3: error return from ZUNMQR
=N+4: error return from ZUNGQR
=N+5: error return from ZGGHRD
=N+6: error return from ZHGEQZ (other than failed
iteration)
=N+7: error return from ZGGBAK (computing VSL)
=N+8: error return from ZGGBAK (computing VSR)
=N+9: error return from ZLASCL (various places)
=====================================================================
Decode the input arguments
Parameter adjustments
Function Body */
/* Table of constant values */
static doublecomplex c_b1 = {0.,0.};
static doublecomplex c_b2 = {1.,0.};
static integer c_n1 = -1;
static integer c__1 = 1;
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vsl_dim1, vsl_offset,
vsr_dim1, vsr_offset, i__1, i__2, i__3;
/* Local variables */
static doublereal anrm, bnrm;
static integer itau;
extern logical lsame_(char *, char *);
static integer ileft, iinfo, icols;
static logical ilvsl;
static integer iwork;
static logical ilvsr;
static integer irows;
extern doublereal dlamch_(char *);
extern /* Subroutine */ int zggbak_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublecomplex *,
integer *, integer *), zggbal_(char *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
, integer *, doublereal *, doublereal *, doublereal *, integer *);
static logical ilascl, ilbscl;
static doublereal safmin;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *,
integer *, doublereal *);
static doublereal bignum;
static integer ijobvl, iright;
extern /* Subroutine */ int zgghrd_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
), zlascl_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, integer *, doublecomplex *,
integer *, integer *);
static integer ijobvr;
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
);
static doublereal anrmto;
static integer lwkmin;
static doublereal bnrmto;
extern /* Subroutine */ int zlacpy_(char *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *),
zlaset_(char *, integer *, integer *, doublecomplex *,
doublecomplex *, doublecomplex *, integer *), zhgeqz_(
char *, char *, char *, integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *,
doublereal *, integer *);
static doublereal smlnum;
static integer irwork, lwkopt;
extern /* Subroutine */ int zungqr_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *), zunmqr_(char *, char *, integer *, integer
*, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
static integer ihi, ilo;
static doublereal eps;
#define ALPHA(I) alpha[(I)-1]
#define BETA(I) beta[(I)-1]
#define WORK(I) work[(I)-1]
#define RWORK(I) rwork[(I)-1]
#define A(I,J) a[(I)-1 + ((J)-1)* ( *lda)]
#define B(I,J) b[(I)-1 + ((J)-1)* ( *ldb)]
#define VSL(I,J) vsl[(I)-1 + ((J)-1)* ( *ldvsl)]
#define VSR(I,J) vsr[(I)-1 + ((J)-1)* ( *ldvsr)]
if (lsame_(jobvsl, "N")) {
ijobvl = 1;
ilvsl = FALSE_;
} else if (lsame_(jobvsl, "V")) {
ijobvl = 2;
ilvsl = TRUE_;
} else {
ijobvl = -1;
ilvsl = FALSE_;
}
if (lsame_(jobvsr, "N")) {
ijobvr = 1;
ilvsr = FALSE_;
} else if (lsame_(jobvsr, "V")) {
ijobvr = 2;
ilvsr = TRUE_;
} else {
ijobvr = -1;
ilvsr = FALSE_;
}
/* Test the input arguments
Computing MAX */
i__1 = *n << 1;
lwkmin = max(i__1,1);
lwkopt = lwkmin;
*info = 0;
if (ijobvl <= 0) {
*info = -1;
} else if (ijobvr <= 0) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*lda < max(1,*n)) {
*info = -5;
} else if (*ldb < max(1,*n)) {
*info = -7;
} else if (*ldvsl < 1 || ilvsl && *ldvsl < *n) {
*info = -11;
} else if (*ldvsr < 1 || ilvsr && *ldvsr < *n) {
*info = -13;
} else if (*lwork < lwkmin) {
*info = -15;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGEGS ", &i__1);
return 0;
}
/* Quick return if possible */
WORK(1).r = (doublereal) lwkopt, WORK(1).i = 0.;
if (*n == 0) {
return 0;
}
/* Get machine constants */
eps = dlamch_("E") * dlamch_("B");
safmin = dlamch_("S");
smlnum = *n * safmin / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", n, n, &A(1,1), lda, &RWORK(1));
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE_;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl) {
zlascl_("G", &c_n1, &c_n1, &anrm, &anrmto, n, n, &A(1,1), lda, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = zlange_("M", n, n, &B(1,1), ldb, &RWORK(1));
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE_;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl) {
zlascl_("G", &c_n1, &c_n1, &bnrm, &bnrmto, n, n, &B(1,1), ldb, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
}
/* Permute the matrix to make it more nearly triangular */
ileft = 1;
iright = *n + 1;
irwork = iright + *n;
iwork = 1;
zggbal_("P", n, &A(1,1), lda, &B(1,1), ldb, &ilo, &ihi, &RWORK(
ileft), &RWORK(iright), &RWORK(irwork), &iinfo);
if (iinfo != 0) {
*info = *n + 1;
goto L10;
}
/* Reduce B to triangular form, and initialize VSL and/or VSR */
irows = ihi + 1 - ilo;
icols = *n + 1 - ilo;
itau = iwork;
iwork = itau + irows;
i__1 = *lwork + 1 - iwork;
zgeqrf_(&irows, &icols, &B(ilo,ilo), ldb, &WORK(itau), &WORK(
iwork), &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__3 = iwork;
i__1 = lwkopt, i__2 = (integer) WORK(iwork).r + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 2;
goto L10;
}
i__1 = *lwork + 1 - iwork;
zunmqr_("L", "C", &irows, &icols, &irows, &B(ilo,ilo), ldb, &
WORK(itau), &A(ilo,ilo), lda, &WORK(iwork), &i__1, &
iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__3 = iwork;
i__1 = lwkopt, i__2 = (integer) WORK(iwork).r + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 3;
goto L10;
}
if (ilvsl) {
zlaset_("Full", n, n, &c_b1, &c_b2, &VSL(1,1), ldvsl);
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &B(ilo+1,ilo), ldb, &VSL(ilo+1,ilo), ldvsl);
i__1 = *lwork + 1 - iwork;
zungqr_(&irows, &irows, &irows, &VSL(ilo,ilo), ldvsl, &
WORK(itau), &WORK(iwork), &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__3 = iwork;
i__1 = lwkopt, i__2 = (integer) WORK(iwork).r + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 4;
goto L10;
}
}
if (ilvsr) {
zlaset_("Full", n, n, &c_b1, &c_b2, &VSR(1,1), ldvsr);
}
/* Reduce to generalized Hessenberg form */
zgghrd_(jobvsl, jobvsr, n, &ilo, &ihi, &A(1,1), lda, &B(1,1),
ldb, &VSL(1,1), ldvsl, &VSR(1,1), ldvsr, &iinfo);
if (iinfo != 0) {
*info = *n + 5;
goto L10;
}
/* Perform QZ algorithm, computing Schur vectors if desired */
iwork = itau;
i__1 = *lwork + 1 - iwork;
zhgeqz_("S", jobvsl, jobvsr, n, &ilo, &ihi, &A(1,1), lda, &B(1,1), ldb, &ALPHA(1), &BETA(1), &VSL(1,1), ldvsl, &
VSR(1,1), ldvsr, &WORK(iwork), &i__1, &RWORK(irwork), &
iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__3 = iwork;
i__1 = lwkopt, i__2 = (integer) WORK(iwork).r + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
if (iinfo > 0 && iinfo <= *n) {
*info = iinfo;
} else if (iinfo > *n && iinfo <= *n << 1) {
*info = iinfo - *n;
} else {
*info = *n + 6;
}
goto L10;
}
/* Apply permutation to VSL and VSR */
if (ilvsl) {
zggbak_("P", "L", n, &ilo, &ihi, &RWORK(ileft), &RWORK(iright), n, &
VSL(1,1), ldvsl, &iinfo);
if (iinfo != 0) {
*info = *n + 7;
goto L10;
}
}
if (ilvsr) {
zggbak_("P", "R", n, &ilo, &ihi, &RWORK(ileft), &RWORK(iright), n, &
VSR(1,1), ldvsr, &iinfo);
if (iinfo != 0) {
*info = *n + 8;
goto L10;
}
}
/* Undo scaling */
if (ilascl) {
zlascl_("U", &c_n1, &c_n1, &anrmto, &anrm, n, n, &A(1,1), lda, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
zlascl_("G", &c_n1, &c_n1, &anrmto, &anrm, n, &c__1, &ALPHA(1), n, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
}
if (ilbscl) {
zlascl_("U", &c_n1, &c_n1, &bnrmto, &bnrm, n, n, &B(1,1), ldb, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
zlascl_("G", &c_n1, &c_n1, &bnrmto, &bnrm, n, &c__1, &BETA(1), n, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
}
L10:
WORK(1).r = (doublereal) lwkopt, WORK(1).i = 0.;
return 0;
/* End of ZGEGS */
} /* zgegs_ */
/* Subroutine */ int zdrvrf3_(integer *nout, integer *nn, integer *nval,
doublereal *thresh, doublecomplex *a, integer *lda, doublecomplex *
arf, doublecomplex *b1, doublecomplex *b2, doublereal *
d_work_zlange__, doublecomplex *z_work_zgeqrf__, doublecomplex *tau)
{
/* Initialized data */
static integer iseedy[4] = { 1988,1989,1990,1991 };
static char uplos[1*2] = "U" "L";
static char forms[1*2] = "N" "C";
static char sides[1*2] = "L" "R";
static char transs[1*2] = "N" "C";
static char diags[1*2] = "N" "U";
/* Format strings */
static char fmt_9999[] = "(1x,\002 *** Error(s) or Failure(s) while test"
"ing ZTFSM ***\002)";
static char fmt_9997[] = "(1x,\002 Failure in \002,a5,\002, CFORM="
"'\002,a1,\002',\002,\002 SIDE='\002,a1,\002',\002,\002 UPLO='"
"\002,a1,\002',\002,\002 TRANS='\002,a1,\002',\002,\002 DIAG='"
"\002,a1,\002',\002,\002 M=\002,i3,\002, N =\002,i3,\002, test"
"=\002,g12.5)";
static char fmt_9996[] = "(1x,\002All tests for \002,a5,\002 auxiliary r"
"outine passed the \002,\002threshold (\002,i5,\002 tests run)"
"\002)";
static char fmt_9995[] = "(1x,a6,\002 auxiliary routine:\002,i5,\002 out"
" of \002,i5,\002 tests failed to pass the threshold\002)";
/* System generated locals */
integer a_dim1, a_offset, b1_dim1, b1_offset, b2_dim1, b2_offset, i__1,
i__2, i__3, i__4, i__5, i__6, i__7;
doublecomplex z__1, z__2;
/* Builtin functions */
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
double sqrt(doublereal);
integer s_wsle(cilist *), e_wsle(void), s_wsfe(cilist *), e_wsfe(void),
do_fio(integer *, char *, ftnlen);
/* Local variables */
integer i__, j, m, n, na, iim, iin;
doublereal eps;
char diag[1], side[1];
integer info;
char uplo[1];
integer nrun, idiag;
doublecomplex alpha;
integer nfail, iseed[4], iside;
char cform[1];
integer iform;
char trans[1];
integer iuplo;
extern /* Subroutine */ int ztfsm_(char *, char *, char *, char *, char *,
integer *, integer *, doublecomplex *, doublecomplex *,
doublecomplex *, integer *), ztrsm_(char *, char *, char *, char *, integer *,
integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *);
extern doublereal dlamch_(char *);
integer ialpha;
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *,
integer *, doublereal *);
extern /* Subroutine */ int zgelqf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
);
extern /* Double Complex */ VOID zlarnd_(doublecomplex *, integer *,
integer *);
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
);
integer itrans;
doublereal result[1];
extern /* Subroutine */ int ztrttf_(char *, char *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *);
/* Fortran I/O blocks */
static cilist io___32 = { 0, 0, 0, 0, 0 };
static cilist io___33 = { 0, 0, 0, fmt_9999, 0 };
static cilist io___34 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___35 = { 0, 0, 0, fmt_9996, 0 };
static cilist io___36 = { 0, 0, 0, fmt_9995, 0 };
/* -- LAPACK test routine (version 3.2.0) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2008 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZDRVRF3 tests the LAPACK RFP routines: */
/* ZTFSM */
/* Arguments */
/* ========= */
/* NOUT (input) INTEGER */
/* The unit number for output. */
/* NN (input) INTEGER */
/* The number of values of N contained in the vector NVAL. */
/* NVAL (input) INTEGER array, dimension (NN) */
/* The values of the matrix dimension N. */
/* THRESH (input) DOUBLE PRECISION */
/* 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. */
/* A (workspace) COMPLEX*16 array, dimension (LDA,NMAX) */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= max(1,NMAX). */
/* ARF (workspace) COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2). */
/* B1 (workspace) COMPLEX*16 array, dimension (LDA,NMAX) */
/* B2 (workspace) COMPLEX*16 array, dimension (LDA,NMAX) */
/* D_WORK_ZLANGE (workspace) DOUBLE PRECISION array, dimension (NMAX) */
/* Z_WORK_ZGEQRF (workspace) COMPLEX*16 array, dimension (NMAX) */
/* TAU (workspace) COMPLEX*16 array, dimension (NMAX) */
/* ===================================================================== */
/* .. */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Scalars in Common .. */
/* .. */
/* .. Common blocks .. */
/* .. */
/* .. Data statements .. */
/* Parameter adjustments */
--nval;
b2_dim1 = *lda;
b2_offset = 1 + b2_dim1;
b2 -= b2_offset;
b1_dim1 = *lda;
b1_offset = 1 + b1_dim1;
b1 -= b1_offset;
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--arf;
--d_work_zlange__;
--z_work_zgeqrf__;
--tau;
/* Function Body */
/* .. */
/* .. Executable Statements .. */
/* Initialize constants and the random number seed. */
nrun = 0;
nfail = 0;
info = 0;
for (i__ = 1; i__ <= 4; ++i__) {
iseed[i__ - 1] = iseedy[i__ - 1];
/* L10: */
}
eps = dlamch_("Precision");
i__1 = *nn;
for (iim = 1; iim <= i__1; ++iim) {
m = nval[iim];
i__2 = *nn;
for (iin = 1; iin <= i__2; ++iin) {
n = nval[iin];
for (iform = 1; iform <= 2; ++iform) {
*(unsigned char *)cform = *(unsigned char *)&forms[iform - 1];
for (iuplo = 1; iuplo <= 2; ++iuplo) {
*(unsigned char *)uplo = *(unsigned char *)&uplos[iuplo -
1];
for (iside = 1; iside <= 2; ++iside) {
*(unsigned char *)side = *(unsigned char *)&sides[
iside - 1];
for (itrans = 1; itrans <= 2; ++itrans) {
*(unsigned char *)trans = *(unsigned char *)&
transs[itrans - 1];
for (idiag = 1; idiag <= 2; ++idiag) {
*(unsigned char *)diag = *(unsigned char *)&
diags[idiag - 1];
for (ialpha = 1; ialpha <= 3; ++ialpha) {
if (ialpha == 1) {
alpha.r = 0., alpha.i = 0.;
} else if (ialpha == 1) {
alpha.r = 1., alpha.i = 0.;
} else {
zlarnd_(&z__1, &c__4, iseed);
alpha.r = z__1.r, alpha.i = z__1.i;
}
/* All the parameters are set: */
/* CFORM, SIDE, UPLO, TRANS, DIAG, M, N, */
/* and ALPHA */
/* READY TO TEST! */
++nrun;
if (iside == 1) {
/* The case ISIDE.EQ.1 is when SIDE.EQ.'L' */
/* -> A is M-by-M ( B is M-by-N ) */
na = m;
} else {
/* The case ISIDE.EQ.2 is when SIDE.EQ.'R' */
/* -> A is N-by-N ( B is M-by-N ) */
na = n;
}
/* Generate A our NA--by--NA triangular */
/* matrix. */
/* Our test is based on forward error so we */
/* do want A to be well conditionned! To get */
/* a well-conditionned triangular matrix, we */
/* take the R factor of the QR/LQ factorization */
/* of a random matrix. */
i__3 = na;
for (j = 1; j <= i__3; ++j) {
i__4 = na;
for (i__ = 1; i__ <= i__4; ++i__) {
i__5 = i__ + j * a_dim1;
zlarnd_(&z__1, &c__4, iseed);
a[i__5].r = z__1.r, a[i__5].i =
z__1.i;
}
}
if (iuplo == 1) {
/* The case IUPLO.EQ.1 is when SIDE.EQ.'U' */
/* -> QR factorization. */
s_copy(srnamc_1.srnamt, "ZGEQRF", (
ftnlen)32, (ftnlen)6);
zgeqrf_(&na, &na, &a[a_offset], lda, &
tau[1], &z_work_zgeqrf__[1],
lda, &info);
} else {
/* The case IUPLO.EQ.2 is when SIDE.EQ.'L' */
/* -> QL factorization. */
s_copy(srnamc_1.srnamt, "ZGELQF", (
ftnlen)32, (ftnlen)6);
zgelqf_(&na, &na, &a[a_offset], lda, &
tau[1], &z_work_zgeqrf__[1],
lda, &info);
}
/* After the QR factorization, the diagonal */
/* of A is made of real numbers, we multiply */
/* by a random complex number of absolute */
/* value 1.0E+00. */
i__3 = na;
for (j = 1; j <= i__3; ++j) {
i__4 = j + j * a_dim1;
i__5 = j + j * a_dim1;
zlarnd_(&z__2, &c__5, iseed);
z__1.r = a[i__5].r * z__2.r - a[i__5]
.i * z__2.i, z__1.i = a[i__5]
.r * z__2.i + a[i__5].i *
z__2.r;
a[i__4].r = z__1.r, a[i__4].i =
z__1.i;
}
/* Store a copy of A in RFP format (in ARF). */
s_copy(srnamc_1.srnamt, "ZTRTTF", (ftnlen)
32, (ftnlen)6);
ztrttf_(cform, uplo, &na, &a[a_offset],
lda, &arf[1], &info);
/* Generate B1 our M--by--N right-hand side */
/* and store a copy in B2. */
i__3 = n;
for (j = 1; j <= i__3; ++j) {
i__4 = m;
for (i__ = 1; i__ <= i__4; ++i__) {
i__5 = i__ + j * b1_dim1;
zlarnd_(&z__1, &c__4, iseed);
b1[i__5].r = z__1.r, b1[i__5].i =
z__1.i;
i__5 = i__ + j * b2_dim1;
i__6 = i__ + j * b1_dim1;
b2[i__5].r = b1[i__6].r, b2[i__5]
.i = b1[i__6].i;
}
}
/* Solve op( A ) X = B or X op( A ) = B */
/* with ZTRSM */
s_copy(srnamc_1.srnamt, "ZTRSM", (ftnlen)
32, (ftnlen)5);
ztrsm_(side, uplo, trans, diag, &m, &n, &
alpha, &a[a_offset], lda, &b1[
b1_offset], lda);
/* Solve op( A ) X = B or X op( A ) = B */
/* with ZTFSM */
s_copy(srnamc_1.srnamt, "ZTFSM", (ftnlen)
32, (ftnlen)5);
ztfsm_(cform, side, uplo, trans, diag, &m,
&n, &alpha, &arf[1], &b2[
b2_offset], lda);
/* Check that the result agrees. */
i__3 = n;
for (j = 1; j <= i__3; ++j) {
i__4 = m;
for (i__ = 1; i__ <= i__4; ++i__) {
i__5 = i__ + j * b1_dim1;
i__6 = i__ + j * b2_dim1;
i__7 = i__ + j * b1_dim1;
z__1.r = b2[i__6].r - b1[i__7].r,
z__1.i = b2[i__6].i - b1[
i__7].i;
b1[i__5].r = z__1.r, b1[i__5].i =
z__1.i;
}
}
result[0] = zlange_("I", &m, &n, &b1[
b1_offset], lda, &d_work_zlange__[
1]);
/* Computing MAX */
i__3 = max(m,n);
result[0] = result[0] / sqrt(eps) / max(
i__3,1);
if (result[0] >= *thresh) {
if (nfail == 0) {
io___32.ciunit = *nout;
s_wsle(&io___32);
e_wsle();
io___33.ciunit = *nout;
s_wsfe(&io___33);
e_wsfe();
}
io___34.ciunit = *nout;
s_wsfe(&io___34);
do_fio(&c__1, "ZTFSM", (ftnlen)5);
do_fio(&c__1, cform, (ftnlen)1);
do_fio(&c__1, side, (ftnlen)1);
do_fio(&c__1, uplo, (ftnlen)1);
do_fio(&c__1, trans, (ftnlen)1);
do_fio(&c__1, diag, (ftnlen)1);
do_fio(&c__1, (char *)&m, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&n, (ftnlen)
sizeof(integer));
do_fio(&c__1, (char *)&result[0], (
ftnlen)sizeof(doublereal));
e_wsfe();
++nfail;
}
/* L100: */
}
/* L110: */
}
/* L120: */
}
/* L130: */
}
/* L140: */
}
/* L150: */
}
/* L160: */
}
/* L170: */
}
/* Print a summary of the results. */
if (nfail == 0) {
io___35.ciunit = *nout;
s_wsfe(&io___35);
do_fio(&c__1, "ZTFSM", (ftnlen)5);
do_fio(&c__1, (char *)&nrun, (ftnlen)sizeof(integer));
e_wsfe();
} else {
io___36.ciunit = *nout;
s_wsfe(&io___36);
do_fio(&c__1, "ZTFSM", (ftnlen)5);
do_fio(&c__1, (char *)&nfail, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&nrun, (ftnlen)sizeof(integer));
e_wsfe();
}
return 0;
/* End of ZDRVRF3 */
} /* zdrvrf3_ */
/* Subroutine */ int zerrqr_(char *path, integer *nunit)
{
/* System generated locals */
integer i__1;
doublereal d__1, d__2;
doublecomplex z__1;
/* Builtin functions */
integer s_wsle(cilist *), e_wsle(void);
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
/* Local variables */
static integer info;
static doublecomplex a[4] /* was [2][2] */, b[2];
static integer i__, j;
static doublecomplex w[2], x[2], af[4] /* was [2][2] */;
extern /* Subroutine */ int zgeqr2_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *), zung2r_(
integer *, integer *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, integer *), zunm2r_(char *,
char *, integer *, integer *, integer *, doublecomplex *, integer
*, doublecomplex *, doublecomplex *, integer *, doublecomplex *,
integer *), alaesm_(char *, logical *, integer *), chkxer_(char *, integer *, integer *, logical *, logical
*), zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *)
, zgeqrs_(integer *, integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *, integer *), zungqr_(integer *,
integer *, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, integer *), zunmqr_(char *, char *,
integer *, integer *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, integer *, doublecomplex *,
integer *, integer *);
/* Fortran I/O blocks */
static cilist io___1 = { 0, 0, 0, 0, 0 };
#define a_subscr(a_1,a_2) (a_2)*2 + a_1 - 3
#define a_ref(a_1,a_2) a[a_subscr(a_1,a_2)]
#define af_subscr(a_1,a_2) (a_2)*2 + a_1 - 3
#define af_ref(a_1,a_2) af[af_subscr(a_1,a_2)]
/* -- LAPACK test routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
February 29, 1992
Purpose
=======
ZERRQR tests the error exits for the COMPLEX*16 routines
that use the QR decomposition of a general matrix.
Arguments
=========
PATH (input) CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT (input) INTEGER
The unit number for output.
===================================================================== */
infoc_1.nout = *nunit;
io___1.ciunit = infoc_1.nout;
s_wsle(&io___1);
e_wsle();
/* Set the variables to innocuous values. */
for (j = 1; j <= 2; ++j) {
for (i__ = 1; i__ <= 2; ++i__) {
i__1 = a_subscr(i__, j);
d__1 = 1. / (doublereal) (i__ + j);
d__2 = -1. / (doublereal) (i__ + j);
z__1.r = d__1, z__1.i = d__2;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
i__1 = af_subscr(i__, j);
d__1 = 1. / (doublereal) (i__ + j);
d__2 = -1. / (doublereal) (i__ + j);
z__1.r = d__1, z__1.i = d__2;
af[i__1].r = z__1.r, af[i__1].i = z__1.i;
/* L10: */
}
i__1 = j - 1;
b[i__1].r = 0., b[i__1].i = 0.;
i__1 = j - 1;
w[i__1].r = 0., w[i__1].i = 0.;
i__1 = j - 1;
x[i__1].r = 0., x[i__1].i = 0.;
/* L20: */
}
infoc_1.ok = TRUE_;
/* Error exits for QR factorization
ZGEQRF */
s_copy(srnamc_1.srnamt, "ZGEQRF", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
zgeqrf_(&c_n1, &c__0, a, &c__1, b, w, &c__1, &info);
chkxer_("ZGEQRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zgeqrf_(&c__0, &c_n1, a, &c__1, b, w, &c__1, &info);
chkxer_("ZGEQRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
zgeqrf_(&c__2, &c__1, a, &c__1, b, w, &c__1, &info);
chkxer_("ZGEQRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
zgeqrf_(&c__1, &c__2, a, &c__1, b, w, &c__1, &info);
chkxer_("ZGEQRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* ZGEQR2 */
s_copy(srnamc_1.srnamt, "ZGEQR2", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
zgeqr2_(&c_n1, &c__0, a, &c__1, b, w, &info);
chkxer_("ZGEQR2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zgeqr2_(&c__0, &c_n1, a, &c__1, b, w, &info);
chkxer_("ZGEQR2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
zgeqr2_(&c__2, &c__1, a, &c__1, b, w, &info);
chkxer_("ZGEQR2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* ZGEQRS */
s_copy(srnamc_1.srnamt, "ZGEQRS", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
zgeqrs_(&c_n1, &c__0, &c__0, a, &c__1, x, b, &c__1, w, &c__1, &info);
chkxer_("ZGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zgeqrs_(&c__0, &c_n1, &c__0, a, &c__1, x, b, &c__1, w, &c__1, &info);
chkxer_("ZGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zgeqrs_(&c__1, &c__2, &c__0, a, &c__2, x, b, &c__2, w, &c__1, &info);
chkxer_("ZGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
zgeqrs_(&c__0, &c__0, &c_n1, a, &c__1, x, b, &c__1, w, &c__1, &info);
chkxer_("ZGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
zgeqrs_(&c__2, &c__1, &c__0, a, &c__1, x, b, &c__2, w, &c__1, &info);
chkxer_("ZGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 8;
zgeqrs_(&c__2, &c__1, &c__0, a, &c__2, x, b, &c__1, w, &c__1, &info);
chkxer_("ZGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 10;
zgeqrs_(&c__1, &c__1, &c__2, a, &c__1, x, b, &c__1, w, &c__1, &info);
chkxer_("ZGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* ZUNGQR */
s_copy(srnamc_1.srnamt, "ZUNGQR", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
zungqr_(&c_n1, &c__0, &c__0, a, &c__1, x, w, &c__1, &info);
chkxer_("ZUNGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zungqr_(&c__0, &c_n1, &c__0, a, &c__1, x, w, &c__1, &info);
chkxer_("ZUNGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zungqr_(&c__1, &c__2, &c__0, a, &c__1, x, w, &c__2, &info);
chkxer_("ZUNGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
zungqr_(&c__0, &c__0, &c_n1, a, &c__1, x, w, &c__1, &info);
chkxer_("ZUNGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
zungqr_(&c__1, &c__1, &c__2, a, &c__1, x, w, &c__1, &info);
chkxer_("ZUNGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
zungqr_(&c__2, &c__2, &c__0, a, &c__1, x, w, &c__2, &info);
chkxer_("ZUNGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 8;
zungqr_(&c__2, &c__2, &c__0, a, &c__2, x, w, &c__1, &info);
chkxer_("ZUNGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* ZUNG2R */
s_copy(srnamc_1.srnamt, "ZUNG2R", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
zung2r_(&c_n1, &c__0, &c__0, a, &c__1, x, w, &info);
chkxer_("ZUNG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zung2r_(&c__0, &c_n1, &c__0, a, &c__1, x, w, &info);
chkxer_("ZUNG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zung2r_(&c__1, &c__2, &c__0, a, &c__1, x, w, &info);
chkxer_("ZUNG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
zung2r_(&c__0, &c__0, &c_n1, a, &c__1, x, w, &info);
chkxer_("ZUNG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
zung2r_(&c__2, &c__1, &c__2, a, &c__2, x, w, &info);
chkxer_("ZUNG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
zung2r_(&c__2, &c__1, &c__0, a, &c__1, x, w, &info);
chkxer_("ZUNG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* ZUNMQR */
s_copy(srnamc_1.srnamt, "ZUNMQR", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
zunmqr_("/", "N", &c__0, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zunmqr_("L", "/", &c__0, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
zunmqr_("L", "N", &c_n1, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
zunmqr_("L", "N", &c__0, &c_n1, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
zunmqr_("L", "N", &c__0, &c__0, &c_n1, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
zunmqr_("L", "N", &c__0, &c__1, &c__1, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
zunmqr_("R", "N", &c__1, &c__0, &c__1, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
zunmqr_("L", "N", &c__2, &c__1, &c__0, a, &c__1, x, af, &c__2, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
zunmqr_("R", "N", &c__1, &c__2, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 10;
zunmqr_("L", "N", &c__2, &c__1, &c__0, a, &c__2, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 12;
zunmqr_("L", "N", &c__1, &c__2, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 12;
zunmqr_("R", "N", &c__2, &c__1, &c__0, a, &c__1, x, af, &c__2, w, &c__1, &
info);
chkxer_("ZUNMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* ZUNM2R */
s_copy(srnamc_1.srnamt, "ZUNM2R", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
zunm2r_("/", "N", &c__0, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
zunm2r_("L", "/", &c__0, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
zunm2r_("L", "N", &c_n1, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
zunm2r_("L", "N", &c__0, &c_n1, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
zunm2r_("L", "N", &c__0, &c__0, &c_n1, a, &c__1, x, af, &c__1, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
zunm2r_("L", "N", &c__0, &c__1, &c__1, a, &c__1, x, af, &c__1, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
zunm2r_("R", "N", &c__1, &c__0, &c__1, a, &c__1, x, af, &c__1, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
zunm2r_("L", "N", &c__2, &c__1, &c__0, a, &c__1, x, af, &c__2, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
zunm2r_("R", "N", &c__1, &c__2, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 10;
zunm2r_("L", "N", &c__2, &c__1, &c__0, a, &c__2, x, af, &c__1, w, &info);
chkxer_("ZUNM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* Print a summary line. */
alaesm_(path, &infoc_1.ok, &infoc_1.nout);
return 0;
/* End of ZERRQR */
} /* zerrqr_ */
/* Subroutine */ int zgegv_(char *jobvl, char *jobvr, integer *n,
doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb,
doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer
*ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer
*lwork, doublereal *rwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vl_dim1, vl_offset, vr_dim1,
vr_offset, i__1, i__2, i__3, i__4;
doublereal d__1, d__2, d__3, d__4;
doublecomplex z__1, z__2;
/* Builtin functions */
double d_imag(doublecomplex *);
/* Local variables */
integer jc, nb, in, jr, nb1, nb2, nb3, ihi, ilo;
doublereal eps;
logical ilv;
doublereal absb, anrm, bnrm;
integer itau;
doublereal temp;
logical ilvl, ilvr;
integer lopt;
doublereal anrm1, anrm2, bnrm1, bnrm2, absai, scale, absar, sbeta;
extern logical lsame_(char *, char *);
integer ileft, iinfo, icols, iwork, irows;
extern doublereal dlamch_(char *);
doublereal salfai;
extern /* Subroutine */ int zggbak_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublecomplex *,
integer *, integer *), zggbal_(char *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
, integer *, doublereal *, doublereal *, doublereal *, integer *);
doublereal salfar, safmin;
extern /* Subroutine */ int xerbla_(char *, integer *);
doublereal safmax;
char chtemp[1];
logical ldumma[1];
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *,
integer *, doublereal *);
integer ijobvl, iright;
logical ilimit;
extern /* Subroutine */ int zgghrd_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *
), zlascl_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, integer *, doublecomplex *,
integer *, integer *);
integer ijobvr;
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
);
integer lwkmin;
extern /* Subroutine */ int zlacpy_(char *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *),
zlaset_(char *, integer *, integer *, doublecomplex *,
doublecomplex *, doublecomplex *, integer *), ztgevc_(
char *, char *, logical *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, integer *, integer *, doublecomplex *,
doublereal *, integer *), zhgeqz_(char *, char *,
char *, integer *, integer *, integer *, doublecomplex *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, doublecomplex *, integer *, doublecomplex *,
integer *, doublecomplex *, integer *, doublereal *, integer *);
integer irwork, lwkopt;
logical lquery;
extern /* Subroutine */ int zungqr_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *), zunmqr_(char *, char *, integer *, integer
*, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
/* -- LAPACK driver routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* This routine is deprecated and has been replaced by routine ZGGEV. */
/* ZGEGV computes the eigenvalues and, optionally, the left and/or right */
/* eigenvectors of a complex matrix pair (A,B). */
/* Given two square matrices A and B, */
/* the generalized nonsymmetric eigenvalue problem (GNEP) is to find the */
/* eigenvalues lambda and corresponding (non-zero) eigenvectors x such */
/* that */
/* A*x = lambda*B*x. */
/* An alternate form is to find the eigenvalues mu and corresponding */
/* eigenvectors y such that */
/* mu*A*y = B*y. */
/* These two forms are equivalent with mu = 1/lambda and x = y if */
/* neither lambda nor mu is zero. In order to deal with the case that */
/* lambda or mu is zero or small, two values alpha and beta are returned */
/* for each eigenvalue, such that lambda = alpha/beta and */
/* mu = beta/alpha. */
/* The vectors x and y in the above equations are right eigenvectors of */
/* the matrix pair (A,B). Vectors u and v satisfying */
/* u**H*A = lambda*u**H*B or mu*v**H*A = v**H*B */
/* are left eigenvectors of (A,B). */
/* Note: this routine performs "full balancing" on A and B -- see */
/* "Further Details", below. */
/* Arguments */
/* ========= */
/* JOBVL (input) CHARACTER*1 */
/* = 'N': do not compute the left generalized eigenvectors; */
/* = 'V': compute the left generalized eigenvectors (returned */
/* in VL). */
/* JOBVR (input) CHARACTER*1 */
/* = 'N': do not compute the right generalized eigenvectors; */
/* = 'V': compute the right generalized eigenvectors (returned */
/* in VR). */
/* N (input) INTEGER */
/* The order of the matrices A, B, VL, and VR. N >= 0. */
/* A (input/output) COMPLEX*16 array, dimension (LDA, N) */
/* On entry, the matrix A. */
/* If JOBVL = 'V' or JOBVR = 'V', then on exit A */
/* contains the Schur form of A from the generalized Schur */
/* factorization of the pair (A,B) after balancing. If no */
/* eigenvectors were computed, then only the diagonal elements */
/* of the Schur form will be correct. See ZGGHRD and ZHGEQZ */
/* for details. */
/* LDA (input) INTEGER */
/* The leading dimension of A. LDA >= max(1,N). */
/* B (input/output) COMPLEX*16 array, dimension (LDB, N) */
/* On entry, the matrix B. */
/* If JOBVL = 'V' or JOBVR = 'V', then on exit B contains the */
/* upper triangular matrix obtained from B in the generalized */
/* Schur factorization of the pair (A,B) after balancing. */
/* If no eigenvectors were computed, then only the diagonal */
/* elements of B will be correct. See ZGGHRD and ZHGEQZ for */
/* details. */
/* LDB (input) INTEGER */
/* The leading dimension of B. LDB >= max(1,N). */
/* ALPHA (output) COMPLEX*16 array, dimension (N) */
/* The complex scalars alpha that define the eigenvalues of */
/* GNEP. */
/* BETA (output) COMPLEX*16 array, dimension (N) */
/* The complex scalars beta that define the eigenvalues of GNEP. */
/* Together, the quantities alpha = ALPHA(j) and beta = BETA(j) */
/* represent the j-th eigenvalue of the matrix pair (A,B), in */
/* one of the forms lambda = alpha/beta or mu = beta/alpha. */
/* Since either lambda or mu may overflow, they should not, */
/* in general, be computed. */
/* VL (output) COMPLEX*16 array, dimension (LDVL,N) */
/* If JOBVL = 'V', the left eigenvectors u(j) are stored */
/* in the columns of VL, in the same order as their eigenvalues. */
/* Each eigenvector is scaled so that its largest component has */
/* abs(real part) + abs(imag. part) = 1, except for eigenvectors */
/* corresponding to an eigenvalue with alpha = beta = 0, which */
/* are set to zero. */
/* Not referenced if JOBVL = 'N'. */
/* LDVL (input) INTEGER */
/* The leading dimension of the matrix VL. LDVL >= 1, and */
/* if JOBVL = 'V', LDVL >= N. */
/* VR (output) COMPLEX*16 array, dimension (LDVR,N) */
/* If JOBVR = 'V', the right eigenvectors x(j) are stored */
/* in the columns of VR, in the same order as their eigenvalues. */
/* Each eigenvector is scaled so that its largest component has */
/* abs(real part) + abs(imag. part) = 1, except for eigenvectors */
/* corresponding to an eigenvalue with alpha = beta = 0, which */
/* are set to zero. */
/* Not referenced if JOBVR = 'N'. */
/* LDVR (input) INTEGER */
/* The leading dimension of the matrix VR. LDVR >= 1, and */
/* if JOBVR = 'V', LDVR >= N. */
/* WORK (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= max(1,2*N). */
/* For good performance, LWORK must generally be larger. */
/* To compute the optimal value of LWORK, call ILAENV to get */
/* blocksizes (for ZGEQRF, ZUNMQR, and ZUNGQR.) Then compute: */
/* NB -- MAX of the blocksizes for ZGEQRF, ZUNMQR, and ZUNGQR; */
/* The optimal LWORK is MAX( 2*N, N*(NB+1) ). */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the WORK array, returns */
/* this value as the first entry of the WORK array, and no error */
/* message related to LWORK is issued by XERBLA. */
/* RWORK (workspace/output) DOUBLE PRECISION array, dimension (8*N) */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* =1,...,N: */
/* The QZ iteration failed. No eigenvectors have been */
/* calculated, but ALPHA(j) and BETA(j) should be */
/* correct for j=INFO+1,...,N. */
/* > N: errors that usually indicate LAPACK problems: */
/* =N+1: error return from ZGGBAL */
/* =N+2: error return from ZGEQRF */
/* =N+3: error return from ZUNMQR */
/* =N+4: error return from ZUNGQR */
/* =N+5: error return from ZGGHRD */
/* =N+6: error return from ZHGEQZ (other than failed */
/* iteration) */
/* =N+7: error return from ZTGEVC */
/* =N+8: error return from ZGGBAK (computing VL) */
/* =N+9: error return from ZGGBAK (computing VR) */
/* =N+10: error return from ZLASCL (various calls) */
/* Further Details */
/* =============== */
/* Balancing */
/* --------- */
/* This driver calls ZGGBAL to both permute and scale rows and columns */
/* of A and B. The permutations PL and PR are chosen so that PL*A*PR */
/* and PL*B*R will be upper triangular except for the diagonal blocks */
/* A(i:j,i:j) and B(i:j,i:j), with i and j as close together as */
/* possible. The diagonal scaling matrices DL and DR are chosen so */
/* that the pair DL*PL*A*PR*DR, DL*PL*B*PR*DR have elements close to */
/* one (except for the elements that start out zero.) */
/* After the eigenvalues and eigenvectors of the balanced matrices */
/* have been computed, ZGGBAK transforms the eigenvectors back to what */
/* they would have been (in perfect arithmetic) if they had not been */
/* balanced. */
/* Contents of A and B on Exit */
/* -------- -- - --- - -- ---- */
/* If any eigenvectors are computed (either JOBVL='V' or JOBVR='V' or */
/* both), then on exit the arrays A and B will contain the complex Schur */
/* form[*] of the "balanced" versions of A and B. If no eigenvectors */
/* are computed, then only the diagonal blocks will be correct. */
/* [*] In other words, upper triangular form. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Statement Functions .. */
/* .. */
/* .. Statement Function definitions .. */
/* .. */
/* .. Executable Statements .. */
/* Decode the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
--alpha;
--beta;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1;
vr -= vr_offset;
--work;
--rwork;
/* Function Body */
if (lsame_(jobvl, "N")) {
ijobvl = 1;
ilvl = FALSE_;
} else if (lsame_(jobvl, "V")) {
ijobvl = 2;
ilvl = TRUE_;
} else {
ijobvl = -1;
ilvl = FALSE_;
}
if (lsame_(jobvr, "N")) {
ijobvr = 1;
ilvr = FALSE_;
} else if (lsame_(jobvr, "V")) {
ijobvr = 2;
ilvr = TRUE_;
} else {
ijobvr = -1;
ilvr = FALSE_;
}
ilv = ilvl || ilvr;
/* Test the input arguments */
/* Computing MAX */
i__1 = *n << 1;
lwkmin = max(i__1,1);
lwkopt = lwkmin;
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
lquery = *lwork == -1;
*info = 0;
if (ijobvl <= 0) {
*info = -1;
} else if (ijobvr <= 0) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*lda < max(1,*n)) {
*info = -5;
} else if (*ldb < max(1,*n)) {
*info = -7;
} else if (*ldvl < 1 || ilvl && *ldvl < *n) {
*info = -11;
} else if (*ldvr < 1 || ilvr && *ldvr < *n) {
*info = -13;
} else if (*lwork < lwkmin && ! lquery) {
*info = -15;
}
if (*info == 0) {
nb1 = ilaenv_(&c__1, "ZGEQRF", " ", n, n, &c_n1, &c_n1);
nb2 = ilaenv_(&c__1, "ZUNMQR", " ", n, n, n, &c_n1);
nb3 = ilaenv_(&c__1, "ZUNGQR", " ", n, n, n, &c_n1);
/* Computing MAX */
i__1 = max(nb1,nb2);
nb = max(i__1,nb3);
/* Computing MAX */
i__1 = *n << 1, i__2 = *n * (nb + 1);
lopt = max(i__1,i__2);
work[1].r = (doublereal) lopt, work[1].i = 0.;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGEGV ", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Get machine constants */
eps = dlamch_("E") * dlamch_("B");
safmin = dlamch_("S");
safmin += safmin;
safmax = 1. / safmin;
/* Scale A */
anrm = zlange_("M", n, n, &a[a_offset], lda, &rwork[1]);
anrm1 = anrm;
anrm2 = 1.;
if (anrm < 1.) {
if (safmax * anrm < 1.) {
anrm1 = safmin;
anrm2 = safmax * anrm;
}
}
if (anrm > 0.) {
zlascl_("G", &c_n1, &c_n1, &anrm, &c_b29, n, n, &a[a_offset], lda, &
iinfo);
if (iinfo != 0) {
*info = *n + 10;
return 0;
}
}
/* Scale B */
bnrm = zlange_("M", n, n, &b[b_offset], ldb, &rwork[1]);
bnrm1 = bnrm;
bnrm2 = 1.;
if (bnrm < 1.) {
if (safmax * bnrm < 1.) {
bnrm1 = safmin;
bnrm2 = safmax * bnrm;
}
}
if (bnrm > 0.) {
zlascl_("G", &c_n1, &c_n1, &bnrm, &c_b29, n, n, &b[b_offset], ldb, &
iinfo);
if (iinfo != 0) {
*info = *n + 10;
return 0;
}
}
/* Permute the matrix to make it more nearly triangular */
/* Also "balance" the matrix. */
ileft = 1;
iright = *n + 1;
irwork = iright + *n;
zggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &rwork[
ileft], &rwork[iright], &rwork[irwork], &iinfo);
if (iinfo != 0) {
*info = *n + 1;
goto L80;
}
/* Reduce B to triangular form, and initialize VL and/or VR */
irows = ihi + 1 - ilo;
if (ilv) {
icols = *n + 1 - ilo;
} else {
icols = irows;
}
itau = 1;
iwork = itau + irows;
i__1 = *lwork + 1 - iwork;
zgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[
iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__3 = iwork;
i__1 = lwkopt, i__2 = (integer) work[i__3].r + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 2;
goto L80;
}
i__1 = *lwork + 1 - iwork;
zunmqr_("L", "C", &irows, &icols, &irows, &b[ilo + ilo * b_dim1], ldb, &
work[itau], &a[ilo + ilo * a_dim1], lda, &work[iwork], &i__1, &
iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__3 = iwork;
i__1 = lwkopt, i__2 = (integer) work[i__3].r + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 3;
goto L80;
}
if (ilvl) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vl[vl_offset], ldvl);
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vl[ilo +
1 + ilo * vl_dim1], ldvl);
i__1 = *lwork + 1 - iwork;
zungqr_(&irows, &irows, &irows, &vl[ilo + ilo * vl_dim1], ldvl, &work[
itau], &work[iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__3 = iwork;
i__1 = lwkopt, i__2 = (integer) work[i__3].r + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 4;
goto L80;
}
}
if (ilvr) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vr[vr_offset], ldvr);
}
/* Reduce to generalized Hessenberg form */
if (ilv) {
/* Eigenvectors requested -- work on whole matrix. */
zgghrd_(jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, &iinfo);
} else {
zgghrd_("N", "N", &irows, &c__1, &irows, &a[ilo + ilo * a_dim1], lda,
&b[ilo + ilo * b_dim1], ldb, &vl[vl_offset], ldvl, &vr[
vr_offset], ldvr, &iinfo);
}
if (iinfo != 0) {
*info = *n + 5;
goto L80;
}
/* Perform QZ algorithm */
iwork = itau;
if (ilv) {
*(unsigned char *)chtemp = 'S';
} else {
*(unsigned char *)chtemp = 'E';
}
i__1 = *lwork + 1 - iwork;
zhgeqz_(chtemp, jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alpha[1], &beta[1], &vl[vl_offset], ldvl, &vr[
vr_offset], ldvr, &work[iwork], &i__1, &rwork[irwork], &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__3 = iwork;
i__1 = lwkopt, i__2 = (integer) work[i__3].r + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
if (iinfo > 0 && iinfo <= *n) {
*info = iinfo;
} else if (iinfo > *n && iinfo <= *n << 1) {
*info = iinfo - *n;
} else {
*info = *n + 6;
}
goto L80;
}
if (ilv) {
/* Compute Eigenvectors */
if (ilvl) {
if (ilvr) {
*(unsigned char *)chtemp = 'B';
} else {
*(unsigned char *)chtemp = 'L';
}
} else {
*(unsigned char *)chtemp = 'R';
}
ztgevc_(chtemp, "B", ldumma, n, &a[a_offset], lda, &b[b_offset], ldb,
&vl[vl_offset], ldvl, &vr[vr_offset], ldvr, n, &in, &work[
iwork], &rwork[irwork], &iinfo);
if (iinfo != 0) {
*info = *n + 7;
goto L80;
}
/* Undo balancing on VL and VR, rescale */
if (ilvl) {
zggbak_("P", "L", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n,
&vl[vl_offset], ldvl, &iinfo);
if (iinfo != 0) {
*info = *n + 8;
goto L80;
}
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
temp = 0.;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
i__3 = jr + jc * vl_dim1;
d__3 = temp, d__4 = (d__1 = vl[i__3].r, abs(d__1)) + (
d__2 = d_imag(&vl[jr + jc * vl_dim1]), abs(d__2));
temp = max(d__3,d__4);
/* L10: */
}
if (temp < safmin) {
goto L30;
}
temp = 1. / temp;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
i__3 = jr + jc * vl_dim1;
i__4 = jr + jc * vl_dim1;
z__1.r = temp * vl[i__4].r, z__1.i = temp * vl[i__4].i;
vl[i__3].r = z__1.r, vl[i__3].i = z__1.i;
/* L20: */
}
L30:
;
}
}
if (ilvr) {
zggbak_("P", "R", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n,
&vr[vr_offset], ldvr, &iinfo);
if (iinfo != 0) {
*info = *n + 9;
goto L80;
}
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
temp = 0.;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
i__3 = jr + jc * vr_dim1;
d__3 = temp, d__4 = (d__1 = vr[i__3].r, abs(d__1)) + (
d__2 = d_imag(&vr[jr + jc * vr_dim1]), abs(d__2));
temp = max(d__3,d__4);
/* L40: */
}
if (temp < safmin) {
goto L60;
}
temp = 1. / temp;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
i__3 = jr + jc * vr_dim1;
i__4 = jr + jc * vr_dim1;
z__1.r = temp * vr[i__4].r, z__1.i = temp * vr[i__4].i;
vr[i__3].r = z__1.r, vr[i__3].i = z__1.i;
/* L50: */
}
L60:
;
}
}
/* End of eigenvector calculation */
}
/* Undo scaling in alpha, beta */
/* Note: this does not give the alpha and beta for the unscaled */
/* problem. */
/* Un-scaling is limited to avoid underflow in alpha and beta */
/* if they are significant. */
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
i__2 = jc;
absar = (d__1 = alpha[i__2].r, abs(d__1));
absai = (d__1 = d_imag(&alpha[jc]), abs(d__1));
i__2 = jc;
absb = (d__1 = beta[i__2].r, abs(d__1));
i__2 = jc;
salfar = anrm * alpha[i__2].r;
salfai = anrm * d_imag(&alpha[jc]);
i__2 = jc;
sbeta = bnrm * beta[i__2].r;
ilimit = FALSE_;
scale = 1.;
/* Check for significant underflow in imaginary part of ALPHA */
/* Computing MAX */
d__1 = safmin, d__2 = eps * absar, d__1 = max(d__1,d__2), d__2 = eps *
absb;
if (abs(salfai) < safmin && absai >= max(d__1,d__2)) {
ilimit = TRUE_;
/* Computing MAX */
d__1 = safmin, d__2 = anrm2 * absai;
scale = safmin / anrm1 / max(d__1,d__2);
}
/* Check for significant underflow in real part of ALPHA */
/* Computing MAX */
d__1 = safmin, d__2 = eps * absai, d__1 = max(d__1,d__2), d__2 = eps *
absb;
if (abs(salfar) < safmin && absar >= max(d__1,d__2)) {
ilimit = TRUE_;
/* Computing MAX */
/* Computing MAX */
d__3 = safmin, d__4 = anrm2 * absar;
d__1 = scale, d__2 = safmin / anrm1 / max(d__3,d__4);
scale = max(d__1,d__2);
}
/* Check for significant underflow in BETA */
/* Computing MAX */
d__1 = safmin, d__2 = eps * absar, d__1 = max(d__1,d__2), d__2 = eps *
absai;
if (abs(sbeta) < safmin && absb >= max(d__1,d__2)) {
ilimit = TRUE_;
/* Computing MAX */
/* Computing MAX */
d__3 = safmin, d__4 = bnrm2 * absb;
d__1 = scale, d__2 = safmin / bnrm1 / max(d__3,d__4);
scale = max(d__1,d__2);
}
/* Check for possible overflow when limiting scaling */
if (ilimit) {
/* Computing MAX */
d__1 = abs(salfar), d__2 = abs(salfai), d__1 = max(d__1,d__2),
d__2 = abs(sbeta);
temp = scale * safmin * max(d__1,d__2);
if (temp > 1.) {
scale /= temp;
}
if (scale < 1.) {
ilimit = FALSE_;
}
}
/* Recompute un-scaled ALPHA, BETA if necessary. */
if (ilimit) {
i__2 = jc;
salfar = scale * alpha[i__2].r * anrm;
salfai = scale * d_imag(&alpha[jc]) * anrm;
i__2 = jc;
z__2.r = scale * beta[i__2].r, z__2.i = scale * beta[i__2].i;
z__1.r = bnrm * z__2.r, z__1.i = bnrm * z__2.i;
sbeta = z__1.r;
}
i__2 = jc;
z__1.r = salfar, z__1.i = salfai;
alpha[i__2].r = z__1.r, alpha[i__2].i = z__1.i;
i__2 = jc;
beta[i__2].r = sbeta, beta[i__2].i = 0.;
/* L70: */
}
L80:
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
return 0;
/* End of ZGEGV */
} /* zgegv_ */
/* Subroutine */
int zggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp selctg, char *sense, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, integer *sdim, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, integer *ldvsl, doublecomplex *vsr, integer *ldvsr, doublereal *rconde, doublereal * rcondv, doublecomplex *work, integer *lwork, doublereal *rwork, integer *iwork, integer *liwork, logical *bwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vsl_dim1, vsl_offset, vsr_dim1, vsr_offset, i__1, i__2;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
integer i__;
doublereal pl, pr, dif[2];
integer ihi, ilo;
doublereal eps;
integer ijob;
doublereal anrm, bnrm;
integer ierr, itau, iwrk, lwrk;
extern logical lsame_(char *, char *);
integer ileft, icols;
logical cursl, ilvsl, ilvsr;
integer irwrk, irows;
extern /* Subroutine */
int dlabad_(doublereal *, doublereal *);
extern doublereal dlamch_(char *);
extern /* Subroutine */
int zggbak_(char *, char *, integer *, integer *, integer *, doublereal *, doublereal *, integer *, doublecomplex *, integer *, integer *), zggbal_(char *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer * , integer *, doublereal *, doublereal *, doublereal *, integer *);
logical ilascl, ilbscl;
extern /* Subroutine */
int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *, integer *, integer *);
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *, integer *, doublereal *);
doublereal bignum;
integer ijobvl, iright;
extern /* Subroutine */
int zgghrd_(char *, char *, integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer * ), zlascl_(char *, integer *, integer *, doublereal *, doublereal *, integer *, integer *, doublecomplex *, integer *, integer *);
integer ijobvr;
logical wantsb;
integer liwmin;
logical wantse, lastsl;
doublereal anrmto, bnrmto;
extern /* Subroutine */
int zgeqrf_(integer *, integer *, doublecomplex *, integer *, doublecomplex *, doublecomplex *, integer *, integer * );
integer maxwrk;
logical wantsn;
integer minwrk;
doublereal smlnum;
extern /* Subroutine */
int zhgeqz_(char *, char *, char *, integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, doublecomplex *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublereal *, integer *), zlacpy_(char *, integer *, integer *, doublecomplex *, integer *, doublecomplex * , integer *), zlaset_(char *, integer *, integer *, doublecomplex *, doublecomplex *, doublecomplex *, integer *);
logical wantst, lquery, wantsv;
extern /* Subroutine */
int ztgsen_(integer *, logical *, logical *, logical *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, doublecomplex *, doublecomplex *, integer *, doublecomplex *, integer *, integer *, doublereal *, doublereal *, doublereal *, doublecomplex *, integer *, integer *, integer *, integer *), zungqr_(integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, doublecomplex *, integer *, integer *), zunmqr_(char *, char *, integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, doublecomplex *, integer *, doublecomplex *, integer *, integer *);
/* -- LAPACK driver routine (version 3.4.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* November 2011 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* .. Function Arguments .. */
/* .. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Decode the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
--alpha;
--beta;
vsl_dim1 = *ldvsl;
vsl_offset = 1 + vsl_dim1;
vsl -= vsl_offset;
vsr_dim1 = *ldvsr;
vsr_offset = 1 + vsr_dim1;
vsr -= vsr_offset;
--rconde;
--rcondv;
--work;
--rwork;
--iwork;
--bwork;
/* Function Body */
if (lsame_(jobvsl, "N"))
{
ijobvl = 1;
ilvsl = FALSE_;
}
else if (lsame_(jobvsl, "V"))
{
ijobvl = 2;
ilvsl = TRUE_;
}
else
{
ijobvl = -1;
ilvsl = FALSE_;
}
if (lsame_(jobvsr, "N"))
{
ijobvr = 1;
ilvsr = FALSE_;
}
else if (lsame_(jobvsr, "V"))
{
ijobvr = 2;
ilvsr = TRUE_;
}
else
{
ijobvr = -1;
ilvsr = FALSE_;
}
wantst = lsame_(sort, "S");
wantsn = lsame_(sense, "N");
wantse = lsame_(sense, "E");
wantsv = lsame_(sense, "V");
wantsb = lsame_(sense, "B");
lquery = *lwork == -1 || *liwork == -1;
if (wantsn)
{
ijob = 0;
}
else if (wantse)
{
ijob = 1;
}
else if (wantsv)
{
ijob = 2;
}
else if (wantsb)
{
ijob = 4;
}
/* Test the input arguments */
*info = 0;
if (ijobvl <= 0)
{
*info = -1;
}
else if (ijobvr <= 0)
{
*info = -2;
}
else if (! wantst && ! lsame_(sort, "N"))
{
*info = -3;
}
else if (! (wantsn || wantse || wantsv || wantsb) || ! wantst && ! wantsn)
{
*info = -5;
}
else if (*n < 0)
{
*info = -6;
}
else if (*lda < max(1,*n))
{
*info = -8;
}
else if (*ldb < max(1,*n))
{
*info = -10;
}
else if (*ldvsl < 1 || ilvsl && *ldvsl < *n)
{
*info = -15;
}
else if (*ldvsr < 1 || ilvsr && *ldvsr < *n)
{
*info = -17;
}
/* 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.) */
if (*info == 0)
{
if (*n > 0)
{
minwrk = *n << 1;
maxwrk = *n * (ilaenv_(&c__1, "ZGEQRF", " ", n, &c__1, n, &c__0) + 1);
/* Computing MAX */
i__1 = maxwrk;
i__2 = *n * (ilaenv_(&c__1, "ZUNMQR", " ", n, & c__1, n, &c_n1) + 1); // , expr subst
maxwrk = max(i__1,i__2);
if (ilvsl)
{
/* Computing MAX */
i__1 = maxwrk;
i__2 = *n * (ilaenv_(&c__1, "ZUNGQR", " ", n, & c__1, n, &c_n1) + 1); // , expr subst
maxwrk = max(i__1,i__2);
}
lwrk = maxwrk;
if (ijob >= 1)
{
/* Computing MAX */
i__1 = lwrk;
i__2 = *n * *n / 2; // , expr subst
lwrk = max(i__1,i__2);
}
}
else
{
minwrk = 1;
maxwrk = 1;
lwrk = 1;
}
work[1].r = (doublereal) lwrk;
work[1].i = 0.; // , expr subst
if (wantsn || *n == 0)
{
liwmin = 1;
}
else
{
liwmin = *n + 2;
}
iwork[1] = liwmin;
if (*lwork < minwrk && ! lquery)
{
*info = -21;
}
else if (*liwork < liwmin && ! lquery)
{
*info = -24;
}
}
if (*info != 0)
{
i__1 = -(*info);
xerbla_("ZGGESX", &i__1);
return 0;
}
else if (lquery)
{
return 0;
}
/* Quick return if possible */
if (*n == 0)
{
*sdim = 0;
return 0;
}
/* Get machine constants */
eps = dlamch_("P");
smlnum = dlamch_("S");
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
smlnum = sqrt(smlnum) / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", n, n, &a[a_offset], lda, &rwork[1]);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum)
{
anrmto = smlnum;
ilascl = TRUE_;
}
else if (anrm > bignum)
{
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl)
{
zlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, & ierr);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = zlange_("M", n, n, &b[b_offset], ldb, &rwork[1]);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum)
{
bnrmto = smlnum;
ilbscl = TRUE_;
}
else if (bnrm > bignum)
{
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl)
{
zlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, & ierr);
}
/* Permute the matrix to make it more nearly triangular */
/* (Real Workspace: need 6*N) */
ileft = 1;
iright = *n + 1;
irwrk = iright + *n;
zggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &rwork[ ileft], &rwork[iright], &rwork[irwrk], &ierr);
/* Reduce B to triangular form (QR decomposition of B) */
/* (Complex Workspace: need N, prefer N*NB) */
irows = ihi + 1 - ilo;
icols = *n + 1 - ilo;
itau = 1;
iwrk = itau + irows;
i__1 = *lwork + 1 - iwrk;
zgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[ iwrk], &i__1, &ierr);
/* Apply the unitary transformation to matrix A */
/* (Complex Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
zunmqr_("L", "C", &irows, &icols, &irows, &b[ilo + ilo * b_dim1], ldb, & work[itau], &a[ilo + ilo * a_dim1], lda, &work[iwrk], &i__1, & ierr);
/* Initialize VSL */
/* (Complex Workspace: need N, prefer N*NB) */
if (ilvsl)
{
zlaset_("Full", n, n, &c_b1, &c_b2, &vsl[vsl_offset], ldvsl);
if (irows > 1)
{
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vsl[ ilo + 1 + ilo * vsl_dim1], ldvsl);
}
i__1 = *lwork + 1 - iwrk;
zungqr_(&irows, &irows, &irows, &vsl[ilo + ilo * vsl_dim1], ldvsl, & work[itau], &work[iwrk], &i__1, &ierr);
}
/* Initialize VSR */
if (ilvsr)
{
zlaset_("Full", n, n, &c_b1, &c_b2, &vsr[vsr_offset], ldvsr);
}
/* Reduce to generalized Hessenberg form */
/* (Workspace: none needed) */
zgghrd_(jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset], ldb, &vsl[vsl_offset], ldvsl, &vsr[vsr_offset], ldvsr, &ierr);
*sdim = 0;
/* Perform QZ algorithm, computing Schur vectors if desired */
/* (Complex Workspace: need N) */
/* (Real Workspace: need N) */
iwrk = itau;
i__1 = *lwork + 1 - iwrk;
zhgeqz_("S", jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[ b_offset], ldb, &alpha[1], &beta[1], &vsl[vsl_offset], ldvsl, & vsr[vsr_offset], ldvsr, &work[iwrk], &i__1, &rwork[irwrk], &ierr);
if (ierr != 0)
{
if (ierr > 0 && ierr <= *n)
{
*info = ierr;
}
else if (ierr > *n && ierr <= *n << 1)
{
*info = ierr - *n;
}
else
{
*info = *n + 1;
}
goto L40;
}
/* Sort eigenvalues ALPHA/BETA and compute the reciprocal of */
/* condition number(s) */
if (wantst)
{
/* Undo scaling on eigenvalues before SELCTGing */
if (ilascl)
{
zlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alpha[1], n, &ierr);
}
if (ilbscl)
{
zlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, &ierr);
}
/* Select eigenvalues */
i__1 = *n;
for (i__ = 1;
i__ <= i__1;
++i__)
{
bwork[i__] = (*selctg)(&alpha[i__], &beta[i__]);
/* L10: */
}
/* Reorder eigenvalues, transform Generalized Schur vectors, and */
/* compute reciprocal condition numbers */
/* (Complex Workspace: If IJOB >= 1, need MAX(1, 2*SDIM*(N-SDIM)) */
/* otherwise, need 1 ) */
i__1 = *lwork - iwrk + 1;
ztgsen_(&ijob, &ilvsl, &ilvsr, &bwork[1], n, &a[a_offset], lda, &b[ b_offset], ldb, &alpha[1], &beta[1], &vsl[vsl_offset], ldvsl, &vsr[vsr_offset], ldvsr, sdim, &pl, &pr, dif, &work[iwrk], & i__1, &iwork[1], liwork, &ierr);
if (ijob >= 1)
{
/* Computing MAX */
i__1 = maxwrk;
i__2 = (*sdim << 1) * (*n - *sdim); // , expr subst
maxwrk = max(i__1,i__2);
}
if (ierr == -21)
{
/* not enough complex workspace */
*info = -21;
}
else
{
if (ijob == 1 || ijob == 4)
{
rconde[1] = pl;
rconde[2] = pr;
}
if (ijob == 2 || ijob == 4)
{
rcondv[1] = dif[0];
rcondv[2] = dif[1];
}
if (ierr == 1)
{
*info = *n + 3;
}
}
}
/* Apply permutation to VSL and VSR */
/* (Workspace: none needed) */
if (ilvsl)
{
zggbak_("P", "L", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, & vsl[vsl_offset], ldvsl, &ierr);
}
if (ilvsr)
{
zggbak_("P", "R", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, & vsr[vsr_offset], ldvsr, &ierr);
}
/* Undo scaling */
if (ilascl)
{
zlascl_("U", &c__0, &c__0, &anrmto, &anrm, n, n, &a[a_offset], lda, & ierr);
zlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alpha[1], n, & ierr);
}
if (ilbscl)
{
zlascl_("U", &c__0, &c__0, &bnrmto, &bnrm, n, n, &b[b_offset], ldb, & ierr);
zlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, & ierr);
}
if (wantst)
{
/* Check if reordering is correct */
lastsl = TRUE_;
*sdim = 0;
i__1 = *n;
for (i__ = 1;
i__ <= i__1;
++i__)
{
cursl = (*selctg)(&alpha[i__], &beta[i__]);
if (cursl)
{
++(*sdim);
}
if (cursl && ! lastsl)
{
*info = *n + 2;
}
lastsl = cursl;
/* L30: */
}
}
L40:
work[1].r = (doublereal) maxwrk;
work[1].i = 0.; // , expr subst
iwork[1] = liwmin;
return 0;
/* End of ZGGESX */
}
/* Subroutine */ int zgeqp3_(integer *m, integer *n, doublecomplex *a,
integer *lda, integer *jpvt, doublecomplex *tau, doublecomplex *work,
integer *lwork, doublereal *rwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3;
/* Local variables */
integer j, jb, na, nb, sm, sn, nx, fjb, iws, nfxd, nbmin, minmn, minws;
extern /* Subroutine */ int zswap_(integer *, doublecomplex *, integer *,
doublecomplex *, integer *), zlaqp2_(integer *, integer *,
integer *, doublecomplex *, integer *, integer *, doublecomplex *,
doublereal *, doublereal *, doublecomplex *);
extern doublereal dznrm2_(integer *, doublecomplex *, integer *);
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
);
integer topbmn, sminmn;
extern /* Subroutine */ int zlaqps_(integer *, integer *, integer *,
integer *, integer *, doublecomplex *, integer *, integer *,
doublecomplex *, doublereal *, doublereal *, doublecomplex *,
doublecomplex *, integer *);
integer lwkopt;
logical lquery;
extern /* Subroutine */ int zunmqr_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
/* -- LAPACK routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZGEQP3 computes a QR factorization with column pivoting of a */
/* matrix A: A*P = Q*R using Level 3 BLAS. */
/* 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. */
/* A (input/output) COMPLEX*16 array, dimension (LDA,N) */
/* On entry, the M-by-N matrix A. */
/* On exit, the upper triangle of the array contains the */
/* min(M,N)-by-N upper trapezoidal matrix R; the elements below */
/* the diagonal, together with the array TAU, represent the */
/* unitary matrix Q as a product of min(M,N) elementary */
/* reflectors. */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= max(1,M). */
/* JPVT (input/output) INTEGER array, dimension (N) */
/* On entry, if JPVT(J).ne.0, the J-th column of A is permuted */
/* to the front of A*P (a leading column); if JPVT(J)=0, */
/* the J-th column of A is a free column. */
/* On exit, if JPVT(J)=K, then the J-th column of A*P was the */
/* the K-th column of A. */
/* TAU (output) COMPLEX*16 array, dimension (min(M,N)) */
/* The scalar factors of the elementary reflectors. */
/* WORK (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO=0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= N+1. */
/* For optimal performance LWORK >= ( N+1 )*NB, where NB */
/* is the optimal blocksize. */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the WORK array, returns */
/* this value as the first entry of the WORK array, and no error */
/* message related to LWORK is issued by XERBLA. */
/* RWORK (workspace) DOUBLE PRECISION array, dimension (2*N) */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* Further Details */
/* =============== */
/* The matrix Q is represented as a product of elementary reflectors */
/* Q = H(1) H(2) . . . H(k), where k = min(m,n). */
/* Each H(i) has the form */
/* H(i) = I - tau * v * v' */
/* where tau is a real/complex scalar, and v is a real/complex vector */
/* with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in */
/* A(i+1:m,i), and tau in TAU(i). */
/* Based on contributions by */
/* G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain */
/* X. Sun, Computer Science Dept., Duke University, USA */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test input arguments */
/* ==================== */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--jpvt;
--tau;
--work;
--rwork;
/* Function Body */
*info = 0;
lquery = *lwork == -1;
if (*m < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*lda < max(1,*m)) {
*info = -4;
}
if (*info == 0) {
minmn = min(*m,*n);
if (minmn == 0) {
iws = 1;
lwkopt = 1;
} else {
iws = *n + 1;
nb = ilaenv_(&c__1, "ZGEQRF", " ", m, n, &c_n1, &c_n1);
lwkopt = (*n + 1) * nb;
}
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
if (*lwork < iws && ! lquery) {
*info = -8;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGEQP3", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible. */
if (minmn == 0) {
return 0;
}
/* Move initial columns up front. */
nfxd = 1;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (jpvt[j] != 0) {
if (j != nfxd) {
zswap_(m, &a[j * a_dim1 + 1], &c__1, &a[nfxd * a_dim1 + 1], &
c__1);
jpvt[j] = jpvt[nfxd];
jpvt[nfxd] = j;
} else {
jpvt[j] = j;
}
++nfxd;
} else {
jpvt[j] = j;
}
/* L10: */
}
--nfxd;
/* Factorize fixed columns */
/* ======================= */
/* Compute the QR factorization of fixed columns and update */
/* remaining columns. */
if (nfxd > 0) {
na = min(*m,nfxd);
/* CC CALL ZGEQR2( M, NA, A, LDA, TAU, WORK, INFO ) */
zgeqrf_(m, &na, &a[a_offset], lda, &tau[1], &work[1], lwork, info);
/* Computing MAX */
i__1 = iws, i__2 = (integer) work[1].r;
iws = max(i__1,i__2);
if (na < *n) {
/* CC CALL ZUNM2R( 'Left', 'Conjugate Transpose', M, N-NA, */
/* CC $ NA, A, LDA, TAU, A( 1, NA+1 ), LDA, WORK, */
/* CC $ INFO ) */
i__1 = *n - na;
zunmqr_("Left", "Conjugate Transpose", m, &i__1, &na, &a[a_offset]
, lda, &tau[1], &a[(na + 1) * a_dim1 + 1], lda, &work[1],
lwork, info);
/* Computing MAX */
i__1 = iws, i__2 = (integer) work[1].r;
iws = max(i__1,i__2);
}
}
/* Factorize free columns */
/* ====================== */
if (nfxd < minmn) {
sm = *m - nfxd;
sn = *n - nfxd;
sminmn = minmn - nfxd;
/* Determine the block size. */
nb = ilaenv_(&c__1, "ZGEQRF", " ", &sm, &sn, &c_n1, &c_n1);
nbmin = 2;
nx = 0;
if (nb > 1 && nb < sminmn) {
/* Determine when to cross over from blocked to unblocked code. */
/* Computing MAX */
i__1 = 0, i__2 = ilaenv_(&c__3, "ZGEQRF", " ", &sm, &sn, &c_n1, &
c_n1);
nx = max(i__1,i__2);
if (nx < sminmn) {
/* Determine if workspace is large enough for blocked code. */
minws = (sn + 1) * nb;
iws = max(iws,minws);
if (*lwork < minws) {
/* Not enough workspace to use optimal NB: Reduce NB and */
/* determine the minimum value of NB. */
nb = *lwork / (sn + 1);
/* Computing MAX */
i__1 = 2, i__2 = ilaenv_(&c__2, "ZGEQRF", " ", &sm, &sn, &
c_n1, &c_n1);
nbmin = max(i__1,i__2);
}
}
}
/* Initialize partial column norms. The first N elements of work */
/* store the exact column norms. */
i__1 = *n;
for (j = nfxd + 1; j <= i__1; ++j) {
rwork[j] = dznrm2_(&sm, &a[nfxd + 1 + j * a_dim1], &c__1);
rwork[*n + j] = rwork[j];
/* L20: */
}
if (nb >= nbmin && nb < sminmn && nx < sminmn) {
/* Use blocked code initially. */
j = nfxd + 1;
/* Compute factorization: while loop. */
topbmn = minmn - nx;
L30:
if (j <= topbmn) {
/* Computing MIN */
i__1 = nb, i__2 = topbmn - j + 1;
jb = min(i__1,i__2);
/* Factorize JB columns among columns J:N. */
i__1 = *n - j + 1;
i__2 = j - 1;
i__3 = *n - j + 1;
zlaqps_(m, &i__1, &i__2, &jb, &fjb, &a[j * a_dim1 + 1], lda, &
jpvt[j], &tau[j], &rwork[j], &rwork[*n + j], &work[1],
&work[jb + 1], &i__3);
j += fjb;
goto L30;
}
} else {
j = nfxd + 1;
}
/* Use unblocked code to factor the last or only block. */
if (j <= minmn) {
i__1 = *n - j + 1;
i__2 = j - 1;
zlaqp2_(m, &i__1, &i__2, &a[j * a_dim1 + 1], lda, &jpvt[j], &tau[
j], &rwork[j], &rwork[*n + j], &work[1]);
}
}
work[1].r = (doublereal) iws, work[1].i = 0.;
return 0;
/* End of ZGEQP3 */
} /* zgeqp3_ */
/* Subroutine */ int zggqrf_(integer *n, integer *m, integer *p,
doublecomplex *a, integer *lda, doublecomplex *taua, doublecomplex *b,
integer *ldb, doublecomplex *taub, doublecomplex *work, integer *
lwork, integer *info)
{
/* -- LAPACK routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
June 30, 1999
Purpose
=======
ZGGQRF computes a generalized QR factorization of an N-by-M matrix A
and an N-by-P matrix B:
A = Q*R, B = Q*T*Z,
where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix,
and R and T assume one of the forms:
if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N,
( 0 ) N-M N M-N
M
where R11 is upper triangular, and
if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P,
P-N N ( T21 ) P
P
where T12 or T21 is upper triangular.
In particular, if B is square and nonsingular, the GQR factorization
of A and B implicitly gives the QR factorization of inv(B)*A:
inv(B)*A = Z'*(inv(T)*R)
where inv(B) denotes the inverse of the matrix B, and Z' denotes the
conjugate transpose of matrix Z.
Arguments
=========
N (input) INTEGER
The number of rows of the matrices A and B. N >= 0.
M (input) INTEGER
The number of columns of the matrix A. M >= 0.
P (input) INTEGER
The number of columns of the matrix B. P >= 0.
A (input/output) COMPLEX*16 array, dimension (LDA,M)
On entry, the N-by-M matrix A.
On exit, the elements on and above the diagonal of the array
contain the min(N,M)-by-M upper trapezoidal matrix R (R is
upper triangular if N >= M); the elements below the diagonal,
with the array TAUA, represent the unitary matrix Q as a
product of min(N,M) elementary reflectors (see Further
Details).
LDA (input) INTEGER
The leading dimension of the array A. LDA >= max(1,N).
TAUA (output) COMPLEX*16 array, dimension (min(N,M))
The scalar factors of the elementary reflectors which
represent the unitary matrix Q (see Further Details).
B (input/output) COMPLEX*16 array, dimension (LDB,P)
On entry, the N-by-P matrix B.
On exit, if N <= P, the upper triangle of the subarray
B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;
if N > P, the elements on and above the (N-P)-th subdiagonal
contain the N-by-P upper trapezoidal matrix T; the remaining
elements, with the array TAUB, represent the unitary
matrix Z as a product of elementary reflectors (see Further
Details).
LDB (input) INTEGER
The leading dimension of the array B. LDB >= max(1,N).
TAUB (output) COMPLEX*16 array, dimension (min(N,P))
The scalar factors of the elementary reflectors which
represent the unitary matrix Z (see Further Details).
WORK (workspace/output) COMPLEX*16 array, dimension (LWORK)
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK. LWORK >= max(1,N,M,P).
For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),
where NB1 is the optimal blocksize for the QR factorization
of an N-by-M matrix, NB2 is the optimal blocksize for the
RQ factorization of an N-by-P matrix, and NB3 is the optimal
blocksize for a call of ZUNMQR.
If LWORK = -1, then a workspace query is assumed; the routine
only calculates the optimal size of the WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value.
Further Details
===============
The matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(k), where k = min(n,m).
Each H(i) has the form
H(i) = I - taua * v * v'
where taua is a complex scalar, and v is a complex vector with
v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
and taua in TAUA(i).
To form Q explicitly, use LAPACK subroutine ZUNGQR.
To use Q to update another matrix, use LAPACK subroutine ZUNMQR.
The matrix Z is represented as a product of elementary reflectors
Z = H(1) H(2) . . . H(k), where k = min(n,p).
Each H(i) has the form
H(i) = I - taub * v * v'
where taub is a complex scalar, and v is a complex vector with
v(p-k+i+1:p) = 0 and v(p-k+i) = 1; v(1:p-k+i-1) is stored on exit in
B(n-k+i,1:p-k+i-1), and taub in TAUB(i).
To form Z explicitly, use LAPACK subroutine ZUNGRQ.
To use Z to update another matrix, use LAPACK subroutine ZUNMRQ.
=====================================================================
Test the input parameters
Parameter adjustments */
/* Table of constant values */
static integer c__1 = 1;
static integer c_n1 = -1;
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3;
/* Local variables */
static integer lopt, nb;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
), zgerqf_(integer *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, integer *, integer *);
static integer nb1, nb2, nb3, lwkopt;
static logical lquery;
extern /* Subroutine */ int zunmqr_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
--taua;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
--taub;
--work;
/* Function Body */
*info = 0;
nb1 = ilaenv_(&c__1, "ZGEQRF", " ", n, m, &c_n1, &c_n1, (ftnlen)6, (
ftnlen)1);
nb2 = ilaenv_(&c__1, "ZGERQF", " ", n, p, &c_n1, &c_n1, (ftnlen)6, (
ftnlen)1);
nb3 = ilaenv_(&c__1, "ZUNMQR", " ", n, m, p, &c_n1, (ftnlen)6, (ftnlen)1);
/* Computing MAX */
i__1 = max(nb1,nb2);
nb = max(i__1,nb3);
/* Computing MAX */
i__1 = max(*n,*m);
lwkopt = max(i__1,*p) * nb;
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
lquery = *lwork == -1;
if (*n < 0) {
*info = -1;
} else if (*m < 0) {
*info = -2;
} else if (*p < 0) {
*info = -3;
} else if (*lda < max(1,*n)) {
*info = -5;
} else if (*ldb < max(1,*n)) {
*info = -8;
} else /* if(complicated condition) */ {
/* Computing MAX */
i__1 = max(1,*n), i__1 = max(i__1,*m);
if (*lwork < max(i__1,*p) && ! lquery) {
*info = -11;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGGQRF", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* QR factorization of N-by-M matrix A: A = Q*R */
zgeqrf_(n, m, &a[a_offset], lda, &taua[1], &work[1], lwork, info);
lopt = (integer) work[1].r;
/* Update B := Q'*B. */
i__1 = min(*n,*m);
zunmqr_("Left", "Conjugate Transpose", n, p, &i__1, &a[a_offset], lda, &
taua[1], &b[b_offset], ldb, &work[1], lwork, info);
/* Computing MAX */
i__1 = lopt, i__2 = (integer) work[1].r;
lopt = max(i__1,i__2);
/* RQ factorization of N-by-P matrix B: B = T*Z. */
zgerqf_(n, p, &b[b_offset], ldb, &taub[1], &work[1], lwork, info);
/* Computing MAX */
i__2 = lopt, i__3 = (integer) work[1].r;
i__1 = max(i__2,i__3);
work[1].r = (doublereal) i__1, work[1].i = 0.;
return 0;
/* End of ZGGQRF */
} /* zggqrf_ */
int zgges_(char *jobvsl, char *jobvsr, char *sort, L_fp
selctg, int *n, doublecomplex *a, int *lda, doublecomplex *b,
int *ldb, int *sdim, doublecomplex *alpha, doublecomplex *
beta, doublecomplex *vsl, int *ldvsl, doublecomplex *vsr, int
*ldvsr, doublecomplex *work, int *lwork, double *rwork,
int *bwork, int *info)
{
/* System generated locals */
int a_dim1, a_offset, b_dim1, b_offset, vsl_dim1, vsl_offset,
vsr_dim1, vsr_offset, i__1, i__2;
/* Builtin functions */
double sqrt(double);
/* Local variables */
int i__;
double dif[2];
int ihi, ilo;
double eps, anrm, bnrm;
int idum[1], ierr, itau, iwrk;
double pvsl, pvsr;
extern int lsame_(char *, char *);
int ileft, icols;
int cursl, ilvsl, ilvsr;
int irwrk, irows;
extern int dlabad_(double *, double *);
extern double dlamch_(char *);
extern int zggbak_(char *, char *, int *, int *,
int *, double *, double *, int *, doublecomplex *,
int *, int *), zggbal_(char *, int *,
doublecomplex *, int *, doublecomplex *, int *, int *
, int *, double *, double *, double *, int *);
int ilascl, ilbscl;
extern int xerbla_(char *, int *);
extern int ilaenv_(int *, char *, char *, int *, int *,
int *, int *);
extern double zlange_(char *, int *, int *, doublecomplex *,
int *, double *);
double bignum;
int ijobvl, iright;
extern int zgghrd_(char *, char *, int *, int *,
int *, doublecomplex *, int *, doublecomplex *, int *,
doublecomplex *, int *, doublecomplex *, int *, int *
), zlascl_(char *, int *, int *,
double *, double *, int *, int *, doublecomplex *,
int *, int *);
int ijobvr;
extern int zgeqrf_(int *, int *, doublecomplex *,
int *, doublecomplex *, doublecomplex *, int *, int *
);
double anrmto;
int lwkmin;
int lastsl;
double bnrmto;
extern int zlacpy_(char *, int *, int *,
doublecomplex *, int *, doublecomplex *, int *),
zlaset_(char *, int *, int *, doublecomplex *,
doublecomplex *, doublecomplex *, int *), zhgeqz_(
char *, char *, char *, int *, int *, int *,
doublecomplex *, int *, doublecomplex *, int *,
doublecomplex *, doublecomplex *, doublecomplex *, int *,
doublecomplex *, int *, doublecomplex *, int *,
double *, int *), ztgsen_(int
*, int *, int *, int *, int *, doublecomplex *,
int *, doublecomplex *, int *, doublecomplex *,
doublecomplex *, doublecomplex *, int *, doublecomplex *,
int *, int *, double *, double *, double *,
doublecomplex *, int *, int *, int *, int *);
double smlnum;
int wantst, lquery;
int lwkopt;
extern int zungqr_(int *, int *, int *,
doublecomplex *, int *, doublecomplex *, doublecomplex *,
int *, int *), zunmqr_(char *, char *, int *, int
*, int *, doublecomplex *, int *, doublecomplex *,
doublecomplex *, int *, doublecomplex *, int *, int *);
/* -- LAPACK driver routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* .. Function Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZGGES computes for a pair of N-by-N complex nonsymmetric matrices */
/* (A,B), the generalized eigenvalues, the generalized complex Schur */
/* form (S, T), and optionally left and/or right Schur vectors (VSL */
/* and VSR). This gives the generalized Schur factorization */
/* (A,B) = ( (VSL)*S*(VSR)**H, (VSL)*T*(VSR)**H ) */
/* where (VSR)**H is the conjugate-transpose of VSR. */
/* Optionally, it also orders the eigenvalues so that a selected cluster */
/* of eigenvalues appears in the leading diagonal blocks of the upper */
/* triangular matrix S and the upper triangular matrix T. The leading */
/* columns of VSL and VSR then form an unitary basis for the */
/* corresponding left and right eigenspaces (deflating subspaces). */
/* (If only the generalized eigenvalues are needed, use the driver */
/* ZGGEV instead, which is faster.) */
/* A generalized eigenvalue for a pair of matrices (A,B) is a scalar w */
/* or a ratio alpha/beta = w, such that A - w*B is singular. It is */
/* usually represented as the pair (alpha,beta), as there is a */
/* reasonable interpretation for beta=0, and even for both being zero. */
/* A pair of matrices (S,T) is in generalized complex Schur form if S */
/* and T are upper triangular and, in addition, the diagonal elements */
/* of T are non-negative float numbers. */
/* Arguments */
/* ========= */
/* JOBVSL (input) CHARACTER*1 */
/* = 'N': do not compute the left Schur vectors; */
/* = 'V': compute the left Schur vectors. */
/* JOBVSR (input) CHARACTER*1 */
/* = 'N': do not compute the right Schur vectors; */
/* = 'V': compute the right Schur vectors. */
/* SORT (input) CHARACTER*1 */
/* Specifies whether or not to order the eigenvalues on the */
/* diagonal of the generalized Schur form. */
/* = 'N': Eigenvalues are not ordered; */
/* = 'S': Eigenvalues are ordered (see SELCTG). */
/* SELCTG (external procedure) LOGICAL FUNCTION of two COMPLEX*16 arguments */
/* SELCTG must be declared EXTERNAL in the calling subroutine. */
/* If SORT = 'N', SELCTG is not referenced. */
/* If SORT = 'S', SELCTG is used to select eigenvalues to sort */
/* to the top left of the Schur form. */
/* An eigenvalue ALPHA(j)/BETA(j) is selected if */
/* SELCTG(ALPHA(j),BETA(j)) is true. */
/* Note that a selected complex eigenvalue may no longer satisfy */
/* SELCTG(ALPHA(j),BETA(j)) = .TRUE. after ordering, since */
/* ordering may change the value of complex eigenvalues */
/* (especially if the eigenvalue is ill-conditioned), in this */
/* case INFO is set to N+2 (See INFO below). */
/* N (input) INTEGER */
/* The order of the matrices A, B, VSL, and VSR. N >= 0. */
/* A (input/output) COMPLEX*16 array, dimension (LDA, N) */
/* On entry, the first of the pair of matrices. */
/* On exit, A has been overwritten by its generalized Schur */
/* form S. */
/* LDA (input) INTEGER */
/* The leading dimension of A. LDA >= MAX(1,N). */
/* B (input/output) COMPLEX*16 array, dimension (LDB, N) */
/* On entry, the second of the pair of matrices. */
/* On exit, B has been overwritten by its generalized Schur */
/* form T. */
/* LDB (input) INTEGER */
/* The leading dimension of B. LDB >= MAX(1,N). */
/* SDIM (output) INTEGER */
/* If SORT = 'N', SDIM = 0. */
/* If SORT = 'S', SDIM = number of eigenvalues (after sorting) */
/* for which SELCTG is true. */
/* ALPHA (output) COMPLEX*16 array, dimension (N) */
/* BETA (output) COMPLEX*16 array, dimension (N) */
/* On exit, ALPHA(j)/BETA(j), j=1,...,N, will be the */
/* generalized eigenvalues. ALPHA(j), j=1,...,N and BETA(j), */
/* j=1,...,N are the diagonals of the complex Schur form (A,B) */
/* output by ZGGES. The BETA(j) will be non-negative float. */
/* Note: the quotients ALPHA(j)/BETA(j) may easily over- or */
/* underflow, and BETA(j) may even be zero. Thus, the user */
/* should avoid naively computing the ratio alpha/beta. */
/* However, ALPHA will be always less than and usually */
/* comparable with norm(A) in magnitude, and BETA always less */
/* than and usually comparable with norm(B). */
/* VSL (output) COMPLEX*16 array, dimension (LDVSL,N) */
/* If JOBVSL = 'V', VSL will contain the left Schur vectors. */
/* Not referenced if JOBVSL = 'N'. */
/* LDVSL (input) INTEGER */
/* The leading dimension of the matrix VSL. LDVSL >= 1, and */
/* if JOBVSL = 'V', LDVSL >= N. */
/* VSR (output) COMPLEX*16 array, dimension (LDVSR,N) */
/* If JOBVSR = 'V', VSR will contain the right Schur vectors. */
/* Not referenced if JOBVSR = 'N'. */
/* LDVSR (input) INTEGER */
/* The leading dimension of the matrix VSR. LDVSR >= 1, and */
/* if JOBVSR = 'V', LDVSR >= N. */
/* WORK (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= MAX(1,2*N). */
/* For good performance, LWORK must generally be larger. */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the WORK array, returns */
/* this value as the first entry of the WORK array, and no error */
/* message related to LWORK is issued by XERBLA. */
/* RWORK (workspace) DOUBLE PRECISION array, dimension (8*N) */
/* BWORK (workspace) LOGICAL array, dimension (N) */
/* Not referenced if SORT = 'N'. */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* =1,...,N: */
/* The QZ iteration failed. (A,B) are not in Schur */
/* form, but ALPHA(j) and BETA(j) should be correct for */
/* j=INFO+1,...,N. */
/* > N: =N+1: other than QZ iteration failed in ZHGEQZ */
/* =N+2: after reordering, roundoff changed values of */
/* some complex eigenvalues so that leading */
/* eigenvalues in the Generalized Schur form no */
/* longer satisfy SELCTG=.TRUE. This could also */
/* be caused due to scaling. */
/* =N+3: reordering falied in ZTGSEN. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Decode the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
--alpha;
--beta;
vsl_dim1 = *ldvsl;
vsl_offset = 1 + vsl_dim1;
vsl -= vsl_offset;
vsr_dim1 = *ldvsr;
vsr_offset = 1 + vsr_dim1;
vsr -= vsr_offset;
--work;
--rwork;
--bwork;
/* Function Body */
if (lsame_(jobvsl, "N")) {
ijobvl = 1;
ilvsl = FALSE;
} else if (lsame_(jobvsl, "V")) {
ijobvl = 2;
ilvsl = TRUE;
} else {
ijobvl = -1;
ilvsl = FALSE;
}
if (lsame_(jobvsr, "N")) {
ijobvr = 1;
ilvsr = FALSE;
} else if (lsame_(jobvsr, "V")) {
ijobvr = 2;
ilvsr = TRUE;
} else {
ijobvr = -1;
ilvsr = FALSE;
}
wantst = lsame_(sort, "S");
/* Test the input arguments */
*info = 0;
lquery = *lwork == -1;
if (ijobvl <= 0) {
*info = -1;
} else if (ijobvr <= 0) {
*info = -2;
} else if (! wantst && ! lsame_(sort, "N")) {
*info = -3;
} else if (*n < 0) {
*info = -5;
} else if (*lda < MAX(1,*n)) {
*info = -7;
} else if (*ldb < MAX(1,*n)) {
*info = -9;
} else if (*ldvsl < 1 || ilvsl && *ldvsl < *n) {
*info = -14;
} else if (*ldvsr < 1 || ilvsr && *ldvsr < *n) {
*info = -16;
}
/* 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.) */
if (*info == 0) {
/* Computing MAX */
i__1 = 1, i__2 = *n << 1;
lwkmin = MAX(i__1,i__2);
/* Computing MAX */
i__1 = 1, i__2 = *n + *n * ilaenv_(&c__1, "ZGEQRF", " ", n, &c__1, n,
&c__0);
lwkopt = MAX(i__1,i__2);
/* Computing MAX */
i__1 = lwkopt, i__2 = *n + *n * ilaenv_(&c__1, "ZUNMQR", " ", n, &
c__1, n, &c_n1);
lwkopt = MAX(i__1,i__2);
if (ilvsl) {
/* Computing MAX */
i__1 = lwkopt, i__2 = *n + *n * ilaenv_(&c__1, "ZUNGQR", " ", n, &
c__1, n, &c_n1);
lwkopt = MAX(i__1,i__2);
}
work[1].r = (double) lwkopt, work[1].i = 0.;
if (*lwork < lwkmin && ! lquery) {
*info = -18;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGGES ", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
*sdim = 0;
return 0;
}
/* Get machine constants */
eps = dlamch_("P");
smlnum = dlamch_("S");
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
smlnum = sqrt(smlnum) / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", n, n, &a[a_offset], lda, &rwork[1]);
ilascl = FALSE;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE;
}
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, &
ierr);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = zlange_("M", n, n, &b[b_offset], ldb, &rwork[1]);
ilbscl = FALSE;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE;
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, &
ierr);
}
/* Permute the matrix to make it more nearly triangular */
/* (Real Workspace: need 6*N) */
ileft = 1;
iright = *n + 1;
irwrk = iright + *n;
zggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &rwork[
ileft], &rwork[iright], &rwork[irwrk], &ierr);
/* Reduce B to triangular form (QR decomposition of B) */
/* (Complex Workspace: need N, prefer N*NB) */
irows = ihi + 1 - ilo;
icols = *n + 1 - ilo;
itau = 1;
iwrk = itau + irows;
i__1 = *lwork + 1 - iwrk;
zgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[
iwrk], &i__1, &ierr);
/* Apply the orthogonal transformation to matrix A */
/* (Complex Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
zunmqr_("L", "C", &irows, &icols, &irows, &b[ilo + ilo * b_dim1], ldb, &
work[itau], &a[ilo + ilo * a_dim1], lda, &work[iwrk], &i__1, &
ierr);
/* Initialize VSL */
/* (Complex Workspace: need N, prefer N*NB) */
if (ilvsl) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vsl[vsl_offset], ldvsl);
if (irows > 1) {
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vsl[
ilo + 1 + ilo * vsl_dim1], ldvsl);
}
i__1 = *lwork + 1 - iwrk;
zungqr_(&irows, &irows, &irows, &vsl[ilo + ilo * vsl_dim1], ldvsl, &
work[itau], &work[iwrk], &i__1, &ierr);
}
/* Initialize VSR */
if (ilvsr) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vsr[vsr_offset], ldvsr);
}
/* Reduce to generalized Hessenberg form */
/* (Workspace: none needed) */
zgghrd_(jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vsl[vsl_offset], ldvsl, &vsr[vsr_offset], ldvsr, &ierr);
*sdim = 0;
/* Perform QZ algorithm, computing Schur vectors if desired */
/* (Complex Workspace: need N) */
/* (Real Workspace: need N) */
iwrk = itau;
i__1 = *lwork + 1 - iwrk;
zhgeqz_("S", jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alpha[1], &beta[1], &vsl[vsl_offset], ldvsl, &
vsr[vsr_offset], ldvsr, &work[iwrk], &i__1, &rwork[irwrk], &ierr);
if (ierr != 0) {
if (ierr > 0 && ierr <= *n) {
*info = ierr;
} else if (ierr > *n && ierr <= *n << 1) {
*info = ierr - *n;
} else {
*info = *n + 1;
}
goto L30;
}
/* Sort eigenvalues ALPHA/BETA if desired */
/* (Workspace: none needed) */
if (wantst) {
/* Undo scaling on eigenvalues before selecting */
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, &c__1, &alpha[1], n,
&ierr);
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, &c__1, &beta[1], n,
&ierr);
}
/* Select eigenvalues */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
bwork[i__] = (*selctg)(&alpha[i__], &beta[i__]);
/* L10: */
}
i__1 = *lwork - iwrk + 1;
ztgsen_(&c__0, &ilvsl, &ilvsr, &bwork[1], n, &a[a_offset], lda, &b[
b_offset], ldb, &alpha[1], &beta[1], &vsl[vsl_offset], ldvsl,
&vsr[vsr_offset], ldvsr, sdim, &pvsl, &pvsr, dif, &work[iwrk],
&i__1, idum, &c__1, &ierr);
if (ierr == 1) {
*info = *n + 3;
}
}
/* Apply back-permutation to VSL and VSR */
/* (Workspace: none needed) */
if (ilvsl) {
zggbak_("P", "L", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, &
vsl[vsl_offset], ldvsl, &ierr);
}
if (ilvsr) {
zggbak_("P", "R", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, &
vsr[vsr_offset], ldvsr, &ierr);
}
/* Undo scaling */
if (ilascl) {
zlascl_("U", &c__0, &c__0, &anrmto, &anrm, n, n, &a[a_offset], lda, &
ierr);
zlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alpha[1], n, &
ierr);
}
if (ilbscl) {
zlascl_("U", &c__0, &c__0, &bnrmto, &bnrm, n, n, &b[b_offset], ldb, &
ierr);
zlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, &
ierr);
}
if (wantst) {
/* Check if reordering is correct */
lastsl = TRUE;
*sdim = 0;
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
cursl = (*selctg)(&alpha[i__], &beta[i__]);
if (cursl) {
++(*sdim);
}
if (cursl && ! lastsl) {
*info = *n + 2;
}
lastsl = cursl;
/* L20: */
}
}
L30:
work[1].r = (double) lwkopt, work[1].i = 0.;
return 0;
/* End of ZGGES */
} /* zgges_ */
/* Subroutine */ int zgels_(char *trans, integer *m, integer *n, integer *
nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb,
doublecomplex *work, integer *lwork, integer *info)
{
/* -- LAPACK driver routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
June 30, 1999
Purpose
=======
ZGELS solves overdetermined or underdetermined complex linear systems
involving an M-by-N matrix A, or its conjugate-transpose, using a QR
or LQ factorization of A. It is assumed that A has full rank.
The following options are provided:
1. If TRANS = 'N' and m >= n: find the least squares solution of
an overdetermined system, i.e., solve the least squares problem
minimize || B - A*X ||.
2. If TRANS = 'N' and m < n: find the minimum norm solution of
an underdetermined system A * X = B.
3. If TRANS = 'C' and m >= n: find the minimum norm solution of
an undetermined system A**H * X = B.
4. If TRANS = 'C' and m < n: find the least squares solution of
an overdetermined system, i.e., solve the least squares problem
minimize || B - A**H * X ||.
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.
Arguments
=========
TRANS (input) CHARACTER
= 'N': the linear system involves A;
= 'C': the linear system involves A**H.
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) COMPLEX*16 array, dimension (LDA,N)
On entry, the M-by-N matrix A.
if M >= N, A is overwritten by details of its QR
factorization as returned by ZGEQRF;
if M < N, A is overwritten by details of its LQ
factorization as returned by ZGELQF.
LDA (input) INTEGER
The leading dimension of the array A. LDA >= max(1,M).
B (input/output) COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the matrix B of right hand side vectors, stored
columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS
if TRANS = 'C'.
On exit, B is overwritten by the solution vectors, stored
columnwise:
if TRANS = 'N' and m >= n, rows 1 to n of B contain the least
squares solution vectors; the residual sum of squares for the
solution in each column is given by the sum of squares of
elements N+1 to M in that column;
if TRANS = 'N' and m < n, rows 1 to N of B contain the
minimum norm solution vectors;
if TRANS = 'C' and m >= n, rows 1 to M of B contain the
minimum norm solution vectors;
if TRANS = 'C' and m < n, rows 1 to M of B contain the
least squares solution vectors; the residual sum of squares
for the solution in each column is given by the sum of
squares of elements M+1 to N in that column.
LDB (input) INTEGER
The leading dimension of the array B. LDB >= MAX(1,M,N).
WORK (workspace/output) COMPLEX*16 array, dimension (LWORK)
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK.
LWORK >= max( 1, MN + max( MN, NRHS ) ).
For optimal performance,
LWORK >= max( 1, MN + max( MN, NRHS )*NB ).
where MN = min(M,N) and NB is the optimum block size.
If LWORK = -1, then a workspace query is assumed; the routine
only calculates the optimal size of the WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
=====================================================================
Test the input arguments.
Parameter adjustments */
/* Table of constant values */
static doublecomplex c_b1 = {0.,0.};
static doublecomplex c_b2 = {1.,0.};
static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__0 = 0;
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3;
doublereal d__1;
/* Local variables */
static doublereal anrm, bnrm;
static integer brow;
static logical tpsd;
static integer i__, j, iascl, ibscl;
extern logical lsame_(char *, char *);
static integer wsize;
static doublereal rwork[1];
extern /* Subroutine */ int ztrsm_(char *, char *, char *, char *,
integer *, integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *),
dlabad_(doublereal *, doublereal *);
static integer nb;
extern doublereal dlamch_(char *);
static integer mn;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
static integer scllen;
static doublereal bignum;
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *,
integer *, doublereal *);
extern /* Subroutine */ int zgelqf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
), zlascl_(char *, integer *, integer *, doublereal *, doublereal
*, integer *, integer *, doublecomplex *, integer *, integer *), zgeqrf_(integer *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, integer *, integer *), zlaset_(
char *, integer *, integer *, doublecomplex *, doublecomplex *,
doublecomplex *, integer *);
static doublereal smlnum;
static logical lquery;
extern /* Subroutine */ int zunmlq_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *), zunmqr_(char *, char *, integer *, integer *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *, integer *);
#define b_subscr(a_1,a_2) (a_2)*b_dim1 + a_1
#define b_ref(a_1,a_2) b[b_subscr(a_1,a_2)]
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
--work;
/* Function Body */
*info = 0;
mn = min(*m,*n);
lquery = *lwork == -1;
if (! (lsame_(trans, "N") || lsame_(trans, "C"))) {
*info = -1;
} else if (*m < 0) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*nrhs < 0) {
*info = -4;
} else if (*lda < max(1,*m)) {
*info = -6;
} else /* if(complicated condition) */ {
/* Computing MAX */
i__1 = max(1,*m);
if (*ldb < max(i__1,*n)) {
*info = -8;
} else /* if(complicated condition) */ {
/* Computing MAX */
i__1 = 1, i__2 = mn + max(mn,*nrhs);
if (*lwork < max(i__1,i__2) && ! lquery) {
*info = -10;
}
}
}
/* Figure out optimal block size */
if (*info == 0 || *info == -10) {
tpsd = TRUE_;
if (lsame_(trans, "N")) {
tpsd = FALSE_;
}
if (*m >= *n) {
nb = ilaenv_(&c__1, "ZGEQRF", " ", m, n, &c_n1, &c_n1, (ftnlen)6,
(ftnlen)1);
if (tpsd) {
/* Computing MAX */
i__1 = nb, i__2 = ilaenv_(&c__1, "ZUNMQR", "LN", m, nrhs, n, &
c_n1, (ftnlen)6, (ftnlen)2);
nb = max(i__1,i__2);
} else {
/* Computing MAX */
i__1 = nb, i__2 = ilaenv_(&c__1, "ZUNMQR", "LC", m, nrhs, n, &
c_n1, (ftnlen)6, (ftnlen)2);
nb = max(i__1,i__2);
}
} else {
nb = ilaenv_(&c__1, "ZGELQF", " ", m, n, &c_n1, &c_n1, (ftnlen)6,
(ftnlen)1);
if (tpsd) {
/* Computing MAX */
i__1 = nb, i__2 = ilaenv_(&c__1, "ZUNMLQ", "LC", n, nrhs, m, &
c_n1, (ftnlen)6, (ftnlen)2);
nb = max(i__1,i__2);
} else {
/* Computing MAX */
i__1 = nb, i__2 = ilaenv_(&c__1, "ZUNMLQ", "LN", n, nrhs, m, &
c_n1, (ftnlen)6, (ftnlen)2);
nb = max(i__1,i__2);
}
}
/* Computing MAX */
i__1 = 1, i__2 = mn + max(mn,*nrhs) * nb;
wsize = max(i__1,i__2);
d__1 = (doublereal) wsize;
work[1].r = d__1, work[1].i = 0.;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGELS ", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible
Computing MIN */
i__1 = min(*m,*n);
if (min(i__1,*nrhs) == 0) {
i__1 = max(*m,*n);
zlaset_("Full", &i__1, nrhs, &c_b1, &c_b1, &b[b_offset], ldb);
return 0;
}
/* Get machine parameters */
smlnum = dlamch_("S") / dlamch_("P");
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
/* Scale A, B if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", m, n, &a[a_offset], lda, rwork);
iascl = 0;
if (anrm > 0. && anrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
zlascl_("G", &c__0, &c__0, &anrm, &smlnum, m, n, &a[a_offset], lda,
info);
iascl = 1;
} else if (anrm > bignum) {
/* Scale matrix norm down to BIGNUM */
zlascl_("G", &c__0, &c__0, &anrm, &bignum, m, n, &a[a_offset], lda,
info);
iascl = 2;
} else if (anrm == 0.) {
/* Matrix all zero. Return zero solution. */
i__1 = max(*m,*n);
zlaset_("F", &i__1, nrhs, &c_b1, &c_b1, &b[b_offset], ldb);
goto L50;
}
brow = *m;
if (tpsd) {
brow = *n;
}
bnrm = zlange_("M", &brow, nrhs, &b[b_offset], ldb, rwork);
ibscl = 0;
if (bnrm > 0. && bnrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
zlascl_("G", &c__0, &c__0, &bnrm, &smlnum, &brow, nrhs, &b[b_offset],
ldb, info);
ibscl = 1;
} else if (bnrm > bignum) {
/* Scale matrix norm down to BIGNUM */
zlascl_("G", &c__0, &c__0, &bnrm, &bignum, &brow, nrhs, &b[b_offset],
ldb, info);
ibscl = 2;
}
if (*m >= *n) {
/* compute QR factorization of A */
i__1 = *lwork - mn;
zgeqrf_(m, n, &a[a_offset], lda, &work[1], &work[mn + 1], &i__1, info)
;
/* workspace at least N, optimally N*NB */
if (! tpsd) {
/* Least-Squares Problem min || A * X - B ||
B(1:M,1:NRHS) := Q' * B(1:M,1:NRHS) */
i__1 = *lwork - mn;
zunmqr_("Left", "Conjugate transpose", m, nrhs, n, &a[a_offset],
lda, &work[1], &b[b_offset], ldb, &work[mn + 1], &i__1,
info);
/* workspace at least NRHS, optimally NRHS*NB
B(1:N,1:NRHS) := inv(R) * B(1:N,1:NRHS) */
ztrsm_("Left", "Upper", "No transpose", "Non-unit", n, nrhs, &
c_b2, &a[a_offset], lda, &b[b_offset], ldb);
scllen = *n;
} else {
/* Overdetermined system of equations A' * X = B
B(1:N,1:NRHS) := inv(R') * B(1:N,1:NRHS) */
ztrsm_("Left", "Upper", "Conjugate transpose", "Non-unit", n,
nrhs, &c_b2, &a[a_offset], lda, &b[b_offset], ldb);
/* B(N+1:M,1:NRHS) = ZERO */
i__1 = *nrhs;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = *n + 1; i__ <= i__2; ++i__) {
i__3 = b_subscr(i__, j);
b[i__3].r = 0., b[i__3].i = 0.;
/* L10: */
}
/* L20: */
}
/* B(1:M,1:NRHS) := Q(1:N,:) * B(1:N,1:NRHS) */
i__1 = *lwork - mn;
zunmqr_("Left", "No transpose", m, nrhs, n, &a[a_offset], lda, &
work[1], &b[b_offset], ldb, &work[mn + 1], &i__1, info);
/* workspace at least NRHS, optimally NRHS*NB */
scllen = *m;
}
} else {
/* Compute LQ factorization of A */
i__1 = *lwork - mn;
zgelqf_(m, n, &a[a_offset], lda, &work[1], &work[mn + 1], &i__1, info)
;
/* workspace at least M, optimally M*NB. */
if (! tpsd) {
/* underdetermined system of equations A * X = B
B(1:M,1:NRHS) := inv(L) * B(1:M,1:NRHS) */
ztrsm_("Left", "Lower", "No transpose", "Non-unit", m, nrhs, &
c_b2, &a[a_offset], lda, &b[b_offset], ldb);
/* B(M+1:N,1:NRHS) = 0 */
i__1 = *nrhs;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = *m + 1; i__ <= i__2; ++i__) {
i__3 = b_subscr(i__, j);
b[i__3].r = 0., b[i__3].i = 0.;
/* L30: */
}
/* L40: */
}
/* B(1:N,1:NRHS) := Q(1:N,:)' * B(1:M,1:NRHS) */
i__1 = *lwork - mn;
zunmlq_("Left", "Conjugate transpose", n, nrhs, m, &a[a_offset],
lda, &work[1], &b[b_offset], ldb, &work[mn + 1], &i__1,
info);
/* workspace at least NRHS, optimally NRHS*NB */
scllen = *n;
} else {
/* overdetermined system min || A' * X - B ||
B(1:N,1:NRHS) := Q * B(1:N,1:NRHS) */
i__1 = *lwork - mn;
zunmlq_("Left", "No transpose", n, nrhs, m, &a[a_offset], lda, &
work[1], &b[b_offset], ldb, &work[mn + 1], &i__1, info);
/* workspace at least NRHS, optimally NRHS*NB
B(1:M,1:NRHS) := inv(L') * B(1:M,1:NRHS) */
ztrsm_("Left", "Lower", "Conjugate transpose", "Non-unit", m,
nrhs, &c_b2, &a[a_offset], lda, &b[b_offset], ldb);
scllen = *m;
}
}
/* Undo scaling */
if (iascl == 1) {
zlascl_("G", &c__0, &c__0, &anrm, &smlnum, &scllen, nrhs, &b[b_offset]
, ldb, info);
} else if (iascl == 2) {
zlascl_("G", &c__0, &c__0, &anrm, &bignum, &scllen, nrhs, &b[b_offset]
, ldb, info);
}
if (ibscl == 1) {
zlascl_("G", &c__0, &c__0, &smlnum, &bnrm, &scllen, nrhs, &b[b_offset]
, ldb, info);
} else if (ibscl == 2) {
zlascl_("G", &c__0, &c__0, &bignum, &bnrm, &scllen, nrhs, &b[b_offset]
, ldb, info);
}
L50:
d__1 = (doublereal) wsize;
work[1].r = d__1, work[1].i = 0.;
return 0;
/* End of ZGELS */
} /* zgels_ */
/* Subroutine */ int zggrqf_(integer *m, integer *p, integer *n,
doublecomplex *a, integer *lda, doublecomplex *taua, doublecomplex *b,
integer *ldb, doublecomplex *taub, doublecomplex *work, integer *
lwork, integer *info)
{
/* -- LAPACK 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
=======
ZGGRQF computes a generalized RQ factorization of an M-by-N matrix A
and a P-by-N matrix B:
A = R*Q, B = Z*T*Q,
where Q is an N-by-N unitary matrix, Z is a P-by-P unitary
matrix, and R and T assume one of the forms:
if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N,
N-M M ( R21 ) N
N
where R12 or R21 is upper triangular, and
if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P,
( 0 ) P-N P N-P
N
where T11 is upper triangular.
In particular, if B is square and nonsingular, the GRQ factorization
of A and B implicitly gives the RQ factorization of A*inv(B):
A*inv(B) = (R*inv(T))*Z'
where inv(B) denotes the inverse of the matrix B, and Z' denotes the
conjugate transpose of the matrix Z.
Arguments
=========
M (input) INTEGER
The number of rows of the matrix A. M >= 0.
P (input) INTEGER
The number of rows of the matrix B. P >= 0.
N (input) INTEGER
The number of columns of the matrices A and B. N >= 0.
A (input/output) COMPLEX*16 array, dimension (LDA,N)
On entry, the M-by-N matrix A.
On exit, if M <= N, the upper triangle of the subarray
A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R;
if M > N, the elements on and above the (M-N)-th subdiagonal
contain the M-by-N upper trapezoidal matrix R; the remaining
elements, with the array TAUA, represent the unitary
matrix Q as a product of elementary reflectors (see Further
Details).
LDA (input) INTEGER
The leading dimension of the array A. LDA >= max(1,M).
TAUA (output) COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors which
represent the unitary matrix Q (see Further Details).
B (input/output) COMPLEX*16 array, dimension (LDB,N)
On entry, the P-by-N matrix B.
On exit, the elements on and above the diagonal of the array
contain the min(P,N)-by-N upper trapezoidal matrix T (T is
upper triangular if P >= N); the elements below the diagonal,
with the array TAUB, represent the unitary matrix Z as a
product of elementary reflectors (see Further Details).
LDB (input) INTEGER
The leading dimension of the array B. LDB >= max(1,P).
TAUB (output) COMPLEX*16 array, dimension (min(P,N))
The scalar factors of the elementary reflectors which
represent the unitary matrix Z (see Further Details).
WORK (workspace/output) COMPLEX*16 array, dimension (LWORK)
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK. LWORK >= max(1,N,M,P).
For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),
where NB1 is the optimal blocksize for the RQ factorization
of an M-by-N matrix, NB2 is the optimal blocksize for the
QR factorization of a P-by-N matrix, and NB3 is the optimal
blocksize for a call of ZUNMRQ.
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO=-i, the i-th argument had an illegal value.
Further Details
===============
The matrix Q is represented as a product of elementary reflectors
Q = H(1) H(2) . . . H(k), where k = min(m,n).
Each H(i) has the form
H(i) = I - taua * v * v'
where taua is a complex scalar, and v is a complex vector with
v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
A(m-k+i,1:n-k+i-1), and taua in TAUA(i).
To form Q explicitly, use LAPACK subroutine ZUNGRQ.
To use Q to update another matrix, use LAPACK subroutine ZUNMRQ.
The matrix Z is represented as a product of elementary reflectors
Z = H(1) H(2) . . . H(k), where k = min(p,n).
Each H(i) has the form
H(i) = I - taub * v * v'
where taub is a complex scalar, and v is a complex vector with
v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i),
and taub in TAUB(i).
To form Z explicitly, use LAPACK subroutine ZUNGQR.
To use Z to update another matrix, use LAPACK subroutine ZUNMQR.
=====================================================================
Test the input parameters
Parameter adjustments
Function Body */
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3;
doublereal d__1;
/* Local variables */
static integer lopt;
extern /* Subroutine */ int xerbla_(char *, integer *), zgeqrf_(
integer *, integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, integer *), zgerqf_(integer *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublecomplex *, integer *, integer *), zunmrq_(char *, char *,
integer *, integer *, integer *, doublecomplex *, integer *,
doublecomplex *, doublecomplex *, integer *, doublecomplex *,
integer *, integer *);
#define TAUA(I) taua[(I)-1]
#define TAUB(I) taub[(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;
if (*m < 0) {
*info = -1;
} else if (*p < 0) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*lda < max(1,*m)) {
*info = -5;
} else if (*ldb < max(1,*p)) {
*info = -8;
} else /* if(complicated condition) */ {
/* Computing MAX */
i__1 = max(1,*m), i__1 = max(i__1,*p);
if (*lwork < max(i__1,*n)) {
*info = -11;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGGRQF", &i__1);
return 0;
}
/* RQ factorization of M-by-N matrix A: A = R*Q */
zgerqf_(m, n, &A(1,1), lda, &TAUA(1), &WORK(1), lwork, info);
lopt = (integer) WORK(1).r;
/* Update B := B*Q' */
i__1 = min(*m,*n);
/* Computing MAX */
i__2 = 1, i__3 = *m - *n + 1;
zunmrq_("Right", "Conjugate Transpose", p, n, &i__1, &A(max(1,*m-*n+1),1), lda, &TAUA(1), &B(1,1), ldb, &WORK(1), lwork, info);
/* Computing MAX */
i__1 = lopt, i__2 = (integer) WORK(1).r;
lopt = max(i__1,i__2);
/* QR factorization of P-by-N matrix B: B = Z*T */
zgeqrf_(p, n, &B(1,1), ldb, &TAUB(1), &WORK(1), lwork, info);
/* Computing MAX */
i__1 = lopt, i__2 = (integer) WORK(1).r;
d__1 = (doublereal) max(i__1,i__2);
WORK(1).r = d__1, WORK(1).i = 0.;
return 0;
/* End of ZGGRQF */
} /* zggrqf_ */
/* Subroutine */ int zqrt01_(integer *m, integer *n, doublecomplex *a,
doublecomplex *af, doublecomplex *q, doublecomplex *r__, integer *lda,
doublecomplex *tau, doublecomplex *work, integer *lwork, doublereal *
rwork, doublereal *result)
{
/* System generated locals */
integer a_dim1, a_offset, af_dim1, af_offset, q_dim1, q_offset, r_dim1,
r_offset, i__1;
/* Builtin functions */
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
/* Local variables */
doublereal eps;
integer info;
doublereal resid, anorm;
integer minmn;
extern /* Subroutine */ int zgemm_(char *, char *, integer *, integer *,
integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *), zherk_(char *, char *, integer *,
integer *, doublereal *, doublecomplex *, integer *, doublereal *,
doublecomplex *, integer *);
extern doublereal dlamch_(char *), zlange_(char *, integer *,
integer *, doublecomplex *, integer *, doublereal *);
extern /* Subroutine */ int zgeqrf_(integer *, integer *, doublecomplex *,
integer *, doublecomplex *, doublecomplex *, integer *, integer *
), zlacpy_(char *, integer *, integer *, doublecomplex *, integer
*, doublecomplex *, integer *), zlaset_(char *, integer *,
integer *, doublecomplex *, doublecomplex *, doublecomplex *,
integer *);
extern doublereal zlansy_(char *, char *, integer *, doublecomplex *,
integer *, doublereal *);
extern /* Subroutine */ int zungqr_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *);
/* -- LAPACK test routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZQRT01 tests ZGEQRF, which computes the QR factorization of an m-by-n */
/* matrix A, and partially tests ZUNGQR which forms the m-by-m */
/* orthogonal matrix Q. */
/* ZQRT01 compares R with Q'*A, and checks that Q is orthogonal. */
/* 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. */
/* A (input) COMPLEX*16 array, dimension (LDA,N) */
/* The m-by-n matrix A. */
/* AF (output) COMPLEX*16 array, dimension (LDA,N) */
/* Details of the QR factorization of A, as returned by ZGEQRF. */
/* See ZGEQRF for further details. */
/* Q (output) COMPLEX*16 array, dimension (LDA,M) */
/* The m-by-m orthogonal matrix Q. */
/* R (workspace) COMPLEX*16 array, dimension (LDA,max(M,N)) */
/* LDA (input) INTEGER */
/* The leading dimension of the arrays A, AF, Q and R. */
/* LDA >= max(M,N). */
/* TAU (output) COMPLEX*16 array, dimension (min(M,N)) */
/* The scalar factors of the elementary reflectors, as returned */
/* by ZGEQRF. */
/* WORK (workspace) COMPLEX*16 array, dimension (LWORK) */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. */
/* RWORK (workspace) DOUBLE PRECISION array, dimension (M) */
/* RESULT (output) DOUBLE PRECISION array, dimension (2) */
/* The test ratios: */
/* RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS ) */
/* RESULT(2) = norm( I - Q'*Q ) / ( M * EPS ) */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Scalars in Common .. */
/* .. */
/* .. Common blocks .. */
/* .. */
/* .. Executable Statements .. */
/* Parameter adjustments */
r_dim1 = *lda;
r_offset = 1 + r_dim1;
r__ -= r_offset;
q_dim1 = *lda;
q_offset = 1 + q_dim1;
q -= q_offset;
af_dim1 = *lda;
af_offset = 1 + af_dim1;
af -= af_offset;
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--tau;
--work;
--rwork;
--result;
/* Function Body */
minmn = min(*m,*n);
eps = dlamch_("Epsilon");
/* Copy the matrix A to the array AF. */
zlacpy_("Full", m, n, &a[a_offset], lda, &af[af_offset], lda);
/* Factorize the matrix A in the array AF. */
s_copy(srnamc_1.srnamt, "ZGEQRF", (ftnlen)6, (ftnlen)6);
zgeqrf_(m, n, &af[af_offset], lda, &tau[1], &work[1], lwork, &info);
/* Copy details of Q */
zlaset_("Full", m, m, &c_b1, &c_b1, &q[q_offset], lda);
i__1 = *m - 1;
zlacpy_("Lower", &i__1, n, &af[af_dim1 + 2], lda, &q[q_dim1 + 2], lda);
/* Generate the m-by-m matrix Q */
s_copy(srnamc_1.srnamt, "ZUNGQR", (ftnlen)6, (ftnlen)6);
zungqr_(m, m, &minmn, &q[q_offset], lda, &tau[1], &work[1], lwork, &info);
/* Copy R */
zlaset_("Full", m, n, &c_b10, &c_b10, &r__[r_offset], lda);
zlacpy_("Upper", m, n, &af[af_offset], lda, &r__[r_offset], lda);
/* Compute R - Q'*A */
zgemm_("Conjugate transpose", "No transpose", m, n, m, &c_b15, &q[
q_offset], lda, &a[a_offset], lda, &c_b16, &r__[r_offset], lda);
/* Compute norm( R - Q'*A ) / ( M * norm(A) * EPS ) . */
anorm = zlange_("1", m, n, &a[a_offset], lda, &rwork[1]);
resid = zlange_("1", m, n, &r__[r_offset], lda, &rwork[1]);
if (anorm > 0.) {
result[1] = resid / (doublereal) max(1,*m) / anorm / eps;
} else {
result[1] = 0.;
}
/* Compute I - Q'*Q */
zlaset_("Full", m, m, &c_b10, &c_b16, &r__[r_offset], lda);
zherk_("Upper", "Conjugate transpose", m, m, &c_b24, &q[q_offset], lda, &
c_b25, &r__[r_offset], lda);
/* Compute norm( I - Q'*Q ) / ( M * EPS ) . */
resid = zlansy_("1", "Upper", m, &r__[r_offset], lda, &rwork[1]);
result[2] = resid / (doublereal) max(1,*m) / eps;
return 0;
/* End of ZQRT01 */
} /* zqrt01_ */
/* Subroutine */ int zggevx_(char *balanc, char *jobvl, char *jobvr, char *
sense, integer *n, doublecomplex *a, integer *lda, doublecomplex *b,
integer *ldb, doublecomplex *alpha, doublecomplex *beta,
doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr,
integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale,
doublereal *abnrm, doublereal *bbnrm, doublereal *rconde, doublereal *
rcondv, doublecomplex *work, integer *lwork, doublereal *rwork,
integer *iwork, logical *bwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vl_dim1, vl_offset, vr_dim1,
vr_offset, i__1, i__2, i__3, i__4;
doublereal d__1, d__2, d__3, d__4;
doublecomplex z__1;
/* Local variables */
integer i__, j, m, jc, in, jr;
doublereal eps;
logical ilv;
doublereal anrm, bnrm;
integer ierr, itau;
doublereal temp;
logical ilvl, ilvr;
integer iwrk, iwrk1;
integer icols;
logical noscl;
integer irows;
logical ilascl, ilbscl;
logical ldumma[1];
char chtemp[1];
doublereal bignum;
integer ijobvl;
integer ijobvr;
logical wantsb;
doublereal anrmto;
logical wantse;
doublereal bnrmto;
integer minwrk;
integer maxwrk;
logical wantsn;
doublereal smlnum;
logical lquery, wantsv;
/* -- LAPACK driver routine (version 3.2) -- */
/* November 2006 */
/* Purpose */
/* ======= */
/* ZGGEVX computes for a pair of N-by-N complex nonsymmetric matrices */
/* (A,B) the generalized eigenvalues, and optionally, the left and/or */
/* right generalized eigenvectors. */
/* Optionally, it also computes a balancing transformation to improve */
/* the conditioning of the eigenvalues and eigenvectors (ILO, IHI, */
/* LSCALE, RSCALE, ABNRM, and BBNRM), reciprocal condition numbers for */
/* the eigenvalues (RCONDE), and reciprocal condition numbers for the */
/* right eigenvectors (RCONDV). */
/* A generalized eigenvalue for a pair of matrices (A,B) is a scalar */
/* lambda or a ratio alpha/beta = lambda, such that A - lambda*B is */
/* singular. It is usually represented as the pair (alpha,beta), as */
/* there is a reasonable interpretation for beta=0, and even for both */
/* being zero. */
/* The right eigenvector v(j) corresponding to the eigenvalue lambda(j) */
/* of (A,B) satisfies */
/* A * v(j) = lambda(j) * B * v(j) . */
/* The left eigenvector u(j) corresponding to the eigenvalue lambda(j) */
/* of (A,B) satisfies */
/* u(j)**H * A = lambda(j) * u(j)**H * B. */
/* where u(j)**H is the conjugate-transpose of u(j). */
/* Arguments */
/* ========= */
/* BALANC (input) CHARACTER*1 */
/* Specifies the balance option to be performed: */
/* = 'N': do not diagonally scale or permute; */
/* = 'P': permute only; */
/* = 'S': scale only; */
/* = 'B': both permute and scale. */
/* Computed reciprocal condition numbers will be for the */
/* matrices after permuting and/or balancing. Permuting does */
/* not change condition numbers (in exact arithmetic), but */
/* balancing does. */
/* JOBVL (input) CHARACTER*1 */
/* = 'N': do not compute the left generalized eigenvectors; */
/* = 'V': compute the left generalized eigenvectors. */
/* JOBVR (input) CHARACTER*1 */
/* = 'N': do not compute the right generalized eigenvectors; */
/* = 'V': compute the right generalized eigenvectors. */
/* SENSE (input) CHARACTER*1 */
/* Determines which reciprocal condition numbers are computed. */
/* = 'N': none are computed; */
/* = 'E': computed for eigenvalues only; */
/* = 'V': computed for eigenvectors only; */
/* = 'B': computed for eigenvalues and eigenvectors. */
/* N (input) INTEGER */
/* The order of the matrices A, B, VL, and VR. N >= 0. */
/* A (input/output) COMPLEX*16 array, dimension (LDA, N) */
/* On entry, the matrix A in the pair (A,B). */
/* On exit, A has been overwritten. If JOBVL='V' or JOBVR='V' */
/* or both, then A contains the first part of the complex Schur */
/* form of the "balanced" versions of the input A and B. */
/* LDA (input) INTEGER */
/* The leading dimension of A. LDA >= max(1,N). */
/* B (input/output) COMPLEX*16 array, dimension (LDB, N) */
/* On entry, the matrix B in the pair (A,B). */
/* On exit, B has been overwritten. If JOBVL='V' or JOBVR='V' */
/* or both, then B contains the second part of the complex */
/* Schur form of the "balanced" versions of the input A and B. */
/* LDB (input) INTEGER */
/* The leading dimension of B. LDB >= max(1,N). */
/* ALPHA (output) COMPLEX*16 array, dimension (N) */
/* BETA (output) COMPLEX*16 array, dimension (N) */
/* eigenvalues. */
/* Note: the quotient ALPHA(j)/BETA(j) ) may easily over- or */
/* underflow, and BETA(j) may even be zero. Thus, the user */
/* should avoid naively computing the ratio ALPHA/BETA. */
/* However, ALPHA will be always less than and usually */
/* comparable with norm(A) in magnitude, and BETA always less */
/* than and usually comparable with norm(B). */
/* VL (output) COMPLEX*16 array, dimension (LDVL,N) */
/* If JOBVL = 'V', the left generalized eigenvectors u(j) are */
/* stored one after another in the columns of VL, in the same */
/* order as their eigenvalues. */
/* Each eigenvector will be scaled so the largest component */
/* will have abs(real part) + abs(imag. part) = 1. */
/* Not referenced if JOBVL = 'N'. */
/* LDVL (input) INTEGER */
/* The leading dimension of the matrix VL. LDVL >= 1, and */
/* if JOBVL = 'V', LDVL >= N. */
/* VR (output) COMPLEX*16 array, dimension (LDVR,N) */
/* If JOBVR = 'V', the right generalized eigenvectors v(j) are */
/* stored one after another in the columns of VR, in the same */
/* order as their eigenvalues. */
/* Each eigenvector will be scaled so the largest component */
/* will have abs(real part) + abs(imag. part) = 1. */
/* Not referenced if JOBVR = 'N'. */
/* LDVR (input) INTEGER */
/* The leading dimension of the matrix VR. LDVR >= 1, and */
/* if JOBVR = 'V', LDVR >= N. */
/* ILO (output) INTEGER */
/* IHI (output) INTEGER */
/* ILO and IHI are integer values such that on exit */
/* A(i,j) = 0 and B(i,j) = 0 if i > j and */
/* If BALANC = 'N' or 'S', ILO = 1 and IHI = N. */
/* LSCALE (output) DOUBLE PRECISION array, dimension (N) */
/* Details of the permutations and scaling factors applied */
/* to the left side of A and B. If PL(j) is the index of the */
/* row interchanged with row j, and DL(j) is the scaling */
/* factor applied to row j, then */
/* The order in which the interchanges are made is N to IHI+1, */
/* then 1 to ILO-1. */
/* RSCALE (output) DOUBLE PRECISION array, dimension (N) */
/* Details of the permutations and scaling factors applied */
/* to the right side of A and B. If PR(j) is the index of the */
/* column interchanged with column j, and DR(j) is the scaling */
/* factor applied to column j, then */
/* The order in which the interchanges are made is N to IHI+1, */
/* then 1 to ILO-1. */
/* ABNRM (output) DOUBLE PRECISION */
/* The one-norm of the balanced matrix A. */
/* BBNRM (output) DOUBLE PRECISION */
/* The one-norm of the balanced matrix B. */
/* RCONDE (output) DOUBLE PRECISION array, dimension (N) */
/* If SENSE = 'E' or 'B', the reciprocal condition numbers of */
/* the eigenvalues, stored in consecutive elements of the array. */
/* If SENSE = 'N' or 'V', RCONDE is not referenced. */
/* RCONDV (output) DOUBLE PRECISION array, dimension (N) */
/* If JOB = 'V' or 'B', the estimated reciprocal condition */
/* numbers of the eigenvectors, stored in consecutive elements */
/* of the array. If the eigenvalues cannot be reordered to */
/* compute RCONDV(j), RCONDV(j) is set to 0; this can only occur */
/* when the true value would be very small anyway. */
/* If SENSE = 'N' or 'E', RCONDV is not referenced. */
/* WORK (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= max(1,2*N). */
/* If SENSE = 'E', LWORK >= max(1,4*N). */
/* If SENSE = 'V' or 'B', LWORK >= max(1,2*N*N+2*N). */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the WORK array, returns */
/* this value as the first entry of the WORK array, and no error */
/* message related to LWORK is issued by XERBLA. */
/* RWORK (workspace) REAL array, dimension (lrwork) */
/* lrwork must be at least max(1,6*N) if BALANC = 'S' or 'B', */
/* and at least max(1,2*N) otherwise. */
/* Real workspace. */
/* IWORK (workspace) INTEGER array, dimension (N+2) */
/* If SENSE = 'E', IWORK is not referenced. */
/* BWORK (workspace) LOGICAL array, dimension (N) */
/* If SENSE = 'N', BWORK is not referenced. */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* The QZ iteration failed. No eigenvectors have been */
/* calculated, but ALPHA(j) and BETA(j) should be correct */
/* > N: =N+1: other than QZ iteration failed in ZHGEQZ. */
/* =N+2: error return from ZTGEVC. */
/* Further Details */
/* =============== */
/* Balancing a matrix pair (A,B) includes, first, permuting rows and */
/* columns to isolate eigenvalues, second, applying diagonal similarity */
/* transformation to the rows and columns to make the rows and columns */
/* as close in norm as possible. The computed reciprocal condition */
/* numbers correspond to the balanced matrix. Permuting rows and columns */
/* will not change the condition numbers (in exact arithmetic) but */
/* diagonal scaling will. For further explanation of balancing, see */
/* section 4.11.1.2 of LAPACK Users' Guide. */
/* An approximate error bound on the chordal distance between the i-th */
/* computed generalized eigenvalue w and the corresponding exact */
/* eigenvalue lambda is */
/* chord(w, lambda) <= EPS * norm(ABNRM, BBNRM) / RCONDE(I) */
/* An approximate error bound for the angle between the i-th computed */
/* eigenvector VL(i) or VR(i) is given by */
/* EPS * norm(ABNRM, BBNRM) / DIF(i). */
/* For further explanation of the reciprocal condition numbers RCONDE */
/* and RCONDV, see section 4.11 of LAPACK User's Guide. */
/* Decode the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
--alpha;
--beta;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1;
vr -= vr_offset;
--lscale;
--rscale;
--rconde;
--rcondv;
--work;
--rwork;
--iwork;
--bwork;
/* Function Body */
if (lsame_(jobvl, "N")) {
ijobvl = 1;
ilvl = FALSE_;
} else if (lsame_(jobvl, "V")) {
ijobvl = 2;
ilvl = TRUE_;
} else {
ijobvl = -1;
ilvl = FALSE_;
}
if (lsame_(jobvr, "N")) {
ijobvr = 1;
ilvr = FALSE_;
} else if (lsame_(jobvr, "V")) {
ijobvr = 2;
ilvr = TRUE_;
} else {
ijobvr = -1;
ilvr = FALSE_;
}
ilv = ilvl || ilvr;
noscl = lsame_(balanc, "N") || lsame_(balanc, "P");
wantsn = lsame_(sense, "N");
wantse = lsame_(sense, "E");
wantsv = lsame_(sense, "V");
wantsb = lsame_(sense, "B");
/* Test the input arguments */
*info = 0;
lquery = *lwork == -1;
if (! (noscl || lsame_(balanc, "S") || lsame_(
balanc, "B"))) {
*info = -1;
} else if (ijobvl <= 0) {
*info = -2;
} else if (ijobvr <= 0) {
*info = -3;
} else if (! (wantsn || wantse || wantsb || wantsv)) {
*info = -4;
} else if (*n < 0) {
*info = -5;
} else if (*lda < max(1,*n)) {
*info = -7;
} else if (*ldb < max(1,*n)) {
*info = -9;
} else if (*ldvl < 1 || ilvl && *ldvl < *n) {
*info = -13;
} else if (*ldvr < 1 || ilvr && *ldvr < *n) {
*info = -15;
}
/* 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. The workspace is */
/* computed assuming ILO = 1 and IHI = N, the worst case.) */
if (*info == 0) {
if (*n == 0) {
minwrk = 1;
maxwrk = 1;
} else {
minwrk = *n << 1;
if (wantse) {
minwrk = *n << 2;
} else if (wantsv || wantsb) {
minwrk = (*n << 1) * (*n + 1);
}
maxwrk = minwrk;
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *n * ilaenv_(&c__1, "ZGEQRF", " ", n, &
c__1, n, &c__0);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *n * ilaenv_(&c__1, "ZUNMQR", " ", n, &
c__1, n, &c__0);
maxwrk = max(i__1,i__2);
if (ilvl) {
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *n * ilaenv_(&c__1, "ZUNGQR",
" ", n, &c__1, n, &c__0);
maxwrk = max(i__1,i__2);
}
}
work[1].r = (doublereal) maxwrk, work[1].i = 0.;
if (*lwork < minwrk && ! lquery) {
*info = -25;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZGGEVX", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Get machine constants */
eps = dlamch_("P");
smlnum = dlamch_("S");
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
smlnum = sqrt(smlnum) / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", n, n, &a[a_offset], lda, &rwork[1]);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE_;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, &
ierr);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = zlange_("M", n, n, &b[b_offset], ldb, &rwork[1]);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE_;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, &
ierr);
}
/* Permute and/or balance the matrix pair (A,B) */
/* (Real Workspace: need 6*N if BALANC = 'S' or 'B', 1 otherwise) */
zggbal_(balanc, n, &a[a_offset], lda, &b[b_offset], ldb, ilo, ihi, &
lscale[1], &rscale[1], &rwork[1], &ierr);
/* Compute ABNRM and BBNRM */
*abnrm = zlange_("1", n, n, &a[a_offset], lda, &rwork[1]);
if (ilascl) {
rwork[1] = *abnrm;
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, &c__1, &c__1, &rwork[1], &
c__1, &ierr);
*abnrm = rwork[1];
}
*bbnrm = zlange_("1", n, n, &b[b_offset], ldb, &rwork[1]);
if (ilbscl) {
rwork[1] = *bbnrm;
dlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, &c__1, &c__1, &rwork[1], &
c__1, &ierr);
*bbnrm = rwork[1];
}
/* Reduce B to triangular form (QR decomposition of B) */
/* (Complex Workspace: need N, prefer N*NB ) */
irows = *ihi + 1 - *ilo;
if (ilv || ! wantsn) {
icols = *n + 1 - *ilo;
} else {
icols = irows;
}
itau = 1;
iwrk = itau + irows;
i__1 = *lwork + 1 - iwrk;
zgeqrf_(&irows, &icols, &b[*ilo + *ilo * b_dim1], ldb, &work[itau], &work[
iwrk], &i__1, &ierr);
/* Apply the unitary transformation to A */
/* (Complex Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
zunmqr_("L", "C", &irows, &icols, &irows, &b[*ilo + *ilo * b_dim1], ldb, &
work[itau], &a[*ilo + *ilo * a_dim1], lda, &work[iwrk], &i__1, &
ierr);
/* Initialize VL and/or VR */
/* (Workspace: need N, prefer N*NB) */
if (ilvl) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vl[vl_offset], ldvl);
if (irows > 1) {
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &b[*ilo + 1 + *ilo * b_dim1], ldb, &vl[
*ilo + 1 + *ilo * vl_dim1], ldvl);
}
i__1 = *lwork + 1 - iwrk;
zungqr_(&irows, &irows, &irows, &vl[*ilo + *ilo * vl_dim1], ldvl, &
work[itau], &work[iwrk], &i__1, &ierr);
}
if (ilvr) {
zlaset_("Full", n, n, &c_b1, &c_b2, &vr[vr_offset], ldvr);
}
/* Reduce to generalized Hessenberg form */
/* (Workspace: none needed) */
if (ilv || ! wantsn) {
/* Eigenvectors requested -- work on whole matrix. */
zgghrd_(jobvl, jobvr, n, ilo, ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, &ierr);
} else {
zgghrd_("N", "N", &irows, &c__1, &irows, &a[*ilo + *ilo * a_dim1],
lda, &b[*ilo + *ilo * b_dim1], ldb, &vl[vl_offset], ldvl, &vr[
vr_offset], ldvr, &ierr);
}
/* Perform QZ algorithm (Compute eigenvalues, and optionally, the */
/* Schur forms and Schur vectors) */
/* (Complex Workspace: need N) */
/* (Real Workspace: need N) */
iwrk = itau;
if (ilv || ! wantsn) {
*(unsigned char *)chtemp = 'S';
} else {
*(unsigned char *)chtemp = 'E';
}
i__1 = *lwork + 1 - iwrk;
zhgeqz_(chtemp, jobvl, jobvr, n, ilo, ihi, &a[a_offset], lda, &b[b_offset]
, ldb, &alpha[1], &beta[1], &vl[vl_offset], ldvl, &vr[vr_offset],
ldvr, &work[iwrk], &i__1, &rwork[1], &ierr);
if (ierr != 0) {
if (ierr > 0 && ierr <= *n) {
*info = ierr;
} else if (ierr > *n && ierr <= *n << 1) {
*info = ierr - *n;
} else {
*info = *n + 1;
}
goto L90;
}
/* Compute Eigenvectors and estimate condition numbers if desired */
/* ZTGEVC: (Complex Workspace: need 2*N ) */
/* (Real Workspace: need 2*N ) */
/* ZTGSNA: (Complex Workspace: need 2*N*N if SENSE='V' or 'B') */
/* (Integer Workspace: need N+2 ) */
if (ilv || ! wantsn) {
if (ilv) {
if (ilvl) {
if (ilvr) {
*(unsigned char *)chtemp = 'B';
} else {
*(unsigned char *)chtemp = 'L';
}
} else {
*(unsigned char *)chtemp = 'R';
}
ztgevc_(chtemp, "B", ldumma, n, &a[a_offset], lda, &b[b_offset],
ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, n, &in, &
work[iwrk], &rwork[1], &ierr);
if (ierr != 0) {
*info = *n + 2;
goto L90;
}
}
if (! wantsn) {
/* compute eigenvectors (DTGEVC) and estimate condition */
/* numbers (DTGSNA). Note that the definition of the condition */
/* number is not invariant under transformation (u,v) to */
/* (Q*u, Z*v), where (u,v) are eigenvectors of the generalized */
/* Schur form (S,T), Q and Z are orthogonal matrices. In order */
/* to avoid using extra 2*N*N workspace, we have to */
/* re-calculate eigenvectors and estimate the condition numbers */
/* one at a time. */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = *n;
for (j = 1; j <= i__2; ++j) {
bwork[j] = FALSE_;
}
bwork[i__] = TRUE_;
iwrk = *n + 1;
iwrk1 = iwrk + *n;
if (wantse || wantsb) {
ztgevc_("B", "S", &bwork[1], n, &a[a_offset], lda, &b[
b_offset], ldb, &work[1], n, &work[iwrk], n, &
c__1, &m, &work[iwrk1], &rwork[1], &ierr);
if (ierr != 0) {
*info = *n + 2;
goto L90;
}
}
i__2 = *lwork - iwrk1 + 1;
ztgsna_(sense, "S", &bwork[1], n, &a[a_offset], lda, &b[
b_offset], ldb, &work[1], n, &work[iwrk], n, &rconde[
i__], &rcondv[i__], &c__1, &m, &work[iwrk1], &i__2, &
iwork[1], &ierr);
}
}
}
/* Undo balancing on VL and VR and normalization */
/* (Workspace: none needed) */
if (ilvl) {
zggbak_(balanc, "L", n, ilo, ihi, &lscale[1], &rscale[1], n, &vl[
vl_offset], ldvl, &ierr);
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
temp = 0.;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
i__3 = jr + jc * vl_dim1;
d__3 = temp, d__4 = (d__1 = vl[i__3].r, abs(d__1)) + (d__2 =
d_imag(&vl[jr + jc * vl_dim1]), abs(d__2));
temp = max(d__3,d__4);
}
if (temp < smlnum) {
goto L50;
}
temp = 1. / temp;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
i__3 = jr + jc * vl_dim1;
i__4 = jr + jc * vl_dim1;
z__1.r = temp * vl[i__4].r, z__1.i = temp * vl[i__4].i;
vl[i__3].r = z__1.r, vl[i__3].i = z__1.i;
}
L50:
;
}
}
if (ilvr) {
zggbak_(balanc, "R", n, ilo, ihi, &lscale[1], &rscale[1], n, &vr[
vr_offset], ldvr, &ierr);
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
temp = 0.;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
i__3 = jr + jc * vr_dim1;
d__3 = temp, d__4 = (d__1 = vr[i__3].r, abs(d__1)) + (d__2 =
d_imag(&vr[jr + jc * vr_dim1]), abs(d__2));
temp = max(d__3,d__4);
}
if (temp < smlnum) {
goto L80;
}
temp = 1. / temp;
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
i__3 = jr + jc * vr_dim1;
i__4 = jr + jc * vr_dim1;
z__1.r = temp * vr[i__4].r, z__1.i = temp * vr[i__4].i;
vr[i__3].r = z__1.r, vr[i__3].i = z__1.i;
}
L80:
;
}
}
/* Undo scaling if necessary */
if (ilascl) {
zlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alpha[1], n, &
ierr);
}
if (ilbscl) {
zlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, &
ierr);
}
L90:
work[1].r = (doublereal) maxwrk, work[1].i = 0.;
return 0;
/* End of ZGGEVX */
} /* zggevx_ */
/* Subroutine */
int zggev_(char *jobvl, char *jobvr, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer *lwork, doublereal *rwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vl_dim1, vl_offset, vr_dim1, vr_offset, i__1, i__2, i__3, i__4;
doublereal d__1, d__2, d__3, d__4;
doublecomplex z__1;
/* Builtin functions */
double sqrt(doublereal), d_imag(doublecomplex *);
/* Local variables */
integer jc, in, jr, ihi, ilo;
doublereal eps;
logical ilv;
doublereal anrm, bnrm;
integer ierr, itau;
doublereal temp;
logical ilvl, ilvr;
integer iwrk;
extern logical lsame_(char *, char *);
integer ileft, icols, irwrk, irows;
extern /* Subroutine */
int dlabad_(doublereal *, doublereal *);
extern doublereal dlamch_(char *);
extern /* Subroutine */
int zggbak_(char *, char *, integer *, integer *, integer *, doublereal *, doublereal *, integer *, doublecomplex *, integer *, integer *), zggbal_(char *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer * , integer *, doublereal *, doublereal *, doublereal *, integer *);
logical ilascl, ilbscl;
extern /* Subroutine */
int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *, integer *, integer *);
logical ldumma[1];
char chtemp[1];
doublereal bignum;
extern doublereal zlange_(char *, integer *, integer *, doublecomplex *, integer *, doublereal *);
integer ijobvl, iright;
extern /* Subroutine */
int zgghrd_(char *, char *, integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer * ), zlascl_(char *, integer *, integer *, doublereal *, doublereal *, integer *, integer *, doublecomplex *, integer *, integer *);
integer ijobvr;
extern /* Subroutine */
int zgeqrf_(integer *, integer *, doublecomplex *, integer *, doublecomplex *, doublecomplex *, integer *, integer * );
doublereal anrmto;
integer lwkmin;
doublereal bnrmto;
extern /* Subroutine */
int zlacpy_(char *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *), zlaset_(char *, integer *, integer *, doublecomplex *, doublecomplex *, doublecomplex *, integer *), ztgevc_( char *, char *, logical *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, integer *, integer *, doublecomplex *, doublereal *, integer *), zhgeqz_(char *, char *, char *, integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, doublecomplex *, doublecomplex *, integer *, doublecomplex *, integer *, doublecomplex *, integer *, doublereal *, integer *);
doublereal smlnum;
integer lwkopt;
logical lquery;
extern /* Subroutine */
int zungqr_(integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, doublecomplex *, integer *, integer *), zunmqr_(char *, char *, integer *, integer *, integer *, doublecomplex *, integer *, doublecomplex *, doublecomplex *, integer *, doublecomplex *, integer *, integer *);
/* -- LAPACK driver routine (version 3.4.1) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* April 2012 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Statement Functions .. */
/* .. */
/* .. Statement Function definitions .. */
/* .. */
/* .. Executable Statements .. */
/* Decode the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
--alpha;
--beta;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1;
vr -= vr_offset;
--work;
--rwork;
/* Function Body */
if (lsame_(jobvl, "N"))
{
ijobvl = 1;
ilvl = FALSE_;
}
else if (lsame_(jobvl, "V"))
{
ijobvl = 2;
ilvl = TRUE_;
}
else
{
ijobvl = -1;
ilvl = FALSE_;
}
if (lsame_(jobvr, "N"))
{
ijobvr = 1;
ilvr = FALSE_;
}
else if (lsame_(jobvr, "V"))
{
ijobvr = 2;
ilvr = TRUE_;
}
else
{
ijobvr = -1;
ilvr = FALSE_;
}
ilv = ilvl || ilvr;
/* Test the input arguments */
*info = 0;
lquery = *lwork == -1;
if (ijobvl <= 0)
{
*info = -1;
}
else if (ijobvr <= 0)
{
*info = -2;
}
else if (*n < 0)
{
*info = -3;
}
else if (*lda < max(1,*n))
{
*info = -5;
}
else if (*ldb < max(1,*n))
{
*info = -7;
}
else if (*ldvl < 1 || ilvl && *ldvl < *n)
{
*info = -11;
}
else if (*ldvr < 1 || ilvr && *ldvr < *n)
{
*info = -13;
}
/* 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. The workspace is */
/* computed assuming ILO = 1 and IHI = N, the worst case.) */
if (*info == 0)
{
/* Computing MAX */
i__1 = 1;
i__2 = *n << 1; // , expr subst
lwkmin = max(i__1,i__2);
/* Computing MAX */
i__1 = 1;
i__2 = *n + *n * ilaenv_(&c__1, "ZGEQRF", " ", n, &c__1, n, &c__0); // , expr subst
lwkopt = max(i__1,i__2);
/* Computing MAX */
i__1 = lwkopt;
i__2 = *n + *n * ilaenv_(&c__1, "ZUNMQR", " ", n, & c__1, n, &c__0); // , expr subst
lwkopt = max(i__1,i__2);
if (ilvl)
{
/* Computing MAX */
i__1 = lwkopt;
i__2 = *n + *n * ilaenv_(&c__1, "ZUNGQR", " ", n, & c__1, n, &c_n1); // , expr subst
lwkopt = max(i__1,i__2);
}
work[1].r = (doublereal) lwkopt;
work[1].i = 0.; // , expr subst
if (*lwork < lwkmin && ! lquery)
{
*info = -15;
}
}
if (*info != 0)
{
i__1 = -(*info);
xerbla_("ZGGEV ", &i__1);
return 0;
}
else if (lquery)
{
return 0;
}
/* Quick return if possible */
if (*n == 0)
{
return 0;
}
/* Get machine constants */
eps = dlamch_("E") * dlamch_("B");
smlnum = dlamch_("S");
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
smlnum = sqrt(smlnum) / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = zlange_("M", n, n, &a[a_offset], lda, &rwork[1]);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum)
{
anrmto = smlnum;
ilascl = TRUE_;
}
else if (anrm > bignum)
{
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl)
{
zlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, & ierr);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = zlange_("M", n, n, &b[b_offset], ldb, &rwork[1]);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum)
{
bnrmto = smlnum;
ilbscl = TRUE_;
}
else if (bnrm > bignum)
{
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl)
{
zlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, & ierr);
}
/* Permute the matrices A, B to isolate eigenvalues if possible */
/* (Real Workspace: need 6*N) */
ileft = 1;
iright = *n + 1;
irwrk = iright + *n;
zggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &rwork[ ileft], &rwork[iright], &rwork[irwrk], &ierr);
/* Reduce B to triangular form (QR decomposition of B) */
/* (Complex Workspace: need N, prefer N*NB) */
irows = ihi + 1 - ilo;
if (ilv)
{
icols = *n + 1 - ilo;
}
else
{
icols = irows;
}
itau = 1;
iwrk = itau + irows;
i__1 = *lwork + 1 - iwrk;
zgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[ iwrk], &i__1, &ierr);
/* Apply the orthogonal transformation to matrix A */
/* (Complex Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
zunmqr_("L", "C", &irows, &icols, &irows, &b[ilo + ilo * b_dim1], ldb, & work[itau], &a[ilo + ilo * a_dim1], lda, &work[iwrk], &i__1, & ierr);
/* Initialize VL */
/* (Complex Workspace: need N, prefer N*NB) */
if (ilvl)
{
zlaset_("Full", n, n, &c_b1, &c_b2, &vl[vl_offset], ldvl);
if (irows > 1)
{
i__1 = irows - 1;
i__2 = irows - 1;
zlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vl[ ilo + 1 + ilo * vl_dim1], ldvl);
}
i__1 = *lwork + 1 - iwrk;
zungqr_(&irows, &irows, &irows, &vl[ilo + ilo * vl_dim1], ldvl, &work[ itau], &work[iwrk], &i__1, &ierr);
}
/* Initialize VR */
if (ilvr)
{
zlaset_("Full", n, n, &c_b1, &c_b2, &vr[vr_offset], ldvr);
}
/* Reduce to generalized Hessenberg form */
if (ilv)
{
/* Eigenvectors requested -- work on whole matrix. */
zgghrd_(jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset], ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, &ierr);
}
else
{
zgghrd_("N", "N", &irows, &c__1, &irows, &a[ilo + ilo * a_dim1], lda, &b[ilo + ilo * b_dim1], ldb, &vl[vl_offset], ldvl, &vr[ vr_offset], ldvr, &ierr);
}
/* Perform QZ algorithm (Compute eigenvalues, and optionally, the */
/* Schur form and Schur vectors) */
/* (Complex Workspace: need N) */
/* (Real Workspace: need N) */
iwrk = itau;
if (ilv)
{
*(unsigned char *)chtemp = 'S';
}
else
{
*(unsigned char *)chtemp = 'E';
}
i__1 = *lwork + 1 - iwrk;
zhgeqz_(chtemp, jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[ b_offset], ldb, &alpha[1], &beta[1], &vl[vl_offset], ldvl, &vr[ vr_offset], ldvr, &work[iwrk], &i__1, &rwork[irwrk], &ierr);
if (ierr != 0)
{
if (ierr > 0 && ierr <= *n)
{
*info = ierr;
}
else if (ierr > *n && ierr <= *n << 1)
{
*info = ierr - *n;
}
else
{
*info = *n + 1;
}
goto L70;
}
/* Compute Eigenvectors */
/* (Real Workspace: need 2*N) */
/* (Complex Workspace: need 2*N) */
if (ilv)
{
if (ilvl)
{
if (ilvr)
{
*(unsigned char *)chtemp = 'B';
}
else
{
*(unsigned char *)chtemp = 'L';
}
}
else
{
*(unsigned char *)chtemp = 'R';
}
ztgevc_(chtemp, "B", ldumma, n, &a[a_offset], lda, &b[b_offset], ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, n, &in, &work[ iwrk], &rwork[irwrk], &ierr);
if (ierr != 0)
{
*info = *n + 2;
goto L70;
}
/* Undo balancing on VL and VR and normalization */
/* (Workspace: none needed) */
if (ilvl)
{
zggbak_("P", "L", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, &vl[vl_offset], ldvl, &ierr);
i__1 = *n;
for (jc = 1;
jc <= i__1;
++jc)
{
temp = 0.;
i__2 = *n;
for (jr = 1;
jr <= i__2;
++jr)
{
/* Computing MAX */
i__3 = jr + jc * vl_dim1;
d__3 = temp;
d__4 = (d__1 = vl[i__3].r, f2c_abs(d__1)) + ( d__2 = d_imag(&vl[jr + jc * vl_dim1]), f2c_abs(d__2)); // , expr subst
temp = max(d__3,d__4);
/* L10: */
}
if (temp < smlnum)
{
goto L30;
}
temp = 1. / temp;
i__2 = *n;
for (jr = 1;
jr <= i__2;
++jr)
{
i__3 = jr + jc * vl_dim1;
i__4 = jr + jc * vl_dim1;
z__1.r = temp * vl[i__4].r;
z__1.i = temp * vl[i__4].i; // , expr subst
vl[i__3].r = z__1.r;
vl[i__3].i = z__1.i; // , expr subst
/* L20: */
}
L30:
;
}
}
if (ilvr)
{
zggbak_("P", "R", n, &ilo, &ihi, &rwork[ileft], &rwork[iright], n, &vr[vr_offset], ldvr, &ierr);
i__1 = *n;
for (jc = 1;
jc <= i__1;
++jc)
{
temp = 0.;
i__2 = *n;
for (jr = 1;
jr <= i__2;
++jr)
{
/* Computing MAX */
i__3 = jr + jc * vr_dim1;
d__3 = temp;
d__4 = (d__1 = vr[i__3].r, f2c_abs(d__1)) + ( d__2 = d_imag(&vr[jr + jc * vr_dim1]), f2c_abs(d__2)); // , expr subst
temp = max(d__3,d__4);
/* L40: */
}
if (temp < smlnum)
{
goto L60;
}
temp = 1. / temp;
i__2 = *n;
for (jr = 1;
jr <= i__2;
++jr)
{
i__3 = jr + jc * vr_dim1;
i__4 = jr + jc * vr_dim1;
z__1.r = temp * vr[i__4].r;
z__1.i = temp * vr[i__4].i; // , expr subst
vr[i__3].r = z__1.r;
vr[i__3].i = z__1.i; // , expr subst
/* L50: */
}
L60:
;
}
}
}
/* Undo scaling if necessary */
L70:
if (ilascl)
{
zlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alpha[1], n, & ierr);
}
if (ilbscl)
{
zlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, & ierr);
}
work[1].r = (doublereal) lwkopt;
work[1].i = 0.; // , expr subst
return 0;
/* End of ZGGEV */
}
