/* Subroutine */ int dggqrf_(integer *n, integer *m, integer *p, doublereal *
a, integer *lda, doublereal *taua, doublereal *b, integer *ldb,
doublereal *taub, doublereal *work, integer *lwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2;
/* Local variables */
static integer nb, nb1, nb2, nb3, lopt;
extern /* Subroutine */ int dgeqrf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dgerqf_(integer *, integer *, doublereal *, integer *, doublereal
*, doublereal *, integer *, integer *), xerbla_(char *, integer *,
ftnlen);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
extern /* Subroutine */ int dormqr_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *, ftnlen, ftnlen);
static integer lwkopt;
static logical lquery;
/* -- 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 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DGGQRF 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 orthogonal matrix, Z is a P-by-P orthogonal */
/* 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 */
/* transpose of the 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) DOUBLE PRECISION 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 orthogonal 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) DOUBLE PRECISION array, dimension (min(N,M)) */
/* The scalar factors of the elementary reflectors which */
/* represent the orthogonal matrix Q (see Further Details). */
/* B (input/output) DOUBLE PRECISION 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 orthogonal */
/* 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) DOUBLE PRECISION array, dimension (min(N,P)) */
/* The scalar factors of the elementary reflectors which */
/* represent the orthogonal matrix Z (see Further Details). */
/* WORK (workspace/output) DOUBLE PRECISION 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 DORMQR. */
/* 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 real scalar, and v is a real 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 DORGQR. */
/* To use Q to update another matrix, use LAPACK subroutine DORMQR. */
/* 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 real scalar, and v is a real 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 DORGRQ. */
/* To use Z to update another matrix, use LAPACK subroutine DORMRQ. */
/* ===================================================================== */
/* .. 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, "DGEQRF", " ", n, m, &c_n1, &c_n1, (ftnlen)6, (
ftnlen)1);
nb2 = ilaenv_(&c__1, "DGERQF", " ", n, p, &c_n1, &c_n1, (ftnlen)6, (
ftnlen)1);
nb3 = ilaenv_(&c__1, "DORMQR", " ", 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] = (doublereal) lwkopt;
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_("DGGQRF", &i__1, (ftnlen)6);
return 0;
} else if (lquery) {
return 0;
}
/* QR factorization of N-by-M matrix A: A = Q*R */
dgeqrf_(n, m, &a[a_offset], lda, &taua[1], &work[1], lwork, info);
lopt = (integer) work[1];
/* Update B := Q'*B. */
i__1 = min(*n,*m);
dormqr_("Left", "Transpose", n, p, &i__1, &a[a_offset], lda, &taua[1], &b[
b_offset], ldb, &work[1], lwork, info, (ftnlen)4, (ftnlen)9);
/* Computing MAX */
i__1 = lopt, i__2 = (integer) work[1];
lopt = max(i__1,i__2);
/* RQ factorization of N-by-P matrix B: B = T*Z. */
dgerqf_(n, p, &b[b_offset], ldb, &taub[1], &work[1], lwork, info);
/* Computing MAX */
i__1 = lopt, i__2 = (integer) work[1];
work[1] = (doublereal) max(i__1,i__2);
return 0;
/* End of DGGQRF */
} /* dggqrf_ */
/* Subroutine */ int dgels_(char *trans, integer *m, integer *n, integer *
nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb,
doublereal *work, integer *lwork, integer *info, ftnlen trans_len)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2;
/* Local variables */
static integer i__, j, nb, mn;
static doublereal anrm, bnrm;
static integer brow;
static logical tpsd;
static integer iascl, ibscl;
extern logical lsame_(char *, char *, ftnlen, ftnlen);
extern /* Subroutine */ int dtrsm_(char *, char *, char *, char *,
integer *, integer *, doublereal *, doublereal *, integer *,
doublereal *, integer *, ftnlen, ftnlen, ftnlen, ftnlen);
static integer wsize;
static doublereal rwork[1];
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *);
extern doublereal dlamch_(char *, ftnlen), dlange_(char *, integer *,
integer *, doublereal *, integer *, doublereal *, ftnlen);
extern /* Subroutine */ int dgelqf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dlascl_(char *, integer *, integer *, doublereal *, doublereal *,
integer *, integer *, doublereal *, integer *, integer *, ftnlen),
dgeqrf_(integer *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *, integer *), dlaset_(char *,
integer *, integer *, doublereal *, doublereal *, doublereal *,
integer *, ftnlen), xerbla_(char *, integer *, ftnlen);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
static integer scllen;
static doublereal bignum;
extern /* Subroutine */ int dormlq_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *, ftnlen, ftnlen),
dormqr_(char *, char *, integer *, integer *, integer *,
doublereal *, integer *, doublereal *, doublereal *, integer *,
doublereal *, integer *, integer *, ftnlen, ftnlen);
static doublereal smlnum;
static logical lquery;
/* -- 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 .. */
/* .. */
/* Purpose */
/* ======= */
/* DGELS solves overdetermined or underdetermined real linear systems */
/* involving an M-by-N matrix A, or its 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 = 'T' and m >= n: find the minimum norm solution of */
/* an undetermined system A**T * X = B. */
/* 4. If TRANS = 'T' and m < n: find the least squares solution of */
/* an overdetermined system, i.e., solve the least squares problem */
/* minimize || B - A**T * 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; */
/* = 'T': the linear system involves A**T. */
/* 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) DOUBLE PRECISION array, dimension (LDA,N) */
/* On entry, the M-by-N matrix A. */
/* On exit, */
/* if M >= N, A is overwritten by details of its QR */
/* factorization as returned by DGEQRF; */
/* if M < N, A is overwritten by details of its LQ */
/* factorization as returned by DGELQF. */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= max(1,M). */
/* B (input/output) DOUBLE PRECISION 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 = 'T'. */
/* 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 = 'T' and m >= n, rows 1 to M of B contain the */
/* minimum norm solution vectors; */
/* if TRANS = 'T' 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) DOUBLE PRECISION 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 */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* 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;
--work;
/* Function Body */
*info = 0;
mn = min(*m,*n);
lquery = *lwork == -1;
if (! (lsame_(trans, "N", (ftnlen)1, (ftnlen)1) || lsame_(trans, "T", (
ftnlen)1, (ftnlen)1))) {
*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", (ftnlen)1, (ftnlen)1)) {
tpsd = FALSE_;
}
if (*m >= *n) {
nb = ilaenv_(&c__1, "DGEQRF", " ", m, n, &c_n1, &c_n1, (ftnlen)6,
(ftnlen)1);
if (tpsd) {
/* Computing MAX */
i__1 = nb, i__2 = ilaenv_(&c__1, "DORMQR", "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, "DORMQR", "LT", m, nrhs, n, &
c_n1, (ftnlen)6, (ftnlen)2);
nb = max(i__1,i__2);
}
} else {
nb = ilaenv_(&c__1, "DGELQF", " ", m, n, &c_n1, &c_n1, (ftnlen)6,
(ftnlen)1);
if (tpsd) {
/* Computing MAX */
i__1 = nb, i__2 = ilaenv_(&c__1, "DORMLQ", "LT", 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, "DORMLQ", "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);
work[1] = (doublereal) wsize;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DGELS ", &i__1, (ftnlen)6);
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);
dlaset_("Full", &i__1, nrhs, &c_b33, &c_b33, &b[b_offset], ldb, (
ftnlen)4);
return 0;
}
/* Get machine parameters */
smlnum = dlamch_("S", (ftnlen)1) / dlamch_("P", (ftnlen)1);
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
/* Scale A, B if max element outside range [SMLNUM,BIGNUM] */
anrm = dlange_("M", m, n, &a[a_offset], lda, rwork, (ftnlen)1);
iascl = 0;
if (anrm > 0. && anrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
dlascl_("G", &c__0, &c__0, &anrm, &smlnum, m, n, &a[a_offset], lda,
info, (ftnlen)1);
iascl = 1;
} else if (anrm > bignum) {
/* Scale matrix norm down to BIGNUM */
dlascl_("G", &c__0, &c__0, &anrm, &bignum, m, n, &a[a_offset], lda,
info, (ftnlen)1);
iascl = 2;
} else if (anrm == 0.) {
/* Matrix all zero. Return zero solution. */
i__1 = max(*m,*n);
dlaset_("F", &i__1, nrhs, &c_b33, &c_b33, &b[b_offset], ldb, (ftnlen)
1);
goto L50;
}
brow = *m;
if (tpsd) {
brow = *n;
}
bnrm = dlange_("M", &brow, nrhs, &b[b_offset], ldb, rwork, (ftnlen)1);
ibscl = 0;
if (bnrm > 0. && bnrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
dlascl_("G", &c__0, &c__0, &bnrm, &smlnum, &brow, nrhs, &b[b_offset],
ldb, info, (ftnlen)1);
ibscl = 1;
} else if (bnrm > bignum) {
/* Scale matrix norm down to BIGNUM */
dlascl_("G", &c__0, &c__0, &bnrm, &bignum, &brow, nrhs, &b[b_offset],
ldb, info, (ftnlen)1);
ibscl = 2;
}
if (*m >= *n) {
/* compute QR factorization of A */
i__1 = *lwork - mn;
dgeqrf_(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;
dormqr_("Left", "Transpose", m, nrhs, n, &a[a_offset], lda, &work[
1], &b[b_offset], ldb, &work[mn + 1], &i__1, info, (
ftnlen)4, (ftnlen)9);
/* workspace at least NRHS, optimally NRHS*NB */
/* B(1:N,1:NRHS) := inv(R) * B(1:N,1:NRHS) */
dtrsm_("Left", "Upper", "No transpose", "Non-unit", n, nrhs, &
c_b61, &a[a_offset], lda, &b[b_offset], ldb, (ftnlen)4, (
ftnlen)5, (ftnlen)12, (ftnlen)8);
scllen = *n;
} else {
/* Overdetermined system of equations A' * X = B */
/* B(1:N,1:NRHS) := inv(R') * B(1:N,1:NRHS) */
dtrsm_("Left", "Upper", "Transpose", "Non-unit", n, nrhs, &c_b61,
&a[a_offset], lda, &b[b_offset], ldb, (ftnlen)4, (ftnlen)
5, (ftnlen)9, (ftnlen)8);
/* 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__) {
b[i__ + j * b_dim1] = 0.;
/* L10: */
}
/* L20: */
}
/* B(1:M,1:NRHS) := Q(1:N,:) * B(1:N,1:NRHS) */
i__1 = *lwork - mn;
dormqr_("Left", "No transpose", m, nrhs, n, &a[a_offset], lda, &
work[1], &b[b_offset], ldb, &work[mn + 1], &i__1, info, (
ftnlen)4, (ftnlen)12);
/* workspace at least NRHS, optimally NRHS*NB */
scllen = *m;
}
} else {
/* Compute LQ factorization of A */
i__1 = *lwork - mn;
dgelqf_(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) */
dtrsm_("Left", "Lower", "No transpose", "Non-unit", m, nrhs, &
c_b61, &a[a_offset], lda, &b[b_offset], ldb, (ftnlen)4, (
ftnlen)5, (ftnlen)12, (ftnlen)8);
/* 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__) {
b[i__ + j * b_dim1] = 0.;
/* L30: */
}
/* L40: */
}
/* B(1:N,1:NRHS) := Q(1:N,:)' * B(1:M,1:NRHS) */
i__1 = *lwork - mn;
dormlq_("Left", "Transpose", n, nrhs, m, &a[a_offset], lda, &work[
1], &b[b_offset], ldb, &work[mn + 1], &i__1, info, (
ftnlen)4, (ftnlen)9);
/* 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;
dormlq_("Left", "No transpose", n, nrhs, m, &a[a_offset], lda, &
work[1], &b[b_offset], ldb, &work[mn + 1], &i__1, info, (
ftnlen)4, (ftnlen)12);
/* workspace at least NRHS, optimally NRHS*NB */
/* B(1:M,1:NRHS) := inv(L') * B(1:M,1:NRHS) */
dtrsm_("Left", "Lower", "Transpose", "Non-unit", m, nrhs, &c_b61,
&a[a_offset], lda, &b[b_offset], ldb, (ftnlen)4, (ftnlen)
5, (ftnlen)9, (ftnlen)8);
scllen = *m;
}
}
/* Undo scaling */
if (iascl == 1) {
dlascl_("G", &c__0, &c__0, &anrm, &smlnum, &scllen, nrhs, &b[b_offset]
, ldb, info, (ftnlen)1);
} else if (iascl == 2) {
dlascl_("G", &c__0, &c__0, &anrm, &bignum, &scllen, nrhs, &b[b_offset]
, ldb, info, (ftnlen)1);
}
if (ibscl == 1) {
dlascl_("G", &c__0, &c__0, &smlnum, &bnrm, &scllen, nrhs, &b[b_offset]
, ldb, info, (ftnlen)1);
} else if (ibscl == 2) {
dlascl_("G", &c__0, &c__0, &bignum, &bnrm, &scllen, nrhs, &b[b_offset]
, ldb, info, (ftnlen)1);
}
L50:
work[1] = (doublereal) wsize;
return 0;
/* End of DGELS */
} /* dgels_ */
/* Subroutine */ int dggrqf_(integer *m, integer *p, integer *n, doublereal *
a, integer *lda, doublereal *taua, doublereal *b, integer *ldb,
doublereal *taub, doublereal *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 dgeqrf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dgerqf_(integer *, integer *, doublereal *, integer *, doublereal
*, doublereal *, integer *, integer *), xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
extern /* Subroutine */ int dormrq_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *);
integer lwkopt;
logical lquery;
/* -- LAPACK routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DGGRQF 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 orthogonal matrix, Z is a P-by-P orthogonal */
/* 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 */
/* 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) DOUBLE PRECISION 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 orthogonal */
/* 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) DOUBLE PRECISION array, dimension (min(M,N)) */
/* The scalar factors of the elementary reflectors which */
/* represent the orthogonal matrix Q (see Further Details). */
/* B (input/output) DOUBLE PRECISION 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 orthogonal 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) DOUBLE PRECISION array, dimension (min(P,N)) */
/* The scalar factors of the elementary reflectors which */
/* represent the orthogonal matrix Z (see Further Details). */
/* WORK (workspace/output) DOUBLE PRECISION 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 DORMRQ. */
/* 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 INF0= -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 real scalar, and v is a real 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 DORGRQ. */
/* To use Q to update another matrix, use LAPACK subroutine DORMRQ. */
/* 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 real scalar, and v is a real 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 DORGQR. */
/* To use Z to update another matrix, use LAPACK subroutine DORMQR. */
/* ===================================================================== */
/* .. 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, "DGERQF", " ", m, n, &c_n1, &c_n1);
nb2 = ilaenv_(&c__1, "DGEQRF", " ", p, n, &c_n1, &c_n1);
nb3 = ilaenv_(&c__1, "DORMRQ", " ", 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] = (doublereal) lwkopt;
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_("DGGRQF", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* RQ factorization of M-by-N matrix A: A = R*Q */
dgerqf_(m, n, &a[a_offset], lda, &taua[1], &work[1], lwork, info);
lopt = (integer) work[1];
/* Update B := B*Q' */
i__1 = min(*m,*n);
/* Computing MAX */
i__2 = 1, i__3 = *m - *n + 1;
dormrq_("Right", "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];
lopt = max(i__1,i__2);
/* QR factorization of P-by-N matrix B: B = Z*T */
dgeqrf_(p, n, &b[b_offset], ldb, &taub[1], &work[1], lwork, info);
/* Computing MAX */
i__1 = lopt, i__2 = (integer) work[1];
work[1] = (doublereal) max(i__1,i__2);
return 0;
/* End of DGGRQF */
} /* dggrqf_ */
__cminpack_attr__
void __cminpack_func__(qrfac)(int m, int n, real *a, int
lda, int pivot, int *ipvt, int lipvt, real *rdiag,
real *acnorm, real *wa)
{
#ifdef USE_LAPACK
__CLPK_integer m_ = m;
__CLPK_integer n_ = n;
__CLPK_integer lda_ = lda;
__CLPK_integer *jpvt;
int i, j, k;
double t;
double* tau = wa;
const __CLPK_integer ltau = m > n ? n : m;
__CLPK_integer lwork = -1;
__CLPK_integer info = 0;
double* work;
if (pivot) {
assert( lipvt >= n );
if (sizeof(__CLPK_integer) != sizeof(ipvt[0])) {
jpvt = malloc(n*sizeof(__CLPK_integer));
} else {
/* __CLPK_integer is actually an int, just do a cast */
jpvt = (__CLPK_integer *)ipvt;
}
/* set all columns free */
memset(jpvt, 0, sizeof(int)*n);
}
/* query optimal size of work */
lwork = -1;
if (pivot) {
dgeqp3_(&m_,&n_,a,&lda_,jpvt,tau,tau,&lwork,&info);
lwork = (int)tau[0];
assert( lwork >= 3*n+1 );
} else {
dgeqrf_(&m_,&n_,a,&lda_,tau,tau,&lwork,&info);
lwork = (int)tau[0];
assert( lwork >= 1 && lwork >= n );
}
assert( info == 0 );
/* alloc work area */
work = (double *)malloc(sizeof(double)*lwork);
assert(work != NULL);
/* set acnorm first (from the doc of qrfac, acnorm may point to the same area as rdiag) */
if (acnorm != rdiag) {
for (j = 0; j < n; ++j) {
acnorm[j] = __cminpack_enorm__(m, &a[j * lda]);
}
}
/* QR decomposition */
if (pivot) {
dgeqp3_(&m_,&n_,a,&lda_,jpvt,tau,work,&lwork,&info);
} else {
dgeqrf_(&m_,&n_,a,&lda_,tau,work,&lwork,&info);
}
assert(info == 0);
/* set rdiag, before the diagonal is replaced */
memset(rdiag, 0, sizeof(double)*n);
for(i=0 ; i<n ; ++i) {
rdiag[i] = a[i*lda+i];
}
/* modify lower trinagular part to look like qrfac's output */
for(i=0 ; i<ltau ; ++i) {
k = i*lda+i;
t = tau[i];
a[k] = t;
for(j=i+1 ; j<m ; j++) {
k++;
a[k] *= t;
}
}
free(work);
if (pivot) {
/* convert back jpvt to ipvt */
if (sizeof(__CLPK_integer) != sizeof(ipvt[0])) {
for(i=0; i<n; ++i) {
ipvt[i] = jpvt[i];
}
free(jpvt);
}
}
#else /* !USE_LAPACK */
/* Initialized data */
#define p05 .05
/* System generated locals */
real d1;
/* Local variables */
int i, j, k, jp1;
real sum;
real temp;
int minmn;
real epsmch;
real ajnorm;
/* ********** */
/* subroutine qrfac */
/* this subroutine uses householder transformations with column */
/* pivoting (optional) to compute a qr factorization of the */
/* m by n matrix a. that is, qrfac determines an orthogonal */
/* matrix q, a permutation matrix p, and an upper trapezoidal */
/* matrix r with diagonal elements of nonincreasing magnitude, */
/* such that a*p = q*r. the householder transformation for */
/* column k, k = 1,2,...,min(m,n), is of the form */
/* t */
/* i - (1/u(k))*u*u */
/* where u has zeros in the first k-1 positions. the form of */
/* this transformation and the method of pivoting first */
/* appeared in the corresponding linpack subroutine. */
/* the subroutine statement is */
/* subroutine qrfac(m,n,a,lda,pivot,ipvt,lipvt,rdiag,acnorm,wa) */
/* where */
/* m is a positive integer input variable set to the number */
/* of rows of a. */
/* n is a positive integer input variable set to the number */
/* of columns of a. */
/* a is an m by n array. on input a contains the matrix for */
/* which the qr factorization is to be computed. on output */
/* the strict upper trapezoidal part of a contains the strict */
/* upper trapezoidal part of r, and the lower trapezoidal */
/* part of a contains a factored form of q (the non-trivial */
/* elements of the u vectors described above). */
/* lda is a positive integer input variable not less than m */
/* which specifies the leading dimension of the array a. */
/* pivot is a logical input variable. if pivot is set true, */
/* then column pivoting is enforced. if pivot is set false, */
/* then no column pivoting is done. */
/* ipvt is an integer output array of length lipvt. ipvt */
/* defines the permutation matrix p such that a*p = q*r. */
/* column j of p is column ipvt(j) of the identity matrix. */
/* if pivot is false, ipvt is not referenced. */
/* lipvt is a positive integer input variable. if pivot is false, */
/* then lipvt may be as small as 1. if pivot is true, then */
/* lipvt must be at least n. */
/* rdiag is an output array of length n which contains the */
/* diagonal elements of r. */
/* acnorm is an output array of length n which contains the */
/* norms of the corresponding columns of the input matrix a. */
/* if this information is not needed, then acnorm can coincide */
/* with rdiag. */
/* wa is a work array of length n. if pivot is false, then wa */
/* can coincide with rdiag. */
/* subprograms called */
/* minpack-supplied ... dpmpar,enorm */
/* fortran-supplied ... dmax1,dsqrt,min0 */
/* argonne national laboratory. minpack project. march 1980. */
/* burton s. garbow, kenneth e. hillstrom, jorge j. more */
/* ********** */
(void)lipvt;
/* epsmch is the machine precision. */
epsmch = __cminpack_func__(dpmpar)(1);
/* compute the initial column norms and initialize several arrays. */
for (j = 0; j < n; ++j) {
acnorm[j] = __cminpack_enorm__(m, &a[j * lda + 0]);
rdiag[j] = acnorm[j];
wa[j] = rdiag[j];
if (pivot) {
ipvt[j] = j+1;
}
}
/* reduce a to r with householder transformations. */
minmn = min(m,n);
for (j = 0; j < minmn; ++j) {
if (pivot) {
/* bring the column of largest norm into the pivot position. */
int kmax = j;
for (k = j; k < n; ++k) {
if (rdiag[k] > rdiag[kmax]) {
kmax = k;
}
}
if (kmax != j) {
for (i = 0; i < m; ++i) {
temp = a[i + j * lda];
a[i + j * lda] = a[i + kmax * lda];
a[i + kmax * lda] = temp;
}
rdiag[kmax] = rdiag[j];
wa[kmax] = wa[j];
k = ipvt[j];
ipvt[j] = ipvt[kmax];
ipvt[kmax] = k;
}
}
/* compute the householder transformation to reduce the */
/* j-th column of a to a multiple of the j-th unit vector. */
ajnorm = __cminpack_enorm__(m - (j+1) + 1, &a[j + j * lda]);
if (ajnorm != 0.) {
if (a[j + j * lda] < 0.) {
ajnorm = -ajnorm;
}
for (i = j; i < m; ++i) {
a[i + j * lda] /= ajnorm;
}
a[j + j * lda] += 1.;
/* apply the transformation to the remaining columns */
/* and update the norms. */
jp1 = j + 1;
if (n > jp1) {
for (k = jp1; k < n; ++k) {
sum = 0.;
for (i = j; i < m; ++i) {
sum += a[i + j * lda] * a[i + k * lda];
}
temp = sum / a[j + j * lda];
for (i = j; i < m; ++i) {
a[i + k * lda] -= temp * a[i + j * lda];
}
if (pivot && rdiag[k] != 0.) {
temp = a[j + k * lda] / rdiag[k];
/* Computing MAX */
d1 = 1. - temp * temp;
rdiag[k] *= sqrt((max((real)0.,d1)));
/* Computing 2nd power */
d1 = rdiag[k] / wa[k];
if (p05 * (d1 * d1) <= epsmch) {
rdiag[k] = __cminpack_enorm__(m - (j+1), &a[jp1 + k * lda]);
wa[k] = rdiag[k];
}
}
}
}
}
rdiag[j] = -ajnorm;
}
/* last card of subroutine qrfac. */
#endif /* !USE_LAPACK */
} /* qrfac_ */
/* Compute a QR factorization of an m by n matrix A */
void dgeqrf_driver(int m, int n, double *A, double *Q, double *R)
{
double *AT;
int lda = m;
double *tau;
int tau_dim = MIN(m, n);
double *work;
int block_size = 64; /* Just a guess... */
int lwork = n * block_size;
int info;
double *H;
double *v, *vvT;
double *Qtmp;
int i, j;
/* Transpose A */
AT = (double *) malloc(sizeof(double) * m * n);
matrix_transpose(m, n, A, AT);
/* Call the LAPACK routine */
tau = (double *) malloc(sizeof(double) * tau_dim);
work = (double *) malloc(sizeof(double) * lwork);
dgeqrf_(&m, &n, AT, &lda, tau, work, &lwork, &info);
if (info < 0) {
printf("[dgeqrf_driver] An error occurred.\n");
free(AT);
free(work);
free(tau);
return;
}
/* Extract the R matrix */
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (j < i)
R[i * n + j] = 0.0;
else
R[i * n + j] = AT[j * m + i];
}
}
/* Now extract the Q matrix */
H = (double *) malloc(sizeof(double) * m * m);
v = (double *) malloc(sizeof(double) * m);
vvT = (double *) malloc(sizeof(double) * m * m);
Qtmp = (double *) malloc(sizeof(double) * m * m);
for (i = 0; i < tau_dim; i++) {
matrix_ident(m, H);
for (j = 0; j < m; j++) {
if (j < i)
v[j] = 0.0;
else if (j == i)
v[j] = 1.0;
else
v[j] = AT[i * m + j];
}
matrix_transpose_product2(m, 1, m, 1, v, v, vvT);
matrix_scale(m, m, vvT, tau[i], vvT);
matrix_diff(m, m, m, m, H, vvT, H);
if (i == 0) {
memcpy(Q, H, sizeof(double) * m * m);
} else {
matrix_product(m, m, m, m, Q, H, Qtmp);
memcpy(Q, Qtmp, sizeof(double) * m * m);
}
}
free(H);
free(v);
free(vvT);
free(Qtmp);
free(tau);
free(work);
free(AT);
}
int constrained_least_squares(int m, int n, double **matrix, int c, int *constrained)
{
//check problem dimensions
if(m < 1 || n < 1 || n > m || c > n) return LS_DIMENSION_ERROR;
//counters
int i, j;
//extra problem dimensions
int f = m - c, u = n - c;
//lapack and blas inputs
char transa, transb;
double alpha, beta;
//lapack output
int info;
//lapack workspace
int lwork = m*m;
double *work; if(!allocate_double_vector(&work, lwork)) { return LS_MEMORY_ERROR; }
//lapack LU pivot indices
int *ipiv; if(!allocate_integer_vector(&ipiv,c)) { return LS_MEMORY_ERROR; }
//lapack coefficients of QR elementary reflectors
double *tau; if(!allocate_double_vector(&tau,c)) { return LS_MEMORY_ERROR; }
//matrices used
double **t_matrix; if(!allocate_double_matrix(&t_matrix, m, m)) { return LS_MEMORY_ERROR; }
double **c_matrix; if(!allocate_double_matrix(&c_matrix, n, n)) { return LS_MEMORY_ERROR; }
double **r_matrix; if(!allocate_double_matrix(&r_matrix, c, c)) { return LS_MEMORY_ERROR; }
double **a_matrix; if(!allocate_double_matrix(&a_matrix, n, f)) { return LS_MEMORY_ERROR; }
double **d_matrix; if(!allocate_double_matrix(&d_matrix, f, f)) { return LS_MEMORY_ERROR; }
//indices of unconstrained equations
int *temp, *unconstrained;
if(!allocate_integer_vector(&temp,m)) { return LS_MEMORY_ERROR; }
if(!allocate_integer_vector(&unconstrained,f)) { return LS_MEMORY_ERROR; }
//create vector of unconstrained indices
for(i = 0; i < m; i ++) temp[i] = 0;
for(i = 0; i < c; i ++) temp[constrained[i]] = 1;
j = 0;
for(i = 0; i < m; i ++) if(!temp[i]) unconstrained[j++] = i;
//copy unconstrained equations from input matrix -> t_matrix
for(i = 0; i < f; i ++) for(j = 0; j < n; j ++) t_matrix[i][j] = matrix[j][unconstrained[i]];
//copy constrained equations from input matrix -> c_matrix
for(i = 0; i < c; i ++) for(j = 0; j < n; j ++) c_matrix[i][j] = matrix[j][constrained[i]];
//QR decomposition of the transposed constrained equations -> c_matrix
dgeqrf_(&n, &c, c_matrix[0], &n, tau, work, &lwork, &info);
//copy R out of the above QR decomposition -> r_matrix
for(i = 0; i < c; i ++) for(j = 0; j < c; j ++) r_matrix[i][j] = ((j >= i) ? c_matrix[j][i] : 0);
//form the square matrix Q from the above QR decomposition -> c_matrix'
dorgqr_(&n, &n, &c, c_matrix[0], &n, tau, work, &lwork, &info);
//multiply unconstrained eqations by Q -> a_matrix'
transa = 'T'; transb = 'N'; alpha = 1.0; beta = 0.0;
dgemm_(&transa, &transb, &f, &n, &n, &alpha, t_matrix[0], &m, c_matrix[0], &n, &beta, a_matrix[0], &f);
//invert R' of the above QR decomposition -> r_matrix
dgetrf_(&c, &c, r_matrix[0], &c, ipiv, &info);
dgetri_(&c, r_matrix[0], &c, ipiv, work, &lwork, &info);
//LS inversion of the non-square parts from unconstrained * Q -> d_matrix'
for(i = 0; i < f; i ++) for(j = 0; j < u; j ++) t_matrix[j][i] = a_matrix[j+c][i];
for(i = 0; i < f; i ++) for(j = 0; j < f; j ++) d_matrix[i][j] = (i == j);
transa = 'N';
dgels_(&transa, &f, &u, &f, t_matrix[0], &m, d_matrix[0], &f, work, &lwork, &info);
//multiply matrices together to form the CLS solution -> t_matrix'
transa = transb = 'N'; alpha = 1.0; beta = 0.0;
dgemm_(&transa, &transb, &n, &f, &u, &alpha, c_matrix[c], &n, d_matrix[0], &f, &beta, t_matrix[0], &m);
alpha = -1.0; beta = 1.0;
dgemm_(&transa, &transb, &n, &c, &f, &alpha, t_matrix[0], &m, a_matrix[0], &f, &beta, c_matrix[0], &n);
alpha = 1.0; beta = 0.0;
dgemm_(&transa, &transb, &n, &c, &c, &alpha, c_matrix[0], &n, r_matrix[0], &c, &beta, t_matrix[f], &m);
//copy the result out of the temporary matrix -> matrix
for(i = 0; i < n; i ++) for(j = 0; j < f; j ++) matrix[i][unconstrained[j]] = t_matrix[j][i];
for(i = 0; i < n; i ++) for(j = 0; j < c; j ++) matrix[i][constrained[j]] = t_matrix[j+f][i];
//clean up and return successful
free_vector(work);
free_vector(ipiv);
free_vector(tau);
free_vector(temp);
free_vector(unconstrained);
free_matrix((void **)t_matrix);
free_matrix((void **)c_matrix);
free_matrix((void **)r_matrix);
free_matrix((void **)a_matrix);
free_matrix((void **)d_matrix);
return LS_SUCCESS;
}
gretl_matrix *model_leverage (const MODEL *pmod, DATASET *dset,
gretlopt opt, PRN *prn,
int *err)
{
integer info, lwork;
integer m, n, lda;
gretl_matrix *Q, *S = NULL;
doublereal *tau, *work;
double Xvalcrit;
int i, j, s, t, vi;
/* allow for missing obs in model range */
int modn = pmod->t2 - pmod->t1 + 1;
m = pmod->nobs; /* # of rows = # of observations */
lda = m; /* leading dimension of Q */
n = pmod->list[0] - 1; /* # of cols = # of variables */
Q = gretl_matrix_alloc(m, n);
/* dim of tau is min (m, n) */
tau = malloc(n * sizeof *tau);
work = malloc(sizeof *work);
if (Q == NULL || tau == NULL || work == NULL) {
*err = E_ALLOC;
goto qr_cleanup;
}
/* copy independent var values into Q, skipping missing obs */
j = 0;
for (i=2; i<=pmod->list[0]; i++) {
vi = pmod->list[i];
for (t=pmod->t1; t<=pmod->t2; t++) {
if (!na(pmod->uhat[t])) {
Q->val[j++] = dset->Z[vi][t];
}
}
}
/* do a workspace size query */
lwork = -1;
info = 0;
dgeqrf_(&m, &n, Q->val, &lda, tau, work, &lwork, &info);
if (info != 0) {
fprintf(stderr, "dgeqrf: info = %d\n", (int) info);
*err = 1;
goto qr_cleanup;
}
/* set up optimally sized work array */
lwork = (integer) work[0];
work = realloc(work, (size_t) lwork * sizeof *work);
if (work == NULL) {
*err = E_ALLOC;
goto qr_cleanup;
}
/* run actual QR factorization */
dgeqrf_(&m, &n, Q->val, &lda, tau, work, &lwork, &info);
if (info != 0) {
fprintf(stderr, "dgeqrf: info = %d\n", (int) info);
*err = 1;
goto qr_cleanup;
}
/* obtain the real "Q" matrix */
dorgqr_(&m, &n, &n, Q->val, &lda, tau, work, &lwork, &info);
if (info != 0) {
*err = 1;
goto qr_cleanup;
}
S = gretl_matrix_alloc(modn, 3);
if (S == NULL) {
*err = E_ALLOC;
goto qr_cleanup;
}
gretl_matrix_set_t1(S, pmod->t1);
/* do the "h" calculations */
s = 0;
for (t=pmod->t1, j=0; t<=pmod->t2; t++, j++) {
double q, h;
if (na(pmod->uhat[t])) {
h = NADBL;
} else {
h = 0.0;
for (i=0; i<n; i++) {
q = gretl_matrix_get(Q, s, i);
h += q * q;
}
s++;
}
gretl_matrix_set(S, j, 0, h);
}
Xvalcrit = 0.0;
/* compute the influence series and the cross-validation criterion */
for (t=pmod->t1, j=0; t<=pmod->t2; t++, j++) {
double f = NADBL;
if (!na(pmod->uhat[t])) {
double h = gretl_matrix_get(S, j, 0);
if (h < 1.0) {
f = pmod->uhat[t] / (1.0 - h);
Xvalcrit += f * f;
f -= pmod->uhat[t];
}
}
gretl_matrix_set(S, j, 1, f);
}
record_test_result(Xvalcrit, NADBL, _("Cross-validation criterion"));
/* put studentized residuals into S[,2] */
studentized_residuals(pmod, S);
/* print the results, unless in quiet mode */
if (!(opt & OPT_Q)) {
leverage_print(pmod, S, Xvalcrit, dset, prn);
if (gnuplot_graph_wanted(PLOT_LEVERAGE, opt)) {
leverage_plot(pmod, S, dset);
}
}
qr_cleanup:
gretl_matrix_free(Q);
free(tau);
free(work);
return S;
}
int dgegv_(char *jobvl, char *jobvr, int *n, double *
a, int *lda, double *b, int *ldb, double *alphar,
double *alphai, double *beta, double *vl, int *ldvl,
double *vr, int *ldvr, double *work, int *lwork,
int *info)
{
/* System generated locals */
int a_dim1, a_offset, b_dim1, b_offset, vl_dim1, vl_offset, vr_dim1,
vr_offset, i__1, i__2;
double d__1, d__2, d__3, d__4;
/* Local variables */
int jc, nb, in, jr, nb1, nb2, nb3, ihi, ilo;
double eps;
int ilv;
double absb, anrm, bnrm;
int itau;
double temp;
int ilvl, ilvr;
int lopt;
double anrm1, anrm2, bnrm1, bnrm2, absai, scale, absar, sbeta;
extern int lsame_(char *, char *);
int ileft, iinfo, icols, iwork, irows;
extern int dggbak_(char *, char *, int *, int *,
int *, double *, double *, int *, double *,
int *, int *), dggbal_(char *, int *,
double *, int *, double *, int *, int *,
int *, double *, double *, double *, int *);
extern double dlamch_(char *), dlange_(char *, int *,
int *, double *, int *, double *);
double salfai;
extern int dgghrd_(char *, char *, int *, int *,
int *, double *, int *, double *, int *,
double *, int *, double *, int *, int *), dlascl_(char *, int *, int *, double
*, double *, int *, int *, double *, int *,
int *);
double salfar;
extern int dgeqrf_(int *, int *, double *,
int *, double *, double *, int *, int *),
dlacpy_(char *, int *, int *, double *, int *,
double *, int *);
double safmin;
extern int dlaset_(char *, int *, int *,
double *, double *, double *, int *);
double safmax;
char chtemp[1];
int ldumma[1];
extern int dhgeqz_(char *, char *, char *, int *,
int *, int *, double *, int *, double *,
int *, double *, double *, double *, double *,
int *, double *, int *, double *, int *,
int *), dtgevc_(char *, char *,
int *, int *, double *, int *, double *,
int *, double *, int *, double *, int *,
int *, int *, double *, int *),
xerbla_(char *, int *);
int ijobvl, iright;
int ilimit;
extern int ilaenv_(int *, char *, char *, int *, int *,
int *, int *);
int ijobvr;
extern int dorgqr_(int *, int *, int *,
double *, int *, double *, double *, int *,
int *);
double onepls;
int lwkmin;
extern int dormqr_(char *, char *, int *, int *,
int *, double *, int *, double *, double *,
int *, double *, int *, int *);
int lwkopt;
int lquery;
/* -- 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 DGGEV. */
/* DGEGV computes the eigenvalues and, optionally, the left and/or right */
/* eigenvectors of a float 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) DOUBLE PRECISION array, dimension (LDA, N) */
/* On entry, the matrix A. */
/* If JOBVL = 'V' or JOBVR = 'V', then on exit A */
/* contains the float 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 */
/* blocks from the Schur form will be correct. See DGGHRD and */
/* DHGEQZ for details. */
/* LDA (input) INTEGER */
/* The leading dimension of A. LDA >= MAX(1,N). */
/* B (input/output) DOUBLE PRECISION 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 those elements of */
/* B corresponding to the diagonal blocks from the Schur form of */
/* A will be correct. See DGGHRD and DHGEQZ for details. */
/* LDB (input) INTEGER */
/* The leading dimension of B. LDB >= MAX(1,N). */
/* ALPHAR (output) DOUBLE PRECISION array, dimension (N) */
/* The float parts of each scalar alpha defining an eigenvalue of */
/* GNEP. */
/* ALPHAI (output) DOUBLE PRECISION array, dimension (N) */
/* The imaginary parts of each scalar alpha defining an */
/* eigenvalue of GNEP. If ALPHAI(j) is zero, then the j-th */
/* eigenvalue is float; if positive, then the j-th and */
/* (j+1)-st eigenvalues are a complex conjugate pair, with */
/* ALPHAI(j+1) = -ALPHAI(j). */
/* BETA (output) DOUBLE PRECISION array, dimension (N) */
/* The scalars beta that define the eigenvalues of GNEP. */
/* Together, the quantities alpha = (ALPHAR(j),ALPHAI(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) DOUBLE PRECISION 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. */
/* If the j-th eigenvalue is float, then u(j) = VL(:,j). */
/* If the j-th and (j+1)-st eigenvalues form a complex conjugate */
/* pair, then */
/* u(j) = VL(:,j) + i*VL(:,j+1) */
/* and */
/* u(j+1) = VL(:,j) - i*VL(:,j+1). */
/* Each eigenvector is scaled so that its largest component has */
/* ABS(float 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) DOUBLE PRECISION 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. */
/* If the j-th eigenvalue is float, then x(j) = VR(:,j). */
/* If the j-th and (j+1)-st eigenvalues form a complex conjugate */
/* pair, then */
/* x(j) = VR(:,j) + i*VR(:,j+1) */
/* and */
/* x(j+1) = VR(:,j) - i*VR(:,j+1). */
/* Each eigenvector is scaled so that its largest component has */
/* ABS(float part) + ABS(imag. part) = 1, except for eigenvalues */
/* 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) DOUBLE PRECISION 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,8*N). */
/* For good performance, LWORK must generally be larger. */
/* To compute the optimal value of LWORK, call ILAENV to get */
/* blocksizes (for DGEQRF, DORMQR, and DORGQR.) Then compute: */
/* NB -- MAX of the blocksizes for DGEQRF, DORMQR, and DORGQR; */
/* The optimal LWORK is: */
/* 2*N + MAX( 6*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. */
/* 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 ALPHAR(j), ALPHAI(j), and BETA(j) */
/* should be correct for j=INFO+1,...,N. */
/* > N: errors that usually indicate LAPACK problems: */
/* =N+1: error return from DGGBAL */
/* =N+2: error return from DGEQRF */
/* =N+3: error return from DORMQR */
/* =N+4: error return from DORGQR */
/* =N+5: error return from DGGHRD */
/* =N+6: error return from DHGEQZ (other than failed */
/* iteration) */
/* =N+7: error return from DTGEVC */
/* =N+8: error return from DGGBAK (computing VL) */
/* =N+9: error return from DGGBAK (computing VR) */
/* =N+10: error return from DLASCL (various calls) */
/* Further Details */
/* =============== */
/* Balancing */
/* --------- */
/* This driver calls DGGBAL 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, DGGBAK 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 float Schur */
/* form[*] of the "balanced" versions of A and B. If no eigenvectors */
/* are computed, then only the diagonal blocks will be correct. */
/* [*] See DHGEQZ, DGEGS, or read the book "Matrix Computations", */
/* by Golub & van Loan, pub. by Johns Hopkins U. Press. */
/* ===================================================================== */
/* .. 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;
--alphar;
--alphai;
--beta;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1;
vr -= vr_offset;
--work;
/* 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 << 3;
lwkmin = MAX(i__1,1);
lwkopt = lwkmin;
work[1] = (double) lwkopt;
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 = -12;
} else if (*ldvr < 1 || ilvr && *ldvr < *n) {
*info = -14;
} else if (*lwork < lwkmin && ! lquery) {
*info = -16;
}
if (*info == 0) {
nb1 = ilaenv_(&c__1, "DGEQRF", " ", n, n, &c_n1, &c_n1);
nb2 = ilaenv_(&c__1, "DORMQR", " ", n, n, n, &c_n1);
nb3 = ilaenv_(&c__1, "DORGQR", " ", n, n, n, &c_n1);
/* Computing MAX */
i__1 = MAX(nb1,nb2);
nb = MAX(i__1,nb3);
/* Computing MAX */
i__1 = *n * 6, i__2 = *n * (nb + 1);
lopt = (*n << 1) + MAX(i__1,i__2);
work[1] = (double) lopt;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DGEGV ", &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;
onepls = eps * 4 + 1.;
/* Scale A */
anrm = dlange_("M", n, n, &a[a_offset], lda, &work[1]);
anrm1 = anrm;
anrm2 = 1.;
if (anrm < 1.) {
if (safmax * anrm < 1.) {
anrm1 = safmin;
anrm2 = safmax * anrm;
}
}
if (anrm > 0.) {
dlascl_("G", &c_n1, &c_n1, &anrm, &c_b27, n, n, &a[a_offset], lda, &
iinfo);
if (iinfo != 0) {
*info = *n + 10;
return 0;
}
}
/* Scale B */
bnrm = dlange_("M", n, n, &b[b_offset], ldb, &work[1]);
bnrm1 = bnrm;
bnrm2 = 1.;
if (bnrm < 1.) {
if (safmax * bnrm < 1.) {
bnrm1 = safmin;
bnrm2 = safmax * bnrm;
}
}
if (bnrm > 0.) {
dlascl_("G", &c_n1, &c_n1, &bnrm, &c_b27, n, n, &b[b_offset], ldb, &
iinfo);
if (iinfo != 0) {
*info = *n + 10;
return 0;
}
}
/* Permute the matrix to make it more nearly triangular */
/* Workspace layout: (8*N words -- "work" requires 6*N words) */
/* left_permutation, right_permutation, work... */
ileft = 1;
iright = *n + 1;
iwork = iright + *n;
dggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &work[
ileft], &work[iright], &work[iwork], &iinfo);
if (iinfo != 0) {
*info = *n + 1;
goto L120;
}
/* Reduce B to triangular form, and initialize VL and/or VR */
/* Workspace layout: ("work..." must have at least N words) */
/* left_permutation, right_permutation, tau, work... */
irows = ihi + 1 - ilo;
if (ilv) {
icols = *n + 1 - ilo;
} else {
icols = irows;
}
itau = iwork;
iwork = itau + irows;
i__1 = *lwork + 1 - iwork;
dgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[
iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (int) work[iwork] + iwork - 1;
lwkopt = MAX(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 2;
goto L120;
}
i__1 = *lwork + 1 - iwork;
dormqr_("L", "T", &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__1 = lwkopt, i__2 = (int) work[iwork] + iwork - 1;
lwkopt = MAX(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 3;
goto L120;
}
if (ilvl) {
dlaset_("Full", n, n, &c_b38, &c_b27, &vl[vl_offset], ldvl)
;
i__1 = irows - 1;
i__2 = irows - 1;
dlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vl[ilo +
1 + ilo * vl_dim1], ldvl);
i__1 = *lwork + 1 - iwork;
dorgqr_(&irows, &irows, &irows, &vl[ilo + ilo * vl_dim1], ldvl, &work[
itau], &work[iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (int) work[iwork] + iwork - 1;
lwkopt = MAX(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 4;
goto L120;
}
}
if (ilvr) {
dlaset_("Full", n, n, &c_b38, &c_b27, &vr[vr_offset], ldvr)
;
}
/* Reduce to generalized Hessenberg form */
if (ilv) {
/* Eigenvectors requested -- work on whole matrix. */
dgghrd_(jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, &iinfo);
} else {
dgghrd_("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 L120;
}
/* Perform QZ algorithm */
/* Workspace layout: ("work..." must have at least 1 word) */
/* left_permutation, right_permutation, work... */
iwork = itau;
if (ilv) {
*(unsigned char *)chtemp = 'S';
} else {
*(unsigned char *)chtemp = 'E';
}
i__1 = *lwork + 1 - iwork;
dhgeqz_(chtemp, jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alphar[1], &alphai[1], &beta[1], &vl[vl_offset],
ldvl, &vr[vr_offset], ldvr, &work[iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (int) work[iwork] + 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 L120;
}
if (ilv) {
/* Compute Eigenvectors (DTGEVC requires 6*N words of workspace) */
if (ilvl) {
if (ilvr) {
*(unsigned char *)chtemp = 'B';
} else {
*(unsigned char *)chtemp = 'L';
}
} else {
*(unsigned char *)chtemp = 'R';
}
dtgevc_(chtemp, "B", ldumma, n, &a[a_offset], lda, &b[b_offset], ldb,
&vl[vl_offset], ldvl, &vr[vr_offset], ldvr, n, &in, &work[
iwork], &iinfo);
if (iinfo != 0) {
*info = *n + 7;
goto L120;
}
/* Undo balancing on VL and VR, rescale */
if (ilvl) {
dggbak_("P", "L", n, &ilo, &ihi, &work[ileft], &work[iright], n, &
vl[vl_offset], ldvl, &iinfo);
if (iinfo != 0) {
*info = *n + 8;
goto L120;
}
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
if (alphai[jc] < 0.) {
goto L50;
}
temp = 0.;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__2 = temp, d__3 = (d__1 = vl[jr + jc * vl_dim1],
ABS(d__1));
temp = MAX(d__2,d__3);
/* L10: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__3 = temp, d__4 = (d__1 = vl[jr + jc * vl_dim1],
ABS(d__1)) + (d__2 = vl[jr + (jc + 1) *
vl_dim1], ABS(d__2));
temp = MAX(d__3,d__4);
/* L20: */
}
}
if (temp < safmin) {
goto L50;
}
temp = 1. / temp;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vl[jr + jc * vl_dim1] *= temp;
/* L30: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vl[jr + jc * vl_dim1] *= temp;
vl[jr + (jc + 1) * vl_dim1] *= temp;
/* L40: */
}
}
L50:
;
}
}
if (ilvr) {
dggbak_("P", "R", n, &ilo, &ihi, &work[ileft], &work[iright], n, &
vr[vr_offset], ldvr, &iinfo);
if (iinfo != 0) {
*info = *n + 9;
goto L120;
}
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
if (alphai[jc] < 0.) {
goto L100;
}
temp = 0.;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__2 = temp, d__3 = (d__1 = vr[jr + jc * vr_dim1],
ABS(d__1));
temp = MAX(d__2,d__3);
/* L60: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__3 = temp, d__4 = (d__1 = vr[jr + jc * vr_dim1],
ABS(d__1)) + (d__2 = vr[jr + (jc + 1) *
vr_dim1], ABS(d__2));
temp = MAX(d__3,d__4);
/* L70: */
}
}
if (temp < safmin) {
goto L100;
}
temp = 1. / temp;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr[jr + jc * vr_dim1] *= temp;
/* L80: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr[jr + jc * vr_dim1] *= temp;
vr[jr + (jc + 1) * vr_dim1] *= temp;
/* L90: */
}
}
L100:
;
}
}
/* 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) {
absar = (d__1 = alphar[jc], ABS(d__1));
absai = (d__1 = alphai[jc], ABS(d__1));
absb = (d__1 = beta[jc], ABS(d__1));
salfar = anrm * alphar[jc];
salfai = anrm * alphai[jc];
sbeta = bnrm * beta[jc];
ilimit = FALSE;
scale = 1.;
/* Check for significant underflow in ALPHAI */
/* 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 = onepls * safmin, d__2 = anrm2 * absai;
scale = onepls * safmin / anrm1 / MAX(d__1,d__2);
} else if (salfai == 0.) {
/* If insignificant underflow in ALPHAI, then make the */
/* conjugate eigenvalue float. */
if (alphai[jc] < 0. && jc > 1) {
alphai[jc - 1] = 0.;
} else if (alphai[jc] > 0. && jc < *n) {
alphai[jc + 1] = 0.;
}
}
/* Check for significant underflow in ALPHAR */
/* 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 = onepls * safmin, d__4 = anrm2 * absar;
d__1 = scale, d__2 = onepls * 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 = onepls * safmin, d__4 = bnrm2 * absb;
d__1 = scale, d__2 = onepls * 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 ALPHAR, ALPHAI, BETA if necessary. */
if (ilimit) {
salfar = scale * alphar[jc] * anrm;
salfai = scale * alphai[jc] * anrm;
sbeta = scale * beta[jc] * bnrm;
}
alphar[jc] = salfar;
alphai[jc] = salfai;
beta[jc] = sbeta;
/* L110: */
}
L120:
work[1] = (double) lwkopt;
return 0;
/* End of DGEGV */
} /* dgegv_ */
/* Subroutine */ int dgelsd_(integer *m, integer *n, integer *nrhs,
doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *
s, doublereal *rcond, integer *rank, doublereal *work, integer *lwork,
integer *iwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3, i__4;
/* Builtin functions */
double log(doublereal);
/* Local variables */
static doublereal anrm, bnrm;
static integer itau, nlvl, iascl, ibscl;
static doublereal sfmin;
static integer minmn, maxmn, itaup, itauq, mnthr, nwork;
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *);
static integer ie, il;
extern /* Subroutine */ int dgebrd_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
doublereal *, integer *, integer *);
extern doublereal dlamch_(char *);
static integer mm;
extern doublereal dlange_(char *, integer *, integer *, doublereal *,
integer *, doublereal *);
extern /* Subroutine */ int dgelqf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dlalsd_(char *, integer *, integer *, integer *, doublereal *,
doublereal *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *, integer *), dlascl_(char *,
integer *, integer *, doublereal *, doublereal *, integer *,
integer *, doublereal *, integer *, integer *), dgeqrf_(
integer *, integer *, doublereal *, integer *, doublereal *,
doublereal *, integer *, integer *), dlacpy_(char *, integer *,
integer *, doublereal *, integer *, doublereal *, integer *), dlaset_(char *, integer *, integer *, doublereal *,
doublereal *, doublereal *, integer *), xerbla_(char *,
integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
static doublereal bignum;
extern /* Subroutine */ int dormbr_(char *, char *, char *, integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, integer *);
static integer wlalsd;
extern /* Subroutine */ int dormlq_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *);
static integer ldwork;
extern /* Subroutine */ int dormqr_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *);
static integer minwrk, maxwrk;
static doublereal smlnum;
static logical lquery;
static integer smlsiz;
static doublereal eps;
#define a_ref(a_1,a_2) a[(a_2)*a_dim1 + a_1]
#define b_ref(a_1,a_2) b[(a_2)*b_dim1 + a_1]
/* -- LAPACK driver routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
October 31, 1999
Purpose
=======
DGELSD 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 transformations, 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 A. M >= 0.
N (input) INTEGER
The number of columns of 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) DOUBLE PRECISION 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) DOUBLE PRECISION array, dimension (LDB,NRHS)
On entry, the M-by-NRHS right hand side matrix B.
On exit, B is overwritten by the N-by-NRHS solution
matrix X. If m >= n and RANK = n, the residual
sum-of-squares for the solution in the i-th column is given
by the sum of squares of elements n+1:m in that column.
LDB (input) INTEGER
The leading dimension of the array B. LDB >= max(1,max(M,N)).
S (output) 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) DOUBLE PRECISION array, dimension (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
12*N + 2*N*SMLSIZ + 8*N*NLVL + N*NRHS + (SMLSIZ+1)**2,
if M is greater than or equal to N or
12*M + 2*M*SMLSIZ + 8*M*NLVL + M*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 )
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 WORK array, returns
this value as the first entry of the WORK array, and no error
message related to LWORK is issued by XERBLA.
IWORK (workspace) INTEGER array, dimension (LIWORK)
LIWORK >= 3 * MINMN * NLVL + 11 * MINMN,
where MINMN = MIN( M,N ).
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 * 1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
--s;
--work;
--iwork;
/* Function Body */
*info = 0;
minmn = min(*m,*n);
maxmn = max(*m,*n);
mnthr = ilaenv_(&c__6, "DGELSD", " ", m, n, nrhs, &c_n1, (ftnlen)6, (
ftnlen)1);
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;
}
smlsiz = ilaenv_(&c__9, "DGELSD", " ", &c__0, &c__0, &c__0, &c__0, (
ftnlen)6, (ftnlen)1);
/* 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;
minmn = max(1,minmn);
/* Computing MAX */
i__1 = (integer) (log((doublereal) minmn / (doublereal) (smlsiz + 1)) /
log(2.)) + 1;
nlvl = max(i__1,0);
if (*info == 0) {
maxwrk = 0;
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 + *n * ilaenv_(&c__1, "DGEQRF", " ", m,
n, &c_n1, &c_n1, (ftnlen)6, (ftnlen)1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *nrhs * ilaenv_(&c__1, "DORMQR", "LT",
m, nrhs, n, &c_n1, (ftnlen)6, (ftnlen)2);
maxwrk = max(i__1,i__2);
}
if (*m >= *n) {
/* Path 1 - overdetermined or exactly determined.
Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + (mm + *n) * ilaenv_(&c__1, "DGEBRD"
, " ", &mm, n, &c_n1, &c_n1, (ftnlen)6, (ftnlen)1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + *nrhs * ilaenv_(&c__1, "DORMBR",
"QLT", &mm, nrhs, n, &c_n1, (ftnlen)6, (ftnlen)3);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + (*n - 1) * ilaenv_(&c__1, "DORMBR",
"PLN", n, nrhs, n, &c_n1, (ftnlen)6, (ftnlen)3);
maxwrk = max(i__1,i__2);
/* Computing 2nd power */
i__1 = smlsiz + 1;
wlalsd = *n * 9 + (*n << 1) * smlsiz + (*n << 3) * nlvl + *n * *
nrhs + i__1 * i__1;
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + wlalsd;
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = *n * 3 + mm, i__2 = *n * 3 + *nrhs, i__1 = max(i__1,i__2),
i__2 = *n * 3 + wlalsd;
minwrk = max(i__1,i__2);
}
if (*n > *m) {
/* Computing 2nd power */
i__1 = smlsiz + 1;
wlalsd = *m * 9 + (*m << 1) * smlsiz + (*m << 3) * nlvl + *m * *
nrhs + i__1 * i__1;
if (*n >= mnthr) {
/* Path 2a - underdetermined, with many more columns
than rows. */
maxwrk = *m + *m * ilaenv_(&c__1, "DGELQF", " ", m, n, &c_n1,
&c_n1, (ftnlen)6, (ftnlen)1);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + (*m << 1) *
ilaenv_(&c__1, "DGEBRD", " ", m, m, &c_n1, &c_n1, (
ftnlen)6, (ftnlen)1);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + *nrhs * ilaenv_(&
c__1, "DORMBR", "QLT", m, nrhs, m, &c_n1, (ftnlen)6, (
ftnlen)3);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + (*m - 1) *
ilaenv_(&c__1, "DORMBR", "PLN", m, nrhs, m, &c_n1, (
ftnlen)6, (ftnlen)3);
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, "DORMLQ",
"LT", n, nrhs, m, &c_n1, (ftnlen)6, (ftnlen)2);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) + wlalsd;
maxwrk = max(i__1,i__2);
} else {
/* Path 2 - remaining underdetermined cases. */
maxwrk = *m * 3 + (*n + *m) * ilaenv_(&c__1, "DGEBRD", " ", m,
n, &c_n1, &c_n1, (ftnlen)6, (ftnlen)1);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + *nrhs * ilaenv_(&c__1, "DORMBR"
, "QLT", m, nrhs, n, &c_n1, (ftnlen)6, (ftnlen)3);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + *m * ilaenv_(&c__1, "DORMBR",
"PLN", n, nrhs, m, &c_n1, (ftnlen)6, (ftnlen)3);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + wlalsd;
maxwrk = max(i__1,i__2);
}
/* Computing MAX */
i__1 = *m * 3 + *nrhs, i__2 = *m * 3 + *m, i__1 = max(i__1,i__2),
i__2 = *m * 3 + wlalsd;
minwrk = max(i__1,i__2);
}
minwrk = min(minwrk,maxwrk);
work[1] = (doublereal) maxwrk;
if (*lwork < minwrk && ! lquery) {
*info = -12;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DGELSD", &i__1);
return 0;
} else if (lquery) {
goto L10;
}
/* 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 = dlange_("M", m, n, &a[a_offset], lda, &work[1]);
iascl = 0;
if (anrm > 0. && anrm < smlnum) {
/* Scale matrix norm up to SMLNUM. */
dlascl_("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. */
dlascl_("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);
dlaset_("F", &i__1, nrhs, &c_b82, &c_b82, &b[b_offset], ldb);
dlaset_("F", &minmn, &c__1, &c_b82, &c_b82, &s[1], &c__1);
*rank = 0;
goto L10;
}
/* Scale B if max entry outside range [SMLNUM,BIGNUM]. */
bnrm = dlange_("M", m, nrhs, &b[b_offset], ldb, &work[1]);
ibscl = 0;
if (bnrm > 0. && bnrm < smlnum) {
/* Scale matrix norm up to SMLNUM. */
dlascl_("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. */
dlascl_("G", &c__0, &c__0, &bnrm, &bignum, m, nrhs, &b[b_offset], ldb,
info);
ibscl = 2;
}
/* If M < N make sure certain entries of B are zero. */
if (*m < *n) {
i__1 = *n - *m;
dlaset_("F", &i__1, nrhs, &c_b82, &c_b82, &b_ref(*m + 1, 1), 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.
(Workspace: need 2*N, prefer N+N*NB) */
i__1 = *lwork - nwork + 1;
dgeqrf_(m, n, &a[a_offset], lda, &work[itau], &work[nwork], &i__1,
info);
/* Multiply B by transpose(Q).
(Workspace: need N+NRHS, prefer N+NRHS*NB) */
i__1 = *lwork - nwork + 1;
dormqr_("L", "T", 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;
dlaset_("L", &i__1, &i__2, &c_b82, &c_b82, &a_ref(2, 1), lda);
}
}
ie = 1;
itauq = ie + *n;
itaup = itauq + *n;
nwork = itaup + *n;
/* Bidiagonalize R in A.
(Workspace: need 3*N+MM, prefer 3*N+(MM+N)*NB) */
i__1 = *lwork - nwork + 1;
dgebrd_(&mm, n, &a[a_offset], lda, &s[1], &work[ie], &work[itauq], &
work[itaup], &work[nwork], &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors of R.
(Workspace: need 3*N+NRHS, prefer 3*N+NRHS*NB) */
i__1 = *lwork - nwork + 1;
dormbr_("Q", "L", "T", &mm, nrhs, n, &a[a_offset], lda, &work[itauq],
&b[b_offset], ldb, &work[nwork], &i__1, info);
/* Solve the bidiagonal least squares problem. */
dlalsd_("U", &smlsiz, n, nrhs, &s[1], &work[ie], &b[b_offset], ldb,
rcond, rank, &work[nwork], &iwork[1], info);
if (*info != 0) {
goto L10;
}
/* Multiply B by right bidiagonalizing vectors of R. */
i__1 = *lwork - nwork + 1;
dormbr_("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.
(Workspace: need 2*M, prefer M+M*NB) */
i__1 = *lwork - nwork + 1;
dgelqf_(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. */
dlacpy_("L", m, m, &a[a_offset], lda, &work[il], &ldwork);
i__1 = *m - 1;
i__2 = *m - 1;
dlaset_("U", &i__1, &i__2, &c_b82, &c_b82, &work[il + ldwork], &
ldwork);
ie = il + ldwork * *m;
itauq = ie + *m;
itaup = itauq + *m;
nwork = itaup + *m;
/* Bidiagonalize L in WORK(IL).
(Workspace: need M*M+5*M, prefer M*M+4*M+2*M*NB) */
i__1 = *lwork - nwork + 1;
dgebrd_(m, m, &work[il], &ldwork, &s[1], &work[ie], &work[itauq],
&work[itaup], &work[nwork], &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors of L.
(Workspace: need M*M+4*M+NRHS, prefer M*M+4*M+NRHS*NB) */
i__1 = *lwork - nwork + 1;
dormbr_("Q", "L", "T", m, nrhs, m, &work[il], &ldwork, &work[
itauq], &b[b_offset], ldb, &work[nwork], &i__1, info);
/* Solve the bidiagonal least squares problem. */
dlalsd_("U", &smlsiz, m, nrhs, &s[1], &work[ie], &b[b_offset],
ldb, rcond, rank, &work[nwork], &iwork[1], info);
if (*info != 0) {
goto L10;
}
/* Multiply B by right bidiagonalizing vectors of L. */
i__1 = *lwork - nwork + 1;
dormbr_("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;
dlaset_("F", &i__1, nrhs, &c_b82, &c_b82, &b_ref(*m + 1, 1), ldb);
nwork = itau + *m;
/* Multiply transpose(Q) by B.
(Workspace: need M+NRHS, prefer M+NRHS*NB) */
i__1 = *lwork - nwork + 1;
dormlq_("L", "T", n, nrhs, m, &a[a_offset], lda, &work[itau], &b[
b_offset], ldb, &work[nwork], &i__1, info);
} else {
/* Path 2 - remaining underdetermined cases. */
ie = 1;
itauq = ie + *m;
itaup = itauq + *m;
nwork = itaup + *m;
/* Bidiagonalize A.
(Workspace: need 3*M+N, prefer 3*M+(M+N)*NB) */
i__1 = *lwork - nwork + 1;
dgebrd_(m, n, &a[a_offset], lda, &s[1], &work[ie], &work[itauq], &
work[itaup], &work[nwork], &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors.
(Workspace: need 3*M+NRHS, prefer 3*M+NRHS*NB) */
i__1 = *lwork - nwork + 1;
dormbr_("Q", "L", "T", m, nrhs, n, &a[a_offset], lda, &work[itauq]
, &b[b_offset], ldb, &work[nwork], &i__1, info);
/* Solve the bidiagonal least squares problem. */
dlalsd_("L", &smlsiz, m, nrhs, &s[1], &work[ie], &b[b_offset],
ldb, rcond, rank, &work[nwork], &iwork[1], info);
if (*info != 0) {
goto L10;
}
/* Multiply B by right bidiagonalizing vectors of A. */
i__1 = *lwork - nwork + 1;
dormbr_("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) {
dlascl_("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) {
dlascl_("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) {
dlascl_("G", &c__0, &c__0, &smlnum, &bnrm, n, nrhs, &b[b_offset], ldb,
info);
} else if (ibscl == 2) {
dlascl_("G", &c__0, &c__0, &bignum, &bnrm, n, nrhs, &b[b_offset], ldb,
info);
}
L10:
work[1] = (doublereal) maxwrk;
return 0;
/* End of DGELSD */
} /* dgelsd_ */
/* Subroutine */ int dggev_(char *jobvl, char *jobvr, integer *n, doublereal *
a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar,
doublereal *alphai, doublereal *beta, doublereal *vl, integer *ldvl,
doublereal *vr, integer *ldvr, doublereal *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
=======
DGGEV computes for a pair of N-by-N real 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 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
=========
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) DOUBLE PRECISION 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) DOUBLE PRECISION 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).
ALPHAR (output) DOUBLE PRECISION array, dimension (N)
ALPHAI (output) DOUBLE PRECISION array, dimension (N)
BETA (output) DOUBLE PRECISION array, dimension (N)
On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will
be the generalized eigenvalues. If ALPHAI(j) is zero, then
the j-th eigenvalue is real; if positive, then the j-th and
(j+1)-st eigenvalues are a complex conjugate pair, with
ALPHAI(j+1) negative.
Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(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, ALPHAR and ALPHAI 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) DOUBLE PRECISION array, dimension (LDVL,N)
If JOBVL = 'V', the left eigenvectors u(j) are stored one
after another in the columns of VL, in the same order as
their eigenvalues. If the j-th eigenvalue is real, then
u(j) = VL(:,j), the j-th column of VL. If the j-th and
(j+1)-th eigenvalues form a complex conjugate pair, then
u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1).
Each eigenvector will be scaled so the largest component 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) DOUBLE PRECISION array, dimension (LDVR,N)
If JOBVR = 'V', the right eigenvectors v(j) are stored one
after another in the columns of VR, in the same order as
their eigenvalues. If the j-th eigenvalue is real, then
v(j) = VR(:,j), the j-th column of VR. If the j-th and
(j+1)-th eigenvalues form a complex conjugate pair, then
v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1).
Each eigenvector will be scaled so the largest component 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.
WORK (workspace/output) DOUBLE PRECISION 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,8*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.
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 ALPHAR(j), ALPHAI(j), and BETA(j)
should be correct for j=INFO+1,...,N.
> N: =N+1: other than QZ iteration failed in DHGEQZ.
=N+2: error return from DTGEVC.
=====================================================================
Decode the input arguments
Parameter adjustments */
/* Table of constant values */
static integer c__1 = 1;
static integer c__0 = 0;
static doublereal c_b26 = 0.;
static doublereal c_b27 = 1.;
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vl_dim1, vl_offset, vr_dim1,
vr_offset, i__1, i__2;
doublereal d__1, d__2, d__3, d__4;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
static doublereal anrm, bnrm;
static integer ierr, itau;
static doublereal temp;
static logical ilvl, ilvr;
static integer iwrk;
extern logical lsame_(char *, char *);
static integer ileft, icols, irows;
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *);
static integer jc;
extern /* Subroutine */ int dggbak_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublereal *,
integer *, integer *), dggbal_(char *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *,
integer *, doublereal *, doublereal *, doublereal *, integer *);
static integer in;
extern doublereal dlamch_(char *), dlange_(char *, integer *,
integer *, doublereal *, integer *, doublereal *);
static integer jr;
extern /* Subroutine */ int dgghrd_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *), dlascl_(char *, integer *, integer *, doublereal
*, doublereal *, integer *, integer *, doublereal *, integer *,
integer *);
static logical ilascl, ilbscl;
extern /* Subroutine */ int dgeqrf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dlacpy_(char *, integer *, integer *, doublereal *, integer *,
doublereal *, integer *), dlaset_(char *, integer *,
integer *, doublereal *, doublereal *, doublereal *, integer *), dtgevc_(char *, char *, logical *, integer *, doublereal
*, integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *, integer *, integer *, doublereal *,
integer *);
static logical ldumma[1];
static char chtemp[1];
static doublereal bignum;
extern /* Subroutine */ int dhgeqz_(char *, char *, char *, integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
integer *, doublereal *, integer *, doublereal *, integer *,
integer *), xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
static integer ijobvl, iright, ijobvr;
extern /* Subroutine */ int dorgqr_(integer *, integer *, integer *,
doublereal *, integer *, doublereal *, doublereal *, integer *,
integer *);
static doublereal anrmto, bnrmto;
extern /* Subroutine */ int dormqr_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *);
static integer minwrk, maxwrk;
static doublereal smlnum;
static logical lquery;
static integer ihi, ilo;
static doublereal eps;
static logical ilv;
#define a_ref(a_1,a_2) a[(a_2)*a_dim1 + a_1]
#define b_ref(a_1,a_2) b[(a_2)*b_dim1 + a_1]
#define vl_ref(a_1,a_2) vl[(a_2)*vl_dim1 + a_1]
#define vr_ref(a_1,a_2) vr[(a_2)*vr_dim1 + a_1]
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
--alphar;
--alphai;
--beta;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1 * 1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1 * 1;
vr -= vr_offset;
--work;
/* 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 = -12;
} else if (*ldvr < 1 || ilvr && *ldvr < *n) {
*info = -14;
}
/* 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.) */
minwrk = 1;
if (*info == 0 && (*lwork >= 1 || lquery)) {
maxwrk = *n * 7 + *n * ilaenv_(&c__1, "DGEQRF", " ", n, &c__1, n, &
c__0, (ftnlen)6, (ftnlen)1);
/* Computing MAX */
i__1 = 1, i__2 = *n << 3;
minwrk = max(i__1,i__2);
work[1] = (doublereal) maxwrk;
}
if (*lwork < minwrk && ! lquery) {
*info = -16;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DGGEV ", &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 = dlange_("M", n, n, &a[a_offset], lda, &work[1]);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE_;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl) {
dlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, &
ierr);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = dlange_("M", n, n, &b[b_offset], ldb, &work[1]);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE_;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl) {
dlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, &
ierr);
}
/* Permute the matrices A, B to isolate eigenvalues if possible
(Workspace: need 6*N) */
ileft = 1;
iright = *n + 1;
iwrk = iright + *n;
dggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &work[
ileft], &work[iright], &work[iwrk], &ierr);
/* Reduce B to triangular form (QR decomposition of B)
(Workspace: need N, prefer N*NB) */
irows = ihi + 1 - ilo;
if (ilv) {
icols = *n + 1 - ilo;
} else {
icols = irows;
}
itau = iwrk;
iwrk = itau + irows;
i__1 = *lwork + 1 - iwrk;
dgeqrf_(&irows, &icols, &b_ref(ilo, ilo), ldb, &work[itau], &work[iwrk], &
i__1, &ierr);
/* Apply the orthogonal transformation to matrix A
(Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
dormqr_("L", "T", &irows, &icols, &irows, &b_ref(ilo, ilo), ldb, &work[
itau], &a_ref(ilo, ilo), lda, &work[iwrk], &i__1, &ierr);
/* Initialize VL
(Workspace: need N, prefer N*NB) */
if (ilvl) {
dlaset_("Full", n, n, &c_b26, &c_b27, &vl[vl_offset], ldvl)
;
i__1 = irows - 1;
i__2 = irows - 1;
dlacpy_("L", &i__1, &i__2, &b_ref(ilo + 1, ilo), ldb, &vl_ref(ilo + 1,
ilo), ldvl);
i__1 = *lwork + 1 - iwrk;
dorgqr_(&irows, &irows, &irows, &vl_ref(ilo, ilo), ldvl, &work[itau],
&work[iwrk], &i__1, &ierr);
}
/* Initialize VR */
if (ilvr) {
dlaset_("Full", n, n, &c_b26, &c_b27, &vr[vr_offset], ldvr)
;
}
/* Reduce to generalized Hessenberg form
(Workspace: none needed) */
if (ilv) {
/* Eigenvectors requested -- work on whole matrix. */
dgghrd_(jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, &ierr);
} else {
dgghrd_("N", "N", &irows, &c__1, &irows, &a_ref(ilo, ilo), lda, &
b_ref(ilo, ilo), ldb, &vl[vl_offset], ldvl, &vr[vr_offset],
ldvr, &ierr);
}
/* Perform QZ algorithm (Compute eigenvalues, and optionally, the
Schur forms and Schur vectors)
(Workspace: need N) */
iwrk = itau;
if (ilv) {
*(unsigned char *)chtemp = 'S';
} else {
*(unsigned char *)chtemp = 'E';
}
i__1 = *lwork + 1 - iwrk;
dhgeqz_(chtemp, jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alphar[1], &alphai[1], &beta[1], &vl[vl_offset],
ldvl, &vr[vr_offset], ldvr, &work[iwrk], &i__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 L110;
}
/* Compute Eigenvectors
(Workspace: need 6*N) */
if (ilv) {
if (ilvl) {
if (ilvr) {
*(unsigned char *)chtemp = 'B';
} else {
*(unsigned char *)chtemp = 'L';
}
} else {
*(unsigned char *)chtemp = 'R';
}
dtgevc_(chtemp, "B", ldumma, n, &a[a_offset], lda, &b[b_offset], ldb,
&vl[vl_offset], ldvl, &vr[vr_offset], ldvr, n, &in, &work[
iwrk], &ierr);
if (ierr != 0) {
*info = *n + 2;
goto L110;
}
/* Undo balancing on VL and VR and normalization
(Workspace: none needed) */
if (ilvl) {
dggbak_("P", "L", n, &ilo, &ihi, &work[ileft], &work[iright], n, &
vl[vl_offset], ldvl, &ierr);
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
if (alphai[jc] < 0.) {
goto L50;
}
temp = 0.;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__2 = temp, d__3 = (d__1 = vl_ref(jr, jc), abs(d__1))
;
temp = max(d__2,d__3);
/* L10: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__3 = temp, d__4 = (d__1 = vl_ref(jr, jc), abs(d__1))
+ (d__2 = vl_ref(jr, jc + 1), abs(d__2));
temp = max(d__3,d__4);
/* L20: */
}
}
if (temp < smlnum) {
goto L50;
}
temp = 1. / temp;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vl_ref(jr, jc) = vl_ref(jr, jc) * temp;
/* L30: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vl_ref(jr, jc) = vl_ref(jr, jc) * temp;
vl_ref(jr, jc + 1) = vl_ref(jr, jc + 1) * temp;
/* L40: */
}
}
L50:
;
}
}
if (ilvr) {
dggbak_("P", "R", n, &ilo, &ihi, &work[ileft], &work[iright], n, &
vr[vr_offset], ldvr, &ierr);
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
if (alphai[jc] < 0.) {
goto L100;
}
temp = 0.;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__2 = temp, d__3 = (d__1 = vr_ref(jr, jc), abs(d__1))
;
temp = max(d__2,d__3);
/* L60: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__3 = temp, d__4 = (d__1 = vr_ref(jr, jc), abs(d__1))
+ (d__2 = vr_ref(jr, jc + 1), abs(d__2));
temp = max(d__3,d__4);
/* L70: */
}
}
if (temp < smlnum) {
goto L100;
}
temp = 1. / temp;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr_ref(jr, jc) = vr_ref(jr, jc) * temp;
/* L80: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr_ref(jr, jc) = vr_ref(jr, jc) * temp;
vr_ref(jr, jc + 1) = vr_ref(jr, jc + 1) * temp;
/* L90: */
}
}
L100:
;
}
}
/* End of eigenvector calculation */
}
/* Undo scaling if necessary */
if (ilascl) {
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alphar[1], n, &
ierr);
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alphai[1], n, &
ierr);
}
if (ilbscl) {
dlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, &
ierr);
}
L110:
work[1] = (doublereal) maxwrk;
return 0;
/* End of DGGEV */
} /* dggev_ */
/* Subroutine */ int dggevx_(char *balanc, char *jobvl, char *jobvr, char *
sense, integer *n, doublereal *a, integer *lda, doublereal *b,
integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *
beta, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr,
integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale,
doublereal *abnrm, doublereal *bbnrm, doublereal *rconde, doublereal *
rcondv, doublereal *work, integer *lwork, 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;
doublereal d__1, d__2, d__3, d__4;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
integer i__, j, m, jc, in, mm, jr;
doublereal eps;
logical ilv, pair;
doublereal anrm, bnrm;
integer ierr, itau;
doublereal temp;
logical ilvl, ilvr;
integer iwrk, iwrk1;
extern logical lsame_(char *, char *);
integer icols;
logical noscl;
integer irows;
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *), dggbak_(
char *, char *, integer *, integer *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, integer *), dggbal_(char *, integer *, doublereal *, integer
*, doublereal *, integer *, integer *, integer *, doublereal *,
doublereal *, doublereal *, integer *);
extern doublereal dlamch_(char *), dlange_(char *, integer *,
integer *, doublereal *, integer *, doublereal *);
extern /* Subroutine */ int dgghrd_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *), dlascl_(char *, integer *, integer *, doublereal
*, doublereal *, integer *, integer *, doublereal *, integer *,
integer *);
logical ilascl, ilbscl;
extern /* Subroutine */ int dgeqrf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dlacpy_(char *, integer *, integer *, doublereal *, integer *,
doublereal *, integer *), dlaset_(char *, integer *,
integer *, doublereal *, doublereal *, doublereal *, integer *);
logical ldumma[1];
char chtemp[1];
doublereal bignum;
extern /* Subroutine */ int dhgeqz_(char *, char *, char *, integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
integer *, doublereal *, integer *, doublereal *, integer *,
integer *), dtgevc_(char *, char *,
logical *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, integer *, doublereal *, integer *,
integer *, integer *, doublereal *, integer *);
integer ijobvl;
extern /* Subroutine */ int dtgsna_(char *, char *, logical *, integer *,
doublereal *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, integer *, doublereal *, integer *, integer *, integer
*), xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
integer ijobvr;
logical wantsb;
extern /* Subroutine */ int dorgqr_(integer *, integer *, integer *,
doublereal *, integer *, doublereal *, doublereal *, integer *,
integer *);
doublereal anrmto;
logical wantse;
doublereal bnrmto;
extern /* Subroutine */ int dormqr_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *);
integer minwrk, maxwrk;
logical wantsn;
doublereal smlnum;
logical lquery, wantsv;
/* -- LAPACK driver routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DGGEVX computes for a pair of N-by-N real nonsymmetric matrices (A,B) */
/* the generalized eigenvalues, and optionally, the left and/or right */
/* generalized eigenvectors. */
/* Optionally also, it 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) DOUBLE PRECISION 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 real 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) DOUBLE PRECISION 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 real Schur */
/* form of the "balanced" versions of the input A and B. */
/* LDB (input) INTEGER */
/* The leading dimension of B. LDB >= max(1,N). */
/* ALPHAR (output) DOUBLE PRECISION array, dimension (N) */
/* ALPHAI (output) DOUBLE PRECISION array, dimension (N) */
/* BETA (output) DOUBLE PRECISION array, dimension (N) */
/* On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will */
/* be the generalized eigenvalues. If ALPHAI(j) is zero, then */
/* the j-th eigenvalue is real; if positive, then the j-th and */
/* (j+1)-st eigenvalues are a complex conjugate pair, with */
/* ALPHAI(j+1) negative. */
/* Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(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, ALPHAR and ALPHAI 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) DOUBLE PRECISION array, dimension (LDVL,N) */
/* If JOBVL = 'V', the left eigenvectors u(j) are stored one */
/* after another in the columns of VL, in the same order as */
/* their eigenvalues. If the j-th eigenvalue is real, then */
/* u(j) = VL(:,j), the j-th column of VL. If the j-th and */
/* (j+1)-th eigenvalues form a complex conjugate pair, then */
/* u(j) = VL(:,j)+i*VL(:,j+1) and u(j+1) = VL(:,j)-i*VL(:,j+1). */
/* Each eigenvector will be scaled so the largest component 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) DOUBLE PRECISION array, dimension (LDVR,N) */
/* If JOBVR = 'V', the right eigenvectors v(j) are stored one */
/* after another in the columns of VR, in the same order as */
/* their eigenvalues. If the j-th eigenvalue is real, then */
/* v(j) = VR(:,j), the j-th column of VR. If the j-th and */
/* (j+1)-th eigenvalues form a complex conjugate pair, then */
/* v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1). */
/* Each eigenvector will be scaled so the largest component 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 */
/* j = 1,...,ILO-1 or i = IHI+1,...,N. */
/* 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 */
/* LSCALE(j) = PL(j) for j = 1,...,ILO-1 */
/* = DL(j) for j = ILO,...,IHI */
/* = PL(j) for j = IHI+1,...,N. */
/* 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 */
/* RSCALE(j) = PR(j) for j = 1,...,ILO-1 */
/* = DR(j) for j = ILO,...,IHI */
/* = PR(j) for j = IHI+1,...,N */
/* 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. */
/* For a complex conjugate pair of eigenvalues two consecutive */
/* elements of RCONDE are set to the same value. Thus RCONDE(j), */
/* RCONDV(j), and the j-th columns of VL and VR all correspond */
/* to the j-th eigenpair. */
/* If SENSE = 'N or 'V', RCONDE is not referenced. */
/* RCONDV (output) DOUBLE PRECISION array, dimension (N) */
/* If SENSE = 'V' or 'B', the estimated reciprocal condition */
/* numbers of the eigenvectors, stored in consecutive elements */
/* of the array. For a complex eigenvector two consecutive */
/* elements of RCONDV are set to the same value. 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) DOUBLE PRECISION 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 BALANC = 'S' or 'B', or JOBVL = 'V', or JOBVR = 'V', */
/* LWORK >= max(1,6*N). */
/* If SENSE = 'E' or 'B', LWORK >= max(1,10*N). */
/* If SENSE = 'V' or 'B', LWORK >= 2*N*N+8*N+16. */
/* 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. */
/* IWORK (workspace) INTEGER array, dimension (N+6) */
/* 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. */
/* = 1,...,N: */
/* The QZ iteration failed. No eigenvectors have been */
/* calculated, but ALPHAR(j), ALPHAI(j), and BETA(j) */
/* should be correct for j=INFO+1,...,N. */
/* > N: =N+1: other than QZ iteration failed in DHGEQZ. */
/* =N+2: error return from DTGEVC. */
/* 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. */
/* ===================================================================== */
/* .. 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;
--alphar;
--alphai;
--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;
--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 (! (lsame_(balanc, "N") || lsame_(balanc, "S") || lsame_(balanc, "P")
|| 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 = -14;
} else if (*ldvr < 1 || ilvr && *ldvr < *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. The workspace is */
/* computed assuming ILO = 1 and IHI = N, the worst case.) */
if (*info == 0) {
if (*n == 0) {
minwrk = 1;
maxwrk = 1;
} else {
if (noscl && ! ilv) {
minwrk = *n << 1;
} else {
minwrk = *n * 6;
}
if (wantse || wantsb) {
minwrk = *n * 10;
}
if (wantsv || wantsb) {
/* Computing MAX */
i__1 = minwrk, i__2 = (*n << 1) * (*n + 4) + 16;
minwrk = max(i__1,i__2);
}
maxwrk = minwrk;
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *n * ilaenv_(&c__1, "DGEQRF", " ", n, &
c__1, n, &c__0);
maxwrk = max(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + *n * ilaenv_(&c__1, "DORMQR", " ", 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, "DORGQR",
" ", n, &c__1, n, &c__0);
maxwrk = max(i__1,i__2);
}
}
work[1] = (doublereal) maxwrk;
if (*lwork < minwrk && ! lquery) {
*info = -26;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DGGEVX", &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 = dlange_("M", n, n, &a[a_offset], lda, &work[1]);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE_;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl) {
dlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, &
ierr);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = dlange_("M", n, n, &b[b_offset], ldb, &work[1]);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE_;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl) {
dlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, &
ierr);
}
/* Permute and/or balance the matrix pair (A,B) */
/* (Workspace: need 6*N if BALANC = 'S' or 'B', 1 otherwise) */
dggbal_(balanc, n, &a[a_offset], lda, &b[b_offset], ldb, ilo, ihi, &
lscale[1], &rscale[1], &work[1], &ierr);
/* Compute ABNRM and BBNRM */
*abnrm = dlange_("1", n, n, &a[a_offset], lda, &work[1]);
if (ilascl) {
work[1] = *abnrm;
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, &c__1, &c__1, &work[1], &
c__1, &ierr);
*abnrm = work[1];
}
*bbnrm = dlange_("1", n, n, &b[b_offset], ldb, &work[1]);
if (ilbscl) {
work[1] = *bbnrm;
dlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, &c__1, &c__1, &work[1], &
c__1, &ierr);
*bbnrm = work[1];
}
/* Reduce B to triangular form (QR decomposition of B) */
/* (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;
dgeqrf_(&irows, &icols, &b[*ilo + *ilo * b_dim1], ldb, &work[itau], &work[
iwrk], &i__1, &ierr);
/* Apply the orthogonal transformation to A */
/* (Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
dormqr_("L", "T", &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) {
dlaset_("Full", n, n, &c_b59, &c_b60, &vl[vl_offset], ldvl)
;
if (irows > 1) {
i__1 = irows - 1;
i__2 = irows - 1;
dlacpy_("L", &i__1, &i__2, &b[*ilo + 1 + *ilo * b_dim1], ldb, &vl[
*ilo + 1 + *ilo * vl_dim1], ldvl);
}
i__1 = *lwork + 1 - iwrk;
dorgqr_(&irows, &irows, &irows, &vl[*ilo + *ilo * vl_dim1], ldvl, &
work[itau], &work[iwrk], &i__1, &ierr);
}
if (ilvr) {
dlaset_("Full", n, n, &c_b59, &c_b60, &vr[vr_offset], ldvr)
;
}
/* Reduce to generalized Hessenberg form */
/* (Workspace: none needed) */
if (ilv || ! wantsn) {
/* Eigenvectors requested -- work on whole matrix. */
dgghrd_(jobvl, jobvr, n, ilo, ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, &ierr);
} else {
dgghrd_("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) */
/* (Workspace: need N) */
if (ilv || ! wantsn) {
*(unsigned char *)chtemp = 'S';
} else {
*(unsigned char *)chtemp = 'E';
}
dhgeqz_(chtemp, jobvl, jobvr, n, ilo, ihi, &a[a_offset], lda, &b[b_offset]
, ldb, &alphar[1], &alphai[1], &beta[1], &vl[vl_offset], ldvl, &
vr[vr_offset], ldvr, &work[1], lwork, &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 L130;
}
/* Compute Eigenvectors and estimate condition numbers if desired */
/* (Workspace: DTGEVC: need 6*N */
/* DTGSNA: need 2*N*(N+2)+16 if SENSE = 'V' or 'B', */
/* need N otherwise ) */
if (ilv || ! wantsn) {
if (ilv) {
if (ilvl) {
if (ilvr) {
*(unsigned char *)chtemp = 'B';
} else {
*(unsigned char *)chtemp = 'L';
}
} else {
*(unsigned char *)chtemp = 'R';
}
dtgevc_(chtemp, "B", ldumma, n, &a[a_offset], lda, &b[b_offset],
ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, n, &in, &
work[1], &ierr);
if (ierr != 0) {
*info = *n + 2;
goto L130;
}
}
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 recalculate */
/* eigenvectors and estimate one condition numbers at a time. */
pair = FALSE_;
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
if (pair) {
pair = FALSE_;
goto L20;
}
mm = 1;
if (i__ < *n) {
if (a[i__ + 1 + i__ * a_dim1] != 0.) {
pair = TRUE_;
mm = 2;
}
}
i__2 = *n;
for (j = 1; j <= i__2; ++j) {
bwork[j] = FALSE_;
/* L10: */
}
if (mm == 1) {
bwork[i__] = TRUE_;
} else if (mm == 2) {
bwork[i__] = TRUE_;
bwork[i__ + 1] = TRUE_;
}
iwrk = mm * *n + 1;
iwrk1 = iwrk + mm * *n;
/* Compute a pair of left and right eigenvectors. */
/* (compute workspace: need up to 4*N + 6*N) */
if (wantse || wantsb) {
dtgevc_("B", "S", &bwork[1], n, &a[a_offset], lda, &b[
b_offset], ldb, &work[1], n, &work[iwrk], n, &mm,
&m, &work[iwrk1], &ierr);
if (ierr != 0) {
*info = *n + 2;
goto L130;
}
}
i__2 = *lwork - iwrk1 + 1;
dtgsna_(sense, "S", &bwork[1], n, &a[a_offset], lda, &b[
b_offset], ldb, &work[1], n, &work[iwrk], n, &rconde[
i__], &rcondv[i__], &mm, &m, &work[iwrk1], &i__2, &
iwork[1], &ierr);
L20:
;
}
}
}
/* Undo balancing on VL and VR and normalization */
/* (Workspace: none needed) */
if (ilvl) {
dggbak_(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) {
if (alphai[jc] < 0.) {
goto L70;
}
temp = 0.;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__2 = temp, d__3 = (d__1 = vl[jr + jc * vl_dim1], abs(
d__1));
temp = max(d__2,d__3);
/* L30: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__3 = temp, d__4 = (d__1 = vl[jr + jc * vl_dim1], abs(
d__1)) + (d__2 = vl[jr + (jc + 1) * vl_dim1], abs(
d__2));
temp = max(d__3,d__4);
/* L40: */
}
}
if (temp < smlnum) {
goto L70;
}
temp = 1. / temp;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vl[jr + jc * vl_dim1] *= temp;
/* L50: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vl[jr + jc * vl_dim1] *= temp;
vl[jr + (jc + 1) * vl_dim1] *= temp;
/* L60: */
}
}
L70:
;
}
}
if (ilvr) {
dggbak_(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) {
if (alphai[jc] < 0.) {
goto L120;
}
temp = 0.;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__2 = temp, d__3 = (d__1 = vr[jr + jc * vr_dim1], abs(
d__1));
temp = max(d__2,d__3);
/* L80: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__3 = temp, d__4 = (d__1 = vr[jr + jc * vr_dim1], abs(
d__1)) + (d__2 = vr[jr + (jc + 1) * vr_dim1], abs(
d__2));
temp = max(d__3,d__4);
/* L90: */
}
}
if (temp < smlnum) {
goto L120;
}
temp = 1. / temp;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr[jr + jc * vr_dim1] *= temp;
/* L100: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr[jr + jc * vr_dim1] *= temp;
vr[jr + (jc + 1) * vr_dim1] *= temp;
/* L110: */
}
}
L120:
;
}
}
/* Undo scaling if necessary */
if (ilascl) {
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alphar[1], n, &
ierr);
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alphai[1], n, &
ierr);
}
if (ilbscl) {
dlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, &
ierr);
}
L130:
work[1] = (doublereal) maxwrk;
return 0;
/* End of DGGEVX */
} /* dggevx_ */
// Type overloads for C++
inline void geqrf( const int & m, const int & n, double da[], const int & lda, double dtau[], double dwork[], const int& ldwork, int& info)
{
dgeqrf_(m,n,da,lda,dtau,dwork,ldwork,info);
}
int main ( int argc, char * argv[]) {
double **x, **y;
double R[N][N], T[N];
double Q[N][N], tau[N];
double rQ[N][N], rQnew[N][N], H[N][N], v[N];
char pdbname1 [150] = "\0";
char pdbname2 [150] = "\0";
char pdbid1 [50] = "\0"; /* this might be too restrictive */
char pdbid2 [50] = "\0";
char filename [150] = "\0";
int component, ctr;
int no_vectors;
int h, i, j, k;
double sum = 0;
Residue * sequence_new;
int read_pdb ( char * pdbname, Residue ** sequence, int *no_res);
void dgels_ (char * trans, int * no_rows, int * no_columns, int * ,
double ** scratch, int *,
double **A, int *, double * work, int * lwork, int *info);
void dgeqrf_ (int *M, int *, double **A, int *LDA, double * TAU,
double * WORK, int * LWORK, int *INFO );
int calphas_to_XY ( double *** x, double ***y, char * name_x,
char *name_y, int * no_matching_residues);
int transform (double tfm_matrix[][N], double * transl_vector,
Residue * seqeunce, int no_res, Residue * seqeunce_new);
int pdb_output ( char *filename, Residue * sequence_new, int no_res);
if ( argc < 2 ) {
printf ( "Usage: %s <pdbname1> <pdbname2>.\n", argv[0] );
printf ( "(To transform <pdbname1> into <pdbname2>;");
printf ( " the alignment btw the two pdb files assumed).\n");
exit (1);
}
sprintf ( pdbname1, "%s", argv[1]);
sprintf ( pdbname2, "%s", argv[2]);
memcpy (pdbid1, pdbname1, strlen (pdbname1) - 4); /* get rid of the pdb extension */
memcpy (pdbid2, pdbname2, strlen (pdbname2) - 4);
/* input two pdbs */
if ( read_pdb ( pdbname1, &sequence1, &no_res_1)) exit (1);
if ( read_pdb ( pdbname2, &sequence2, &no_res_2)) exit (1);
/* turn the matching atoms into vectors x and y - use only c-alphas*/
calphas_to_XY ( &x, &y, pdbid1, pdbid2, &no_vectors);
/* check: */
if (0) {
printf (" Number of vectors read in: %d. \n", no_vectors);
for ( ctr =0; ctr < no_vectors; ctr++ ) {
printf ("\t x%1d %10.4lf %10.4lf %10.4lf ",
ctr, x[0][ctr], x[1][ctr], x[2][ctr]);
printf ("\t y%1d %10.4lf %10.4lf %10.4lf \n",
ctr, y[0][ctr], y[1][ctr], y[2][ctr]);
}
}
exit (1);
/* make the fourth component of x equal to 1 - a trick to incorporate translation into A */
for (ctr =0; ctr < no_vectors; ctr++) x[3][ctr] = 1.0;
/* solve the least squares problem - use the nomenclature from dgels */
char trans= 'N';
int info;
int lwork = 2*no_vectors;
double work [2*no_vectors];
int n = N;
double A[N+1][no_vectors];
int no_rows = no_vectors, no_columns = N+1;
int lead_dim_A = no_vectors;
double B[N][no_vectors];
int lead_dim_B = no_vectors;
memcpy (A[0], x[0], (N+1)*no_vectors*sizeof(double));
memcpy (B[0], y[0], N*no_vectors*sizeof(double));
dgels_ ( &trans, &no_rows, &no_columns, &n, &A, &lead_dim_A,
&B, &lead_dim_B, work, &lwork, &info);
printf (" info: %d\n", info);
printf ("******************************************************\n");
printf (" solution: \n" );
for ( ctr =0; ctr < N; ctr++ ) {
for ( component=0; component<N+1; component++) {
printf ("%10.3lf", B[ctr][component]);
}
printf ("\n");
}
printf ("\n");
printf ("******************************************************\n");
/* rotation and translation parts*/
for ( i =0; i < N; i++ ) {
for ( j =0; j < N; j++ ) {
R[i][j] = B[i][j];
}
T[i] = B[i][N];
}
/* rotate and translate the first chain */
sequence_new = emalloc ( no_res_1 * sizeof(Residue));
memcpy ( sequence_new, sequence1, no_res_1 * sizeof(Residue));
transform ( R, T, sequence1, no_res_1, sequence_new );
/* output the transformed chain */
sprintf (filename, "%s", "transformed.pdb");
pdb_output ( filename, sequence_new, no_res_1);
/* is the solution orthogonal? */
printf (" orthogonal?\n" );
for ( i =0; i < N; i++ ) {
for ( j =0; j < N; j++ ) {
sum = 0.0;
for ( component=0; component<N; component++) {
sum += R[i][component]*R[j][component];
}
printf ("%10.3lf", sum);
}
printf ("\n");
}
printf ("\n");
printf ("******************************************************\n");
/* no reason to believe it will be orthogonal, so orthogonalize using QR decomp: */
/* find decomposition: */
for ( i =0; i < N; i++ ) {
for ( j =0; j < N; j++ ) {
Q[i][j] = B[j][i];
}
}
n = N;
dgeqrf_ ( &n, &n, &Q, &n, tau, work, &lwork, &info);
if ( info ) {
fprintf ( stderr, "Error running dgeqrf. Info: %d.\n", info);
exit (1);
}
/* reconstruct Q: */
/*extract R*/
for ( i =0; i < n; i++ ) {
for ( j =0; j < i; j++ ) {
R[i][j] = 0.0;
}
for ( j =i; j < n; j++ ) {
R[i][j] = Q[j][i];
}
}
/* reconstruct Q (I could not get the orginal LAPACK function to work: */
memset( rQ[0], 0, n*n*sizeof(double));
rQ[0][0] = rQ[1][1] = rQ[2][2] = 1.0;
for ( h =0; h < n; h++ ) {
/* find vh*/
for ( i=0; i<h; i++ ) v[i] = 0.0;
v[h] = 1.0;
for ( i=h+1; i<n; i++ ) v[i] = Q[h][i];
/* find Hh */
for ( i =0; i < n; i++ ) {
H[i][i] = 1.0 -tau[h]*v[i]*v[i];
for ( j =i+1; j < n; j++ ) {
H[i][j] = H[j][i] = -tau[h]*v[i]*v[j];
}
}
/* multiply rQ by Hi */
for ( i =0; i < n; i++ ) {
for ( j =0; j < n; j++ ) {
rQnew[i][j] = 0.0;
for ( k =0; k < n; k++ ) {
rQnew[i][j] += rQ[i][k]*H[k][j];
}
}
}
memcpy ( rQ[0], rQnew[0], n*n*sizeof(double));
}
/* to get as close as possible to the original matrix, require that diagonals
in R be positive (in the limiting case when the input matrix is already
orthogonal, R should be I */
for ( i =0; i < n; i++ ) {
if ( R[i][i] < 0 ) {
for ( j =0; j < n; j++ ) {
rQ[j][i] *= -1;
R [i][j] *= -1;
}
}
}
printf ("Q reconstructed \n");
for ( i =0; i < n; i++ ) {
for ( j =0; j < n; j++ ) {
printf ("%10.3lf", rQ[i][j]);
}
printf ("\n");
}
printf ("\n");
printf ("******************************************************\n");
printf ("R: \n");
for ( i =0; i < n; i++ ) {
for ( j =0; j < n; j++ ) {
printf ("%10.3lf", R[i][j]);
}
printf ("\n");
}
printf ("\n");
printf ("******************************************************\n");
printf ("final orthogonality\n");
for ( i =0; i < n; i++ ) {
for ( j =0; j < n; j++ ) {
sum = 0.0;
for ( component=0; component<n; component++) {
sum += rQ[component][i]*rQ[component][j];
}
printf ("%10.3lf", sum);
}
printf ("\n");
}
printf ("\n");
printf ("******************************************************\n");
printf ("QRproduct\n");
for ( i =0; i < n; i++ ) {
for ( j =0; j < n; j++ ) {
sum = 0.0;
for ( component=0; component<n; component++) {
sum += rQ[i][component]*R[component][j];
}
printf ("%10.3lf", sum);
}
printf ("\n");
}
printf ("\n");
printf ("******************************************************\n");
/* rotate and translate the first chain */
memcpy ( sequence_new, sequence1, no_res_1 * sizeof(Residue));
transform ( rQ, T, sequence1, no_res_1, sequence_new );
/* output the transformed chain */
sprintf (filename, "%s", "rotated.pdb");
pdb_output ( filename, sequence_new, no_res_1);
return 0;
}
/* Subroutine */ int dgges_(char *jobvsl, char *jobvsr, char *sort, L_fp
selctg, integer *n, doublereal *a, integer *lda, doublereal *b,
integer *ldb, integer *sdim, doublereal *alphar, doublereal *alphai,
doublereal *beta, doublereal *vsl, integer *ldvsl, doublereal *vsr,
integer *ldvsr, doublereal *work, integer *lwork, 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;
doublereal d__1;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
integer i__, ip;
doublereal dif[2];
integer ihi, ilo;
doublereal eps, anrm, bnrm;
integer idum[1], ierr, itau, iwrk;
doublereal pvsl, pvsr;
extern logical lsame_(char *, char *);
integer ileft, icols;
logical cursl, ilvsl, ilvsr;
integer irows;
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *), dggbak_(
char *, char *, integer *, integer *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, integer *), dggbal_(char *, integer *, doublereal *, integer
*, doublereal *, integer *, integer *, integer *, doublereal *,
doublereal *, doublereal *, integer *);
logical lst2sl;
extern doublereal dlamch_(char *), dlange_(char *, integer *,
integer *, doublereal *, integer *, doublereal *);
extern /* Subroutine */ int dgghrd_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *), dlascl_(char *, integer *, integer *, doublereal
*, doublereal *, integer *, integer *, doublereal *, integer *,
integer *);
logical ilascl, ilbscl;
extern /* Subroutine */ int dgeqrf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dlacpy_(char *, integer *, integer *, doublereal *, integer *,
doublereal *, integer *);
doublereal safmin;
extern /* Subroutine */ int dlaset_(char *, integer *, integer *,
doublereal *, doublereal *, doublereal *, integer *);
doublereal safmax;
extern /* Subroutine */ int xerbla_(char *, integer *);
doublereal bignum;
extern /* Subroutine */ int dhgeqz_(char *, char *, char *, integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
integer *, doublereal *, integer *, doublereal *, integer *,
integer *), dtgsen_(integer *, logical *,
logical *, logical *, integer *, doublereal *, integer *,
doublereal *, integer *, doublereal *, doublereal *, doublereal *,
doublereal *, integer *, doublereal *, integer *, integer *,
doublereal *, doublereal *, doublereal *, doublereal *, integer *,
integer *, integer *, integer *);
integer ijobvl, iright;
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
integer ijobvr;
extern /* Subroutine */ int dorgqr_(integer *, integer *, integer *,
doublereal *, integer *, doublereal *, doublereal *, integer *,
integer *);
doublereal anrmto, bnrmto;
logical lastsl;
extern /* Subroutine */ int dormqr_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *);
integer minwrk, maxwrk;
doublereal smlnum;
logical wantst, lquery;
/* -- LAPACK driver routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* .. Function Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DGGES computes for a pair of N-by-N real nonsymmetric matrices (A,B), */
/* the generalized eigenvalues, the generalized real Schur form (S,T), */
/* optionally, the left and/or right matrices of Schur vectors (VSL and */
/* VSR). This gives the generalized Schur factorization */
/* (A,B) = ( (VSL)*S*(VSR)**T, (VSL)*T*(VSR)**T ) */
/* Optionally, it also orders the eigenvalues so that a selected cluster */
/* of eigenvalues appears in the leading diagonal blocks of the upper */
/* quasi-triangular matrix S and the upper triangular matrix T.The */
/* leading columns of VSL and VSR then form an orthonormal basis for the */
/* corresponding left and right eigenspaces (deflating subspaces). */
/* (If only the generalized eigenvalues are needed, use the driver */
/* DGGEV 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 or both being zero. */
/* A pair of matrices (S,T) is in generalized real Schur form if T is */
/* upper triangular with non-negative diagonal and S is block upper */
/* triangular with 1-by-1 and 2-by-2 blocks. 1-by-1 blocks correspond */
/* to real generalized eigenvalues, while 2-by-2 blocks of S will be */
/* "standardized" by making the corresponding elements of T have the */
/* form: */
/* [ a 0 ] */
/* [ 0 b ] */
/* and the pair of corresponding 2-by-2 blocks in S and T will have a */
/* complex conjugate pair of generalized eigenvalues. */
/* 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 three DOUBLE PRECISION 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 (ALPHAR(j)+ALPHAI(j))/BETA(j) is selected if */
/* SELCTG(ALPHAR(j),ALPHAI(j),BETA(j)) is true; i.e. if either */
/* one of a complex conjugate pair of eigenvalues is selected, */
/* then both complex eigenvalues are selected. */
/* Note that in the ill-conditioned case, a selected complex */
/* eigenvalue may no longer satisfy SELCTG(ALPHAR(j),ALPHAI(j), */
/* BETA(j)) = .TRUE. after ordering. INFO is to be set to N+2 */
/* in this case. */
/* N (input) INTEGER */
/* The order of the matrices A, B, VSL, and VSR. N >= 0. */
/* A (input/output) DOUBLE PRECISION 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) DOUBLE PRECISION 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. (Complex conjugate pairs for which */
/* SELCTG is true for either eigenvalue count as 2.) */
/* ALPHAR (output) DOUBLE PRECISION array, dimension (N) */
/* ALPHAI (output) DOUBLE PRECISION array, dimension (N) */
/* BETA (output) DOUBLE PRECISION array, dimension (N) */
/* On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will */
/* be the generalized eigenvalues. ALPHAR(j) + ALPHAI(j)*i, */
/* and BETA(j),j=1,...,N are the diagonals of the complex Schur */
/* form (S,T) that would result if the 2-by-2 diagonal blocks of */
/* the real Schur form of (A,B) were further reduced to */
/* triangular form using 2-by-2 complex unitary transformations. */
/* If ALPHAI(j) is zero, then the j-th eigenvalue is real; if */
/* positive, then the j-th and (j+1)-st eigenvalues are a */
/* complex conjugate pair, with ALPHAI(j+1) negative. */
/* Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(j)/BETA(j) */
/* may easily over- or underflow, and BETA(j) may even be zero. */
/* Thus, the user should avoid naively computing the ratio. */
/* However, ALPHAR and ALPHAI 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) DOUBLE PRECISION 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) DOUBLE PRECISION 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) DOUBLE PRECISION 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. */
/* If N = 0, LWORK >= 1, else LWORK >= 8*N+16. */
/* 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. */
/* 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 ALPHAR(j), ALPHAI(j), and BETA(j) should */
/* be correct for j=INFO+1,...,N. */
/* > N: =N+1: other than QZ iteration failed in DHGEQZ. */
/* =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 failed in DTGSEN. */
/* ===================================================================== */
/* .. 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;
--alphar;
--alphai;
--beta;
vsl_dim1 = *ldvsl;
vsl_offset = 1 + vsl_dim1;
vsl -= vsl_offset;
vsr_dim1 = *ldvsr;
vsr_offset = 1 + vsr_dim1;
vsr -= vsr_offset;
--work;
--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 = -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) {
/* Computing MAX */
i__1 = *n << 3, i__2 = *n * 6 + 16;
minwrk = max(i__1,i__2);
maxwrk = minwrk - *n + *n * ilaenv_(&c__1, "DGEQRF", " ", n, &
c__1, n, &c__0);
/* Computing MAX */
i__1 = maxwrk, i__2 = minwrk - *n + *n * ilaenv_(&c__1, "DORMQR",
" ", n, &c__1, n, &c_n1);
maxwrk = max(i__1,i__2);
if (ilvsl) {
/* Computing MAX */
i__1 = maxwrk, i__2 = minwrk - *n + *n * ilaenv_(&c__1, "DOR"
"GQR", " ", n, &c__1, n, &c_n1);
maxwrk = max(i__1,i__2);
}
} else {
minwrk = 1;
maxwrk = 1;
}
work[1] = (doublereal) maxwrk;
if (*lwork < minwrk && ! lquery) {
*info = -19;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DGGES ", &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");
safmin = dlamch_("S");
safmax = 1. / safmin;
dlabad_(&safmin, &safmax);
smlnum = sqrt(safmin) / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = dlange_("M", n, n, &a[a_offset], lda, &work[1]);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE_;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl) {
dlascl_("G", &c__0, &c__0, &anrm, &anrmto, n, n, &a[a_offset], lda, &
ierr);
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = dlange_("M", n, n, &b[b_offset], ldb, &work[1]);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE_;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl) {
dlascl_("G", &c__0, &c__0, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, &
ierr);
}
/* Permute the matrix to make it more nearly triangular */
/* (Workspace: need 6*N + 2*N space for storing balancing factors) */
ileft = 1;
iright = *n + 1;
iwrk = iright + *n;
dggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &work[
ileft], &work[iright], &work[iwrk], &ierr);
/* Reduce B to triangular form (QR decomposition of B) */
/* (Workspace: need N, prefer N*NB) */
irows = ihi + 1 - ilo;
icols = *n + 1 - ilo;
itau = iwrk;
iwrk = itau + irows;
i__1 = *lwork + 1 - iwrk;
dgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[
iwrk], &i__1, &ierr);
/* Apply the orthogonal transformation to matrix A */
/* (Workspace: need N, prefer N*NB) */
i__1 = *lwork + 1 - iwrk;
dormqr_("L", "T", &irows, &icols, &irows, &b[ilo + ilo * b_dim1], ldb, &
work[itau], &a[ilo + ilo * a_dim1], lda, &work[iwrk], &i__1, &
ierr);
/* Initialize VSL */
/* (Workspace: need N, prefer N*NB) */
if (ilvsl) {
dlaset_("Full", n, n, &c_b38, &c_b39, &vsl[vsl_offset], ldvsl);
if (irows > 1) {
i__1 = irows - 1;
i__2 = irows - 1;
dlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vsl[
ilo + 1 + ilo * vsl_dim1], ldvsl);
}
i__1 = *lwork + 1 - iwrk;
dorgqr_(&irows, &irows, &irows, &vsl[ilo + ilo * vsl_dim1], ldvsl, &
work[itau], &work[iwrk], &i__1, &ierr);
}
/* Initialize VSR */
if (ilvsr) {
dlaset_("Full", n, n, &c_b38, &c_b39, &vsr[vsr_offset], ldvsr);
}
/* Reduce to generalized Hessenberg form */
/* (Workspace: none needed) */
dgghrd_(jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vsl[vsl_offset], ldvsl, &vsr[vsr_offset], ldvsr, &ierr);
/* Perform QZ algorithm, computing Schur vectors if desired */
/* (Workspace: need N) */
iwrk = itau;
i__1 = *lwork + 1 - iwrk;
dhgeqz_("S", jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alphar[1], &alphai[1], &beta[1], &vsl[vsl_offset]
, ldvsl, &vsr[vsr_offset], ldvsr, &work[iwrk], &i__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 L50;
}
/* Sort eigenvalues ALPHA/BETA if desired */
/* (Workspace: need 4*N+16 ) */
*sdim = 0;
if (wantst) {
/* Undo scaling on eigenvalues before SELCTGing */
if (ilascl) {
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alphar[1],
n, &ierr);
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alphai[1],
n, &ierr);
}
if (ilbscl) {
dlascl_("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)(&alphar[i__], &alphai[i__], &beta[i__]);
/* L10: */
}
i__1 = *lwork - iwrk + 1;
dtgsen_(&c__0, &ilvsl, &ilvsr, &bwork[1], n, &a[a_offset], lda, &b[
b_offset], ldb, &alphar[1], &alphai[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) {
dggbak_("P", "L", n, &ilo, &ihi, &work[ileft], &work[iright], n, &vsl[
vsl_offset], ldvsl, &ierr);
}
if (ilvsr) {
dggbak_("P", "R", n, &ilo, &ihi, &work[ileft], &work[iright], n, &vsr[
vsr_offset], ldvsr, &ierr);
}
/* Check if unscaling would cause over/underflow, if so, rescale */
/* (ALPHAR(I),ALPHAI(I),BETA(I)) so BETA(I) is on the order of */
/* B(I,I) and ALPHAR(I) and ALPHAI(I) are on the order of A(I,I) */
if (ilascl) {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
if (alphai[i__] != 0.) {
if (alphar[i__] / safmax > anrmto / anrm || safmin / alphar[
i__] > anrm / anrmto) {
work[1] = (d__1 = a[i__ + i__ * a_dim1] / alphar[i__],
abs(d__1));
beta[i__] *= work[1];
alphar[i__] *= work[1];
alphai[i__] *= work[1];
} else if (alphai[i__] / safmax > anrmto / anrm || safmin /
alphai[i__] > anrm / anrmto) {
work[1] = (d__1 = a[i__ + (i__ + 1) * a_dim1] / alphai[
i__], abs(d__1));
beta[i__] *= work[1];
alphar[i__] *= work[1];
alphai[i__] *= work[1];
}
}
/* L20: */
}
}
if (ilbscl) {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
if (alphai[i__] != 0.) {
if (beta[i__] / safmax > bnrmto / bnrm || safmin / beta[i__]
> bnrm / bnrmto) {
work[1] = (d__1 = b[i__ + i__ * b_dim1] / beta[i__], abs(
d__1));
beta[i__] *= work[1];
alphar[i__] *= work[1];
alphai[i__] *= work[1];
}
}
/* L30: */
}
}
/* Undo scaling */
if (ilascl) {
dlascl_("H", &c__0, &c__0, &anrmto, &anrm, n, n, &a[a_offset], lda, &
ierr);
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alphar[1], n, &
ierr);
dlascl_("G", &c__0, &c__0, &anrmto, &anrm, n, &c__1, &alphai[1], n, &
ierr);
}
if (ilbscl) {
dlascl_("U", &c__0, &c__0, &bnrmto, &bnrm, n, n, &b[b_offset], ldb, &
ierr);
dlascl_("G", &c__0, &c__0, &bnrmto, &bnrm, n, &c__1, &beta[1], n, &
ierr);
}
if (wantst) {
/* Check if reordering is correct */
lastsl = TRUE_;
lst2sl = TRUE_;
*sdim = 0;
ip = 0;
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
cursl = (*selctg)(&alphar[i__], &alphai[i__], &beta[i__]);
if (alphai[i__] == 0.) {
if (cursl) {
++(*sdim);
}
ip = 0;
if (cursl && ! lastsl) {
*info = *n + 2;
}
} else {
if (ip == 1) {
/* Last eigenvalue of conjugate pair */
cursl = cursl || lastsl;
lastsl = cursl;
if (cursl) {
*sdim += 2;
}
ip = -1;
if (cursl && ! lst2sl) {
*info = *n + 2;
}
} else {
/* First eigenvalue of conjugate pair */
ip = 1;
}
}
lst2sl = lastsl;
lastsl = cursl;
/* L40: */
}
}
L50:
work[1] = (doublereal) maxwrk;
return 0;
/* End of DGGES */
} /* dgges_ */
/* Subroutine */ int dgegs_(char *jobvsl, char *jobvsr, integer *n,
doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *
alphar, doublereal *alphai, doublereal *beta, doublereal *vsl,
integer *ldvsl, doublereal *vsr, integer *ldvsr, doublereal *work,
integer *lwork, 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;
/* Local variables */
integer nb, nb1, nb2, nb3, ihi, ilo;
doublereal eps, anrm, bnrm;
integer itau, lopt;
extern logical lsame_(char *, char *);
integer ileft, iinfo, icols;
logical ilvsl;
integer iwork;
logical ilvsr;
integer irows;
extern /* Subroutine */ int dggbak_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublereal *,
integer *, integer *), dggbal_(char *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *,
integer *, doublereal *, doublereal *, doublereal *, integer *);
extern doublereal dlamch_(char *), dlange_(char *, integer *,
integer *, doublereal *, integer *, doublereal *);
extern /* Subroutine */ int dgghrd_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *), dlascl_(char *, integer *, integer *, doublereal
*, doublereal *, integer *, integer *, doublereal *, integer *,
integer *);
logical ilascl, ilbscl;
extern /* Subroutine */ int dgeqrf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dlacpy_(char *, integer *, integer *, doublereal *, integer *,
doublereal *, integer *);
doublereal safmin;
extern /* Subroutine */ int dlaset_(char *, integer *, integer *,
doublereal *, doublereal *, doublereal *, integer *),
xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
doublereal bignum;
extern /* Subroutine */ int dhgeqz_(char *, char *, char *, integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
integer *, doublereal *, integer *, doublereal *, integer *,
integer *);
integer ijobvl, iright, ijobvr;
extern /* Subroutine */ int dorgqr_(integer *, integer *, integer *,
doublereal *, integer *, doublereal *, doublereal *, integer *,
integer *);
doublereal anrmto;
integer lwkmin;
doublereal bnrmto;
extern /* Subroutine */ int dormqr_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *);
doublereal smlnum;
integer lwkopt;
logical lquery;
/* -- LAPACK driver routine (version 3.1) -- */
/* 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 DGGES. */
/* DGEGS computes the eigenvalues, real Schur form, and, optionally, */
/* left and or/right Schur vectors of a real matrix pair (A,B). */
/* Given two square matrices A and B, the generalized real Schur */
/* factorization has the form */
/* A = Q*S*Z**T, B = Q*T*Z**T */
/* where Q and Z are orthogonal matrices, T is upper triangular, and S */
/* is an upper quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal */
/* blocks, the 2-by-2 blocks corresponding to complex conjugate pairs */
/* of eigenvalues of (A,B). The columns of Q are the left Schur vectors */
/* and the columns of Z are the right Schur vectors. */
/* If only the eigenvalues of (A,B) are needed, the driver routine */
/* DGEGV should be used instead. See DGEGV for a description of the */
/* eigenvalues of the generalized nonsymmetric eigenvalue problem */
/* (GNEP). */
/* Arguments */
/* ========= */
/* JOBVSL (input) CHARACTER*1 */
/* = 'N': do not compute the left Schur vectors; */
/* = 'V': compute the left Schur vectors (returned in VSL). */
/* JOBVSR (input) CHARACTER*1 */
/* = 'N': do not compute the right Schur vectors; */
/* = 'V': compute the right Schur vectors (returned in VSR). */
/* N (input) INTEGER */
/* The order of the matrices A, B, VSL, and VSR. N >= 0. */
/* A (input/output) DOUBLE PRECISION array, dimension (LDA, N) */
/* On entry, the matrix A. */
/* On exit, the upper quasi-triangular matrix S from the */
/* generalized real Schur factorization. */
/* LDA (input) INTEGER */
/* The leading dimension of A. LDA >= max(1,N). */
/* B (input/output) DOUBLE PRECISION array, dimension (LDB, N) */
/* On entry, the matrix B. */
/* On exit, the upper triangular matrix T from the generalized */
/* real Schur factorization. */
/* LDB (input) INTEGER */
/* The leading dimension of B. LDB >= max(1,N). */
/* ALPHAR (output) DOUBLE PRECISION array, dimension (N) */
/* The real parts of each scalar alpha defining an eigenvalue */
/* of GNEP. */
/* ALPHAI (output) DOUBLE PRECISION array, dimension (N) */
/* The imaginary parts of each scalar alpha defining an */
/* eigenvalue of GNEP. If ALPHAI(j) is zero, then the j-th */
/* eigenvalue is real; if positive, then the j-th and (j+1)-st */
/* eigenvalues are a complex conjugate pair, with */
/* ALPHAI(j+1) = -ALPHAI(j). */
/* BETA (output) DOUBLE PRECISION array, dimension (N) */
/* The scalars beta that define the eigenvalues of GNEP. */
/* Together, the quantities alpha = (ALPHAR(j),ALPHAI(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. */
/* VSL (output) DOUBLE PRECISION array, dimension (LDVSL,N) */
/* If JOBVSL = 'V', the matrix of left Schur vectors Q. */
/* 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) DOUBLE PRECISION array, dimension (LDVSR,N) */
/* If JOBVSR = 'V', the matrix of right Schur vectors Z. */
/* 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) DOUBLE PRECISION 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,4*N). */
/* For good performance, LWORK must generally be larger. */
/* To compute the optimal value of LWORK, call ILAENV to get */
/* blocksizes (for DGEQRF, DORMQR, and DORGQR.) Then compute: */
/* NB -- MAX of the blocksizes for DGEQRF, DORMQR, and DORGQR */
/* The optimal LWORK is 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. */
/* 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 ALPHAR(j), ALPHAI(j), and BETA(j) should */
/* be correct for j=INFO+1,...,N. */
/* > N: errors that usually indicate LAPACK problems: */
/* =N+1: error return from DGGBAL */
/* =N+2: error return from DGEQRF */
/* =N+3: error return from DORMQR */
/* =N+4: error return from DORGQR */
/* =N+5: error return from DGGHRD */
/* =N+6: error return from DHGEQZ (other than failed */
/* iteration) */
/* =N+7: error return from DGGBAK (computing VSL) */
/* =N+8: error return from DGGBAK (computing VSR) */
/* =N+9: error return from DLASCL (various places) */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. 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;
--alphar;
--alphai;
--beta;
vsl_dim1 = *ldvsl;
vsl_offset = 1 + vsl_dim1;
vsl -= vsl_offset;
vsr_dim1 = *ldvsr;
vsr_offset = 1 + vsr_dim1;
vsr -= vsr_offset;
--work;
/* 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_;
}
/* Test the input arguments */
/* Computing MAX */
i__1 = *n << 2;
lwkmin = max(i__1,1);
lwkopt = lwkmin;
work[1] = (doublereal) lwkopt;
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 (*ldvsl < 1 || ilvsl && *ldvsl < *n) {
*info = -12;
} else if (*ldvsr < 1 || ilvsr && *ldvsr < *n) {
*info = -14;
} else if (*lwork < lwkmin && ! lquery) {
*info = -16;
}
if (*info == 0) {
nb1 = ilaenv_(&c__1, "DGEQRF", " ", n, n, &c_n1, &c_n1);
nb2 = ilaenv_(&c__1, "DORMQR", " ", n, n, n, &c_n1);
nb3 = ilaenv_(&c__1, "DORGQR", " ", n, n, n, &c_n1);
/* Computing MAX */
i__1 = max(nb1,nb2);
nb = max(i__1,nb3);
lopt = (*n << 1) + *n * (nb + 1);
work[1] = (doublereal) lopt;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DGEGS ", &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");
smlnum = *n * safmin / eps;
bignum = 1. / smlnum;
/* Scale A if max element outside range [SMLNUM,BIGNUM] */
anrm = dlange_("M", n, n, &a[a_offset], lda, &work[1]);
ilascl = FALSE_;
if (anrm > 0. && anrm < smlnum) {
anrmto = smlnum;
ilascl = TRUE_;
} else if (anrm > bignum) {
anrmto = bignum;
ilascl = TRUE_;
}
if (ilascl) {
dlascl_("G", &c_n1, &c_n1, &anrm, &anrmto, n, n, &a[a_offset], lda, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
}
/* Scale B if max element outside range [SMLNUM,BIGNUM] */
bnrm = dlange_("M", n, n, &b[b_offset], ldb, &work[1]);
ilbscl = FALSE_;
if (bnrm > 0. && bnrm < smlnum) {
bnrmto = smlnum;
ilbscl = TRUE_;
} else if (bnrm > bignum) {
bnrmto = bignum;
ilbscl = TRUE_;
}
if (ilbscl) {
dlascl_("G", &c_n1, &c_n1, &bnrm, &bnrmto, n, n, &b[b_offset], ldb, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
}
/* Permute the matrix to make it more nearly triangular */
/* Workspace layout: (2*N words -- "work..." not actually used) */
/* left_permutation, right_permutation, work... */
ileft = 1;
iright = *n + 1;
iwork = iright + *n;
dggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &work[
ileft], &work[iright], &work[iwork], &iinfo);
if (iinfo != 0) {
*info = *n + 1;
goto L10;
}
/* Reduce B to triangular form, and initialize VSL and/or VSR */
/* Workspace layout: ("work..." must have at least N words) */
/* left_permutation, right_permutation, tau, work... */
irows = ihi + 1 - ilo;
icols = *n + 1 - ilo;
itau = iwork;
iwork = itau + irows;
i__1 = *lwork + 1 - iwork;
dgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[
iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (integer) work[iwork] + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 2;
goto L10;
}
i__1 = *lwork + 1 - iwork;
dormqr_("L", "T", &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__1 = lwkopt, i__2 = (integer) work[iwork] + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 3;
goto L10;
}
if (ilvsl) {
dlaset_("Full", n, n, &c_b36, &c_b37, &vsl[vsl_offset], ldvsl);
i__1 = irows - 1;
i__2 = irows - 1;
dlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vsl[ilo
+ 1 + ilo * vsl_dim1], ldvsl);
i__1 = *lwork + 1 - iwork;
dorgqr_(&irows, &irows, &irows, &vsl[ilo + ilo * vsl_dim1], ldvsl, &
work[itau], &work[iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (integer) work[iwork] + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 4;
goto L10;
}
}
if (ilvsr) {
dlaset_("Full", n, n, &c_b36, &c_b37, &vsr[vsr_offset], ldvsr);
}
/* Reduce to generalized Hessenberg form */
dgghrd_(jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vsl[vsl_offset], ldvsl, &vsr[vsr_offset], ldvsr, &iinfo);
if (iinfo != 0) {
*info = *n + 5;
goto L10;
}
/* Perform QZ algorithm, computing Schur vectors if desired */
/* Workspace layout: ("work..." must have at least 1 word) */
/* left_permutation, right_permutation, work... */
iwork = itau;
i__1 = *lwork + 1 - iwork;
dhgeqz_("S", jobvsl, jobvsr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alphar[1], &alphai[1], &beta[1], &vsl[vsl_offset]
, ldvsl, &vsr[vsr_offset], ldvsr, &work[iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (integer) work[iwork] + 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) {
dggbak_("P", "L", n, &ilo, &ihi, &work[ileft], &work[iright], n, &vsl[
vsl_offset], ldvsl, &iinfo);
if (iinfo != 0) {
*info = *n + 7;
goto L10;
}
}
if (ilvsr) {
dggbak_("P", "R", n, &ilo, &ihi, &work[ileft], &work[iright], n, &vsr[
vsr_offset], ldvsr, &iinfo);
if (iinfo != 0) {
*info = *n + 8;
goto L10;
}
}
/* Undo scaling */
if (ilascl) {
dlascl_("H", &c_n1, &c_n1, &anrmto, &anrm, n, n, &a[a_offset], lda, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
dlascl_("G", &c_n1, &c_n1, &anrmto, &anrm, n, &c__1, &alphar[1], n, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
dlascl_("G", &c_n1, &c_n1, &anrmto, &anrm, n, &c__1, &alphai[1], n, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
}
if (ilbscl) {
dlascl_("U", &c_n1, &c_n1, &bnrmto, &bnrm, n, n, &b[b_offset], ldb, &
iinfo);
if (iinfo != 0) {
*info = *n + 9;
return 0;
}
dlascl_("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] = (doublereal) lwkopt;
return 0;
/* End of DGEGS */
} /* dgegs_ */
/* Subroutine */ int dgegv_(char *jobvl, char *jobvr, integer *n, doublereal *
a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar,
doublereal *alphai, doublereal *beta, doublereal *vl, integer *ldvl,
doublereal *vr, integer *ldvr, doublereal *work, integer *lwork,
integer *info, ftnlen jobvl_len, ftnlen jobvr_len)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, vl_dim1, vl_offset, vr_dim1,
vr_offset, i__1, i__2;
doublereal d__1, d__2, d__3, d__4;
/* Local variables */
static integer jc, nb, in, jr, nb1, nb2, nb3, ihi, ilo;
static doublereal eps;
static logical ilv;
static doublereal absb, anrm, bnrm;
static integer itau;
static doublereal temp;
static logical ilvl, ilvr;
static integer lopt;
static doublereal anrm1, anrm2, bnrm1, bnrm2, absai, scale, absar, sbeta;
extern logical lsame_(char *, char *, ftnlen, ftnlen);
static integer ileft, iinfo, icols, iwork, irows;
extern /* Subroutine */ int dggbak_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublereal *,
integer *, integer *, ftnlen, ftnlen), dggbal_(char *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *,
integer *, doublereal *, doublereal *, doublereal *, integer *,
ftnlen);
extern doublereal dlamch_(char *, ftnlen), dlange_(char *, integer *,
integer *, doublereal *, integer *, doublereal *, ftnlen);
static doublereal salfai;
extern /* Subroutine */ int dgghrd_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *, doublereal *, integer *, integer *,
ftnlen, ftnlen), dlascl_(char *, integer *, integer *, doublereal
*, doublereal *, integer *, integer *, doublereal *, integer *,
integer *, ftnlen);
static doublereal salfar;
extern /* Subroutine */ int dgeqrf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dlacpy_(char *, integer *, integer *, doublereal *, integer *,
doublereal *, integer *, ftnlen);
static doublereal safmin;
extern /* Subroutine */ int dlaset_(char *, integer *, integer *,
doublereal *, doublereal *, doublereal *, integer *, ftnlen);
static doublereal safmax;
static char chtemp[1];
static logical ldumma[1];
extern /* Subroutine */ int dhgeqz_(char *, char *, char *, integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
integer *, doublereal *, integer *, doublereal *, integer *,
integer *, ftnlen, ftnlen, ftnlen), dtgevc_(char *, char *,
logical *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, integer *, doublereal *, integer *,
integer *, integer *, doublereal *, integer *, ftnlen, ftnlen),
xerbla_(char *, integer *, ftnlen);
static integer ijobvl, iright;
static logical ilimit;
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
static integer ijobvr;
extern /* Subroutine */ int dorgqr_(integer *, integer *, integer *,
doublereal *, integer *, doublereal *, doublereal *, integer *,
integer *);
static doublereal onepls;
static integer lwkmin;
extern /* Subroutine */ int dormqr_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *, ftnlen, ftnlen);
static integer lwkopt;
static logical lquery;
/* -- 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 .. */
/* .. */
/* Purpose */
/* ======= */
/* This routine is deprecated and has been replaced by routine DGGEV. */
/* DGEGV computes for a pair of n-by-n real nonsymmetric matrices A and */
/* B, the generalized eigenvalues (alphar +/- alphai*i, beta), and */
/* optionally, the left and/or right generalized eigenvectors (VL and */
/* VR). */
/* 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, "Matrix */
/* Computations", by G. Golub & C. van Loan (Johns Hopkins U. Press) */
/* A right generalized eigenvector corresponding to a generalized */
/* eigenvalue w for a pair of matrices (A,B) is a vector r such */
/* that (A - w B) r = 0 . A left generalized eigenvector is a vector */
/* l such that l**H * (A - w B) = 0, where l**H is the */
/* conjugate-transpose of l. */
/* 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. */
/* 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) DOUBLE PRECISION array, dimension (LDA, N) */
/* On entry, the first of the pair of matrices whose */
/* generalized eigenvalues and (optionally) generalized */
/* eigenvectors are to be computed. */
/* On exit, the contents will have been destroyed. (For a */
/* description of the contents of A on exit, see "Further */
/* Details", below.) */
/* LDA (input) INTEGER */
/* The leading dimension of A. LDA >= max(1,N). */
/* B (input/output) DOUBLE PRECISION array, dimension (LDB, N) */
/* On entry, the second of the pair of matrices whose */
/* generalized eigenvalues and (optionally) generalized */
/* eigenvectors are to be computed. */
/* On exit, the contents will have been destroyed. (For a */
/* description of the contents of B on exit, see "Further */
/* Details", below.) */
/* LDB (input) INTEGER */
/* The leading dimension of B. LDB >= max(1,N). */
/* ALPHAR (output) DOUBLE PRECISION array, dimension (N) */
/* ALPHAI (output) DOUBLE PRECISION array, dimension (N) */
/* BETA (output) DOUBLE PRECISION array, dimension (N) */
/* On exit, (ALPHAR(j) + ALPHAI(j)*i)/BETA(j), j=1,...,N, will */
/* be the generalized eigenvalues. If ALPHAI(j) is zero, then */
/* the j-th eigenvalue is real; if positive, then the j-th and */
/* (j+1)-st eigenvalues are a complex conjugate pair, with */
/* ALPHAI(j+1) negative. */
/* Note: the quotients ALPHAR(j)/BETA(j) and ALPHAI(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, ALPHAR and ALPHAI 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) DOUBLE PRECISION array, dimension (LDVL,N) */
/* If JOBVL = 'V', the left generalized eigenvectors. (See */
/* "Purpose", above.) Real eigenvectors take one column, */
/* complex take two columns, the first for the real part and */
/* the second for the imaginary part. Complex eigenvectors */
/* correspond to an eigenvalue with positive imaginary part. */
/* Each eigenvector will be scaled so the largest component */
/* will have abs(real part) + abs(imag. part) = 1, *except* */
/* that for eigenvalues with alpha=beta=0, a zero vector will */
/* be returned as the corresponding eigenvector. */
/* 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) DOUBLE PRECISION array, dimension (LDVR,N) */
/* If JOBVR = 'V', the right generalized eigenvectors. (See */
/* "Purpose", above.) Real eigenvectors take one column, */
/* complex take two columns, the first for the real part and */
/* the second for the imaginary part. Complex eigenvectors */
/* correspond to an eigenvalue with positive imaginary part. */
/* Each eigenvector will be scaled so the largest component */
/* will have abs(real part) + abs(imag. part) = 1, *except* */
/* that for eigenvalues with alpha=beta=0, a zero vector will */
/* be returned as the corresponding eigenvector. */
/* 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) DOUBLE PRECISION 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,8*N). */
/* For good performance, LWORK must generally be larger. */
/* To compute the optimal value of LWORK, call ILAENV to get */
/* blocksizes (for DGEQRF, DORMQR, and DORGQR.) Then compute: */
/* NB -- MAX of the blocksizes for DGEQRF, DORMQR, and DORGQR; */
/* The optimal LWORK is: */
/* 2*N + MAX( 6*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. */
/* 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 ALPHAR(j), ALPHAI(j), and BETA(j) */
/* should be correct for j=INFO+1,...,N. */
/* > N: errors that usually indicate LAPACK problems: */
/* =N+1: error return from DGGBAL */
/* =N+2: error return from DGEQRF */
/* =N+3: error return from DORMQR */
/* =N+4: error return from DORGQR */
/* =N+5: error return from DGGHRD */
/* =N+6: error return from DHGEQZ (other than failed */
/* iteration) */
/* =N+7: error return from DTGEVC */
/* =N+8: error return from DGGBAK (computing VL) */
/* =N+9: error return from DGGBAK (computing VR) */
/* =N+10: error return from DLASCL (various calls) */
/* Further Details */
/* =============== */
/* Balancing */
/* --------- */
/* This driver calls DGGBAL 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, DGGBAK 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 real Schur */
/* form[*] of the "balanced" versions of A and B. If no eigenvectors */
/* are computed, then only the diagonal blocks will be correct. */
/* [*] See DHGEQZ, DGEGS, or read the book "Matrix Computations", */
/* by Golub & van Loan, pub. by Johns Hopkins U. Press. */
/* ===================================================================== */
/* .. 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;
--alphar;
--alphai;
--beta;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1;
vr -= vr_offset;
--work;
/* Function Body */
if (lsame_(jobvl, "N", (ftnlen)1, (ftnlen)1)) {
ijobvl = 1;
ilvl = FALSE_;
} else if (lsame_(jobvl, "V", (ftnlen)1, (ftnlen)1)) {
ijobvl = 2;
ilvl = TRUE_;
} else {
ijobvl = -1;
ilvl = FALSE_;
}
if (lsame_(jobvr, "N", (ftnlen)1, (ftnlen)1)) {
ijobvr = 1;
ilvr = FALSE_;
} else if (lsame_(jobvr, "V", (ftnlen)1, (ftnlen)1)) {
ijobvr = 2;
ilvr = TRUE_;
} else {
ijobvr = -1;
ilvr = FALSE_;
}
ilv = ilvl || ilvr;
/* Test the input arguments */
/* Computing MAX */
i__1 = *n << 3;
lwkmin = max(i__1,1);
lwkopt = lwkmin;
work[1] = (doublereal) lwkopt;
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 = -12;
} else if (*ldvr < 1 || ilvr && *ldvr < *n) {
*info = -14;
} else if (*lwork < lwkmin && ! lquery) {
*info = -16;
}
if (*info == 0) {
nb1 = ilaenv_(&c__1, "DGEQRF", " ", n, n, &c_n1, &c_n1, (ftnlen)6, (
ftnlen)1);
nb2 = ilaenv_(&c__1, "DORMQR", " ", n, n, n, &c_n1, (ftnlen)6, (
ftnlen)1);
nb3 = ilaenv_(&c__1, "DORGQR", " ", n, n, n, &c_n1, (ftnlen)6, (
ftnlen)1);
/* Computing MAX */
i__1 = max(nb1,nb2);
nb = max(i__1,nb3);
/* Computing MAX */
i__1 = *n * 6, i__2 = *n * (nb + 1);
lopt = (*n << 1) + max(i__1,i__2);
work[1] = (doublereal) lopt;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DGEGV ", &i__1, (ftnlen)6);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Get machine constants */
eps = dlamch_("E", (ftnlen)1) * dlamch_("B", (ftnlen)1);
safmin = dlamch_("S", (ftnlen)1);
safmin += safmin;
safmax = 1. / safmin;
onepls = eps * 4 + 1.;
/* Scale A */
anrm = dlange_("M", n, n, &a[a_offset], lda, &work[1], (ftnlen)1);
anrm1 = anrm;
anrm2 = 1.;
if (anrm < 1.) {
if (safmax * anrm < 1.) {
anrm1 = safmin;
anrm2 = safmax * anrm;
}
}
if (anrm > 0.) {
dlascl_("G", &c_n1, &c_n1, &anrm, &c_b27, n, n, &a[a_offset], lda, &
iinfo, (ftnlen)1);
if (iinfo != 0) {
*info = *n + 10;
return 0;
}
}
/* Scale B */
bnrm = dlange_("M", n, n, &b[b_offset], ldb, &work[1], (ftnlen)1);
bnrm1 = bnrm;
bnrm2 = 1.;
if (bnrm < 1.) {
if (safmax * bnrm < 1.) {
bnrm1 = safmin;
bnrm2 = safmax * bnrm;
}
}
if (bnrm > 0.) {
dlascl_("G", &c_n1, &c_n1, &bnrm, &c_b27, n, n, &b[b_offset], ldb, &
iinfo, (ftnlen)1);
if (iinfo != 0) {
*info = *n + 10;
return 0;
}
}
/* Permute the matrix to make it more nearly triangular */
/* Workspace layout: (8*N words -- "work" requires 6*N words) */
/* left_permutation, right_permutation, work... */
ileft = 1;
iright = *n + 1;
iwork = iright + *n;
dggbal_("P", n, &a[a_offset], lda, &b[b_offset], ldb, &ilo, &ihi, &work[
ileft], &work[iright], &work[iwork], &iinfo, (ftnlen)1);
if (iinfo != 0) {
*info = *n + 1;
goto L120;
}
/* Reduce B to triangular form, and initialize VL and/or VR */
/* Workspace layout: ("work..." must have at least N words) */
/* left_permutation, right_permutation, tau, work... */
irows = ihi + 1 - ilo;
if (ilv) {
icols = *n + 1 - ilo;
} else {
icols = irows;
}
itau = iwork;
iwork = itau + irows;
i__1 = *lwork + 1 - iwork;
dgeqrf_(&irows, &icols, &b[ilo + ilo * b_dim1], ldb, &work[itau], &work[
iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (integer) work[iwork] + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 2;
goto L120;
}
i__1 = *lwork + 1 - iwork;
dormqr_("L", "T", &irows, &icols, &irows, &b[ilo + ilo * b_dim1], ldb, &
work[itau], &a[ilo + ilo * a_dim1], lda, &work[iwork], &i__1, &
iinfo, (ftnlen)1, (ftnlen)1);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (integer) work[iwork] + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 3;
goto L120;
}
if (ilvl) {
dlaset_("Full", n, n, &c_b38, &c_b27, &vl[vl_offset], ldvl, (ftnlen)4)
;
i__1 = irows - 1;
i__2 = irows - 1;
dlacpy_("L", &i__1, &i__2, &b[ilo + 1 + ilo * b_dim1], ldb, &vl[ilo +
1 + ilo * vl_dim1], ldvl, (ftnlen)1);
i__1 = *lwork + 1 - iwork;
dorgqr_(&irows, &irows, &irows, &vl[ilo + ilo * vl_dim1], ldvl, &work[
itau], &work[iwork], &i__1, &iinfo);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (integer) work[iwork] + iwork - 1;
lwkopt = max(i__1,i__2);
}
if (iinfo != 0) {
*info = *n + 4;
goto L120;
}
}
if (ilvr) {
dlaset_("Full", n, n, &c_b38, &c_b27, &vr[vr_offset], ldvr, (ftnlen)4)
;
}
/* Reduce to generalized Hessenberg form */
if (ilv) {
/* Eigenvectors requested -- work on whole matrix. */
dgghrd_(jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[b_offset],
ldb, &vl[vl_offset], ldvl, &vr[vr_offset], ldvr, &iinfo, (
ftnlen)1, (ftnlen)1);
} else {
dgghrd_("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, (ftnlen)1, (ftnlen)1);
}
if (iinfo != 0) {
*info = *n + 5;
goto L120;
}
/* Perform QZ algorithm */
/* Workspace layout: ("work..." must have at least 1 word) */
/* left_permutation, right_permutation, work... */
iwork = itau;
if (ilv) {
*(unsigned char *)chtemp = 'S';
} else {
*(unsigned char *)chtemp = 'E';
}
i__1 = *lwork + 1 - iwork;
dhgeqz_(chtemp, jobvl, jobvr, n, &ilo, &ihi, &a[a_offset], lda, &b[
b_offset], ldb, &alphar[1], &alphai[1], &beta[1], &vl[vl_offset],
ldvl, &vr[vr_offset], ldvr, &work[iwork], &i__1, &iinfo, (ftnlen)
1, (ftnlen)1, (ftnlen)1);
if (iinfo >= 0) {
/* Computing MAX */
i__1 = lwkopt, i__2 = (integer) work[iwork] + 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 L120;
}
if (ilv) {
/* Compute Eigenvectors (DTGEVC requires 6*N words of workspace) */
if (ilvl) {
if (ilvr) {
*(unsigned char *)chtemp = 'B';
} else {
*(unsigned char *)chtemp = 'L';
}
} else {
*(unsigned char *)chtemp = 'R';
}
dtgevc_(chtemp, "B", ldumma, n, &a[a_offset], lda, &b[b_offset], ldb,
&vl[vl_offset], ldvl, &vr[vr_offset], ldvr, n, &in, &work[
iwork], &iinfo, (ftnlen)1, (ftnlen)1);
if (iinfo != 0) {
*info = *n + 7;
goto L120;
}
/* Undo balancing on VL and VR, rescale */
if (ilvl) {
dggbak_("P", "L", n, &ilo, &ihi, &work[ileft], &work[iright], n, &
vl[vl_offset], ldvl, &iinfo, (ftnlen)1, (ftnlen)1);
if (iinfo != 0) {
*info = *n + 8;
goto L120;
}
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
if (alphai[jc] < 0.) {
goto L50;
}
temp = 0.;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__2 = temp, d__3 = (d__1 = vl[jr + jc * vl_dim1],
abs(d__1));
temp = max(d__2,d__3);
/* L10: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__3 = temp, d__4 = (d__1 = vl[jr + jc * vl_dim1],
abs(d__1)) + (d__2 = vl[jr + (jc + 1) *
vl_dim1], abs(d__2));
temp = max(d__3,d__4);
/* L20: */
}
}
if (temp < safmin) {
goto L50;
}
temp = 1. / temp;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vl[jr + jc * vl_dim1] *= temp;
/* L30: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vl[jr + jc * vl_dim1] *= temp;
vl[jr + (jc + 1) * vl_dim1] *= temp;
/* L40: */
}
}
L50:
;
}
}
if (ilvr) {
dggbak_("P", "R", n, &ilo, &ihi, &work[ileft], &work[iright], n, &
vr[vr_offset], ldvr, &iinfo, (ftnlen)1, (ftnlen)1);
if (iinfo != 0) {
*info = *n + 9;
goto L120;
}
i__1 = *n;
for (jc = 1; jc <= i__1; ++jc) {
if (alphai[jc] < 0.) {
goto L100;
}
temp = 0.;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__2 = temp, d__3 = (d__1 = vr[jr + jc * vr_dim1],
abs(d__1));
temp = max(d__2,d__3);
/* L60: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
/* Computing MAX */
d__3 = temp, d__4 = (d__1 = vr[jr + jc * vr_dim1],
abs(d__1)) + (d__2 = vr[jr + (jc + 1) *
vr_dim1], abs(d__2));
temp = max(d__3,d__4);
/* L70: */
}
}
if (temp < safmin) {
goto L100;
}
temp = 1. / temp;
if (alphai[jc] == 0.) {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr[jr + jc * vr_dim1] *= temp;
/* L80: */
}
} else {
i__2 = *n;
for (jr = 1; jr <= i__2; ++jr) {
vr[jr + jc * vr_dim1] *= temp;
vr[jr + (jc + 1) * vr_dim1] *= temp;
/* L90: */
}
}
L100:
;
}
}
/* 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) {
absar = (d__1 = alphar[jc], abs(d__1));
absai = (d__1 = alphai[jc], abs(d__1));
absb = (d__1 = beta[jc], abs(d__1));
salfar = anrm * alphar[jc];
salfai = anrm * alphai[jc];
sbeta = bnrm * beta[jc];
ilimit = FALSE_;
scale = 1.;
/* Check for significant underflow in ALPHAI */
/* 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 = onepls * safmin, d__2 = anrm2 * absai;
scale = onepls * safmin / anrm1 / max(d__1,d__2);
} else if (salfai == 0.) {
/* If insignificant underflow in ALPHAI, then make the */
/* conjugate eigenvalue real. */
if (alphai[jc] < 0. && jc > 1) {
alphai[jc - 1] = 0.;
} else if (alphai[jc] > 0. && jc < *n) {
alphai[jc + 1] = 0.;
}
}
/* Check for significant underflow in ALPHAR */
/* 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 = onepls * safmin, d__4 = anrm2 * absar;
d__1 = scale, d__2 = onepls * 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 = onepls * safmin, d__4 = bnrm2 * absb;
d__1 = scale, d__2 = onepls * 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 ALPHAR, ALPHAI, BETA if necessary. */
if (ilimit) {
salfar = scale * alphar[jc] * anrm;
salfai = scale * alphai[jc] * anrm;
sbeta = scale * beta[jc] * bnrm;
}
alphar[jc] = salfar;
alphai[jc] = salfai;
beta[jc] = sbeta;
/* L110: */
}
L120:
work[1] = (doublereal) lwkopt;
return 0;
/* End of DGEGV */
} /* dgegv_ */
/* Subroutine */ int derrqr_(char *path, integer *nunit)
{
/* Builtin functions */
integer s_wsle(cilist *), e_wsle(void);
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
/* Local variables */
doublereal a[4] /* was [2][2] */, b[2];
integer i__, j;
doublereal w[2], x[2], af[4] /* was [2][2] */;
integer info;
extern /* Subroutine */ int dgeqr2_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *), dorg2r_(
integer *, integer *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *), dorm2r_(char *, char *,
integer *, integer *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *, doublereal *, integer *), alaesm_(char *, logical *, integer *),
dgeqrf_(integer *, integer *, doublereal *, integer *, doublereal
*, doublereal *, integer *, integer *), chkxer_(char *, integer *,
integer *, logical *, logical *), dgeqrs_(integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, integer *),
dorgqr_(integer *, integer *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *, integer *), dormqr_(char *,
char *, integer *, integer *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *, doublereal *, integer *,
integer *);
/* Fortran I/O blocks */
static cilist io___1 = { 0, 0, 0, 0, 0 };
/* -- LAPACK test routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DERRQR tests the error exits for the DOUBLE PRECISION 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. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Scalars in Common .. */
/* .. */
/* .. Common blocks .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
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__) {
a[i__ + (j << 1) - 3] = 1. / (doublereal) (i__ + j);
af[i__ + (j << 1) - 3] = 1. / (doublereal) (i__ + j);
/* L10: */
}
b[j - 1] = 0.;
w[j - 1] = 0.;
x[j - 1] = 0.;
/* L20: */
}
infoc_1.ok = TRUE_;
/* Error exits for QR factorization */
/* DGEQRF */
s_copy(srnamc_1.srnamt, "DGEQRF", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgeqrf_(&c_n1, &c__0, a, &c__1, b, w, &c__1, &info);
chkxer_("DGEQRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgeqrf_(&c__0, &c_n1, a, &c__1, b, w, &c__1, &info);
chkxer_("DGEQRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgeqrf_(&c__2, &c__1, a, &c__1, b, w, &c__1, &info);
chkxer_("DGEQRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
dgeqrf_(&c__1, &c__2, a, &c__1, b, w, &c__1, &info);
chkxer_("DGEQRF", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGEQR2 */
s_copy(srnamc_1.srnamt, "DGEQR2", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgeqr2_(&c_n1, &c__0, a, &c__1, b, w, &info);
chkxer_("DGEQR2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgeqr2_(&c__0, &c_n1, a, &c__1, b, w, &info);
chkxer_("DGEQR2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dgeqr2_(&c__2, &c__1, a, &c__1, b, w, &info);
chkxer_("DGEQR2", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DGEQRS */
s_copy(srnamc_1.srnamt, "DGEQRS", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dgeqrs_(&c_n1, &c__0, &c__0, a, &c__1, x, b, &c__1, w, &c__1, &info);
chkxer_("DGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgeqrs_(&c__0, &c_n1, &c__0, a, &c__1, x, b, &c__1, w, &c__1, &info);
chkxer_("DGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dgeqrs_(&c__1, &c__2, &c__0, a, &c__2, x, b, &c__2, w, &c__1, &info);
chkxer_("DGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dgeqrs_(&c__0, &c__0, &c_n1, a, &c__1, x, b, &c__1, w, &c__1, &info);
chkxer_("DGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dgeqrs_(&c__2, &c__1, &c__0, a, &c__1, x, b, &c__2, w, &c__1, &info);
chkxer_("DGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 8;
dgeqrs_(&c__2, &c__1, &c__0, a, &c__2, x, b, &c__1, w, &c__1, &info);
chkxer_("DGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 10;
dgeqrs_(&c__1, &c__1, &c__2, a, &c__1, x, b, &c__1, w, &c__1, &info);
chkxer_("DGEQRS", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DORGQR */
s_copy(srnamc_1.srnamt, "DORGQR", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dorgqr_(&c_n1, &c__0, &c__0, a, &c__1, x, w, &c__1, &info);
chkxer_("DORGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dorgqr_(&c__0, &c_n1, &c__0, a, &c__1, x, w, &c__1, &info);
chkxer_("DORGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dorgqr_(&c__1, &c__2, &c__0, a, &c__1, x, w, &c__2, &info);
chkxer_("DORGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dorgqr_(&c__0, &c__0, &c_n1, a, &c__1, x, w, &c__1, &info);
chkxer_("DORGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dorgqr_(&c__1, &c__1, &c__2, a, &c__1, x, w, &c__1, &info);
chkxer_("DORGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dorgqr_(&c__2, &c__2, &c__0, a, &c__1, x, w, &c__2, &info);
chkxer_("DORGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 8;
dorgqr_(&c__2, &c__2, &c__0, a, &c__2, x, w, &c__1, &info);
chkxer_("DORGQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DORG2R */
s_copy(srnamc_1.srnamt, "DORG2R", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dorg2r_(&c_n1, &c__0, &c__0, a, &c__1, x, w, &info);
chkxer_("DORG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dorg2r_(&c__0, &c_n1, &c__0, a, &c__1, x, w, &info);
chkxer_("DORG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dorg2r_(&c__1, &c__2, &c__0, a, &c__1, x, w, &info);
chkxer_("DORG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dorg2r_(&c__0, &c__0, &c_n1, a, &c__1, x, w, &info);
chkxer_("DORG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dorg2r_(&c__2, &c__1, &c__2, a, &c__2, x, w, &info);
chkxer_("DORG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dorg2r_(&c__2, &c__1, &c__0, a, &c__1, x, w, &info);
chkxer_("DORG2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DORMQR */
s_copy(srnamc_1.srnamt, "DORMQR", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dormqr_("/", "N", &c__0, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dormqr_("L", "/", &c__0, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dormqr_("L", "N", &c_n1, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dormqr_("L", "N", &c__0, &c_n1, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dormqr_("L", "N", &c__0, &c__0, &c_n1, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dormqr_("L", "N", &c__0, &c__1, &c__1, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dormqr_("R", "N", &c__1, &c__0, &c__1, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
dormqr_("L", "N", &c__2, &c__1, &c__0, a, &c__1, x, af, &c__2, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
dormqr_("R", "N", &c__1, &c__2, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 10;
dormqr_("L", "N", &c__2, &c__1, &c__0, a, &c__2, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 12;
dormqr_("L", "N", &c__1, &c__2, &c__0, a, &c__1, x, af, &c__1, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 12;
dormqr_("R", "N", &c__2, &c__1, &c__0, a, &c__1, x, af, &c__2, w, &c__1, &
info);
chkxer_("DORMQR", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
/* DORM2R */
s_copy(srnamc_1.srnamt, "DORM2R", (ftnlen)6, (ftnlen)6);
infoc_1.infot = 1;
dorm2r_("/", "N", &c__0, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("DORM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 2;
dorm2r_("L", "/", &c__0, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("DORM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 3;
dorm2r_("L", "N", &c_n1, &c__0, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("DORM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 4;
dorm2r_("L", "N", &c__0, &c_n1, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("DORM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dorm2r_("L", "N", &c__0, &c__0, &c_n1, a, &c__1, x, af, &c__1, w, &info);
chkxer_("DORM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dorm2r_("L", "N", &c__0, &c__1, &c__1, a, &c__1, x, af, &c__1, w, &info);
chkxer_("DORM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 5;
dorm2r_("R", "N", &c__1, &c__0, &c__1, a, &c__1, x, af, &c__1, w, &info);
chkxer_("DORM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
dorm2r_("L", "N", &c__2, &c__1, &c__0, a, &c__1, x, af, &c__2, w, &info);
chkxer_("DORM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 7;
dorm2r_("R", "N", &c__1, &c__2, &c__0, a, &c__1, x, af, &c__1, w, &info);
chkxer_("DORM2R", &infoc_1.infot, &infoc_1.nout, &infoc_1.lerr, &
infoc_1.ok);
infoc_1.infot = 10;
dorm2r_("L", "N", &c__2, &c__1, &c__0, a, &c__2, x, af, &c__1, w, &info);
chkxer_("DORM2R", &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 DERRQR */
} /* derrqr_ */
/* Subroutine */
int dggrqf_(integer *m, integer *p, integer *n, doublereal * a, integer *lda, doublereal *taua, doublereal *b, integer *ldb, doublereal *taub, doublereal *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 dgeqrf_(integer *, integer *, doublereal *, integer *, doublereal *, doublereal *, integer *, integer *), dgerqf_(integer *, integer *, doublereal *, integer *, doublereal *, doublereal *, integer *, integer *), xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *, integer *, integer *);
extern /* Subroutine */
int dormrq_(char *, char *, integer *, integer *, integer *, doublereal *, integer *, doublereal *, doublereal *, integer *, doublereal *, integer *, integer *);
integer lwkopt;
logical lquery;
/* -- LAPACK computational 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 .. */
/* .. */
/* ===================================================================== */
/* .. 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, "DGERQF", " ", m, n, &c_n1, &c_n1);
nb2 = ilaenv_(&c__1, "DGEQRF", " ", p, n, &c_n1, &c_n1);
nb3 = ilaenv_(&c__1, "DORMRQ", " ", 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] = (doublereal) lwkopt;
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); // , expr subst
if (*lwork < max(i__1,*n) && ! lquery)
{
*info = -11;
}
}
if (*info != 0)
{
i__1 = -(*info);
xerbla_("DGGRQF", &i__1);
return 0;
}
else if (lquery)
{
return 0;
}
/* RQ factorization of M-by-N matrix A: A = R*Q */
dgerqf_(m, n, &a[a_offset], lda, &taua[1], &work[1], lwork, info);
lopt = (integer) work[1];
/* Update B := B*Q**T */
i__1 = min(*m,*n);
/* Computing MAX */
i__2 = 1;
i__3 = *m - *n + 1; // , expr subst
dormrq_("Right", "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]; // , expr subst
lopt = max(i__1,i__2);
/* QR factorization of P-by-N matrix B: B = Z*T */
dgeqrf_(p, n, &b[b_offset], ldb, &taub[1], &work[1], lwork, info);
/* Computing MAX */
i__1 = lopt;
i__2 = (integer) work[1]; // , expr subst
work[1] = (doublereal) max(i__1,i__2);
return 0;
/* End of DGGRQF */
}
