Nonsymmetric eigenproblem kernels: multishift QR and QZ sweeps with aggressive early deflation. More...
Functions/Subroutines | |
| pure subroutine, public | la_slaqr1 (n, h, ldh, sr1, si1, sr2, si2, v) |
| Given a 2-by-2 or 3-by-3 matrix H, SLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm. | |
| pure subroutine, public | la_dlaqr1 (n, h, ldh, sr1, si1, sr2, si2, v) |
| Given a 2-by-2 or 3-by-3 matrix H, DLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm. | |
| pure subroutine, public | la_qlaqr1 (n, h, ldh, sr1, si1, sr2, si2, v) |
| Given a 2-by-2 or 3-by-3 matrix H, QLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm. | |
| pure subroutine, public | la_slaqz1 (a, lda, b, ldb, sr1, sr2, si, beta1, beta2, v) |
| Given a 3-by-3 matrix pencil (A,B), SLAQZ1: sets v to a scalar multiple of the first column of the product (*) K = (A - (beta2*sr2 - i*si)*B)*B^(-1)*(beta1*A - (sr2 + i*si2)*B)*B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm. | |
| pure subroutine, public | la_dlaqz1 (a, lda, b, ldb, sr1, sr2, si, beta1, beta2, v) |
| Given a 3-by-3 matrix pencil (A,B), DLAQZ1: sets v to a scalar multiple of the first column of the product (*) K = (A - (beta2*sr2 - i*si)*B)*B^(-1)*(beta1*A - (sr2 + i*si2)*B)*B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm. | |
| pure subroutine, public | la_qlaqz1 (a, lda, b, ldb, sr1, sr2, si, beta1, beta2, v) |
| Given a 3-by-3 matrix pencil (A,B), QLAQZ1: sets v to a scalar multiple of the first column of the product (*) K = (A - (beta2*sr2 - i*si)*B)*B^(-1)*(beta1*A - (sr2 + i*si2)*B)*B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm. | |
| pure subroutine, public | la_slaqz2 (ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz) |
| SLAQZ2: chases a 2x2 shift bulge in a matrix pencil down a single position. | |
| pure subroutine, public | la_dlaqz2 (ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz) |
| DLAQZ2: chases a 2x2 shift bulge in a matrix pencil down a single position. | |
| pure subroutine, public | la_qlaqz2 (ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz) |
| QLAQZ2: chases a 2x2 shift bulge in a matrix pencil down a single position. | |
| pure subroutine, public | la_slaqz4 (ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, sr, si, ss, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info) |
| SLAQZ4: Executes a single multishift QZ sweep. | |
| pure subroutine, public | la_dlaqz4 (ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, sr, si, ss, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info) |
| DLAQZ4: Executes a single multishift QZ sweep. | |
| pure subroutine, public | la_qlaqz4 (ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, sr, si, ss, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info) |
| QLAQZ4: Executes a single multishift QZ sweep. | |
| pure subroutine, public | la_slaqr5 (wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) |
| SLAQR5:, called by SLAQR0, performs a single small-bulge multi-shift QR sweep. | |
| pure subroutine, public | la_dlaqr5 (wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) |
| DLAQR5:, called by DLAQR0, performs a single small-bulge multi-shift QR sweep. | |
| pure subroutine, public | la_qlaqr5 (wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) |
| QLAQR5:, called by QLAQR0, performs a single small-bulge multi-shift QR sweep. | |
| subroutine, public | la_slaqtr (ltran, lreal, n, t, ldt, b, w, scale, x, work, info) |
| SLAQTR: solves the real quasi-triangular system op(T)*p = scale*c, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)*(p+iq) = scale*(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or A**T, A**T denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine STRSNA. | |
| subroutine, public | la_dlaqtr (ltran, lreal, n, t, ldt, b, w, scale, x, work, info) |
| DLAQTR: solves the real quasi-triangular system op(T)*p = scale*c, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)*(p+iq) = scale*(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or A**T, A**T denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine DTRSNA. | |
| subroutine, public | la_qlaqtr (ltran, lreal, n, t, ldt, b, w, scale, x, work, info) |
| QLAQTR: solves the real quasi-triangular system op(T)*p = scale*c, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)*(p+iq) = scale*(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or A**T, A**T denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine QTRSNA. | |
| pure subroutine, public | la_slahqr (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info) |
| SLAHQR: is an auxiliary routine called by SHSEQR to update the eigenvalues and Schur decomposition already computed by SHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI. | |
| pure subroutine, public | la_dlahqr (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info) |
| DLAHQR: is an auxiliary routine called by DHSEQR to update the eigenvalues and Schur decomposition already computed by DHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI. | |
| pure subroutine, public | la_qlahqr (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info) |
| QLAHQR: is an auxiliary routine called by QHSEQR to update the eigenvalues and Schur decomposition already computed by QHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI. | |
| subroutine, public | la_slaqr2 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| SLAQR2: is identical to SLAQR3 except that it avoids recursion by calling SLAHQR instead of SLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| subroutine, public | la_dlaqr2 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| DLAQR2: is identical to DLAQR3 except that it avoids recursion by calling DLAHQR instead of DLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| subroutine, public | la_qlaqr2 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| QLAQR2: is identical to QLAQR3 except that it avoids recursion by calling QLAHQR instead of QLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| subroutine, public | la_slaqr0 (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) |
| SLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T. | |
| subroutine, public | la_dlaqr0 (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) |
| DLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T. | |
| subroutine, public | la_qlaqr0 (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) |
| QLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T. | |
| subroutine, public | la_slaqr3 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| Aggressive early deflation: SLAQR3: accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| subroutine, public | la_dlaqr3 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| Aggressive early deflation: DLAQR3: accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| subroutine, public | la_qlaqr3 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| Aggressive early deflation: QLAQR3: accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| subroutine, public | la_slaqr4 (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) |
| SLAQR4: implements one level of recursion for SLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by SLAQR0 and, for large enough deflation window size, it may be called by SLAQR3. This subroutine is identical to SLAQR0 except that it calls SLAQR2 instead of SLAQR3. SLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T. | |
| subroutine, public | la_dlaqr4 (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) |
| DLAQR4: implements one level of recursion for DLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by DLAQR0 and, for large enough deflation window size, it may be called by DLAQR3. This subroutine is identical to DLAQR0 except that it calls DLAQR2 instead of DLAQR3. DLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T. | |
| subroutine, public | la_qlaqr4 (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info) |
| QLAQR4: implements one level of recursion for QLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by QLAQR0 and, for large enough deflation window size, it may be called by QLAQR3. This subroutine is identical to QLAQR0 except that it calls QLAQR2 instead of QLAQR3. QLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T. | |
| recursive subroutine, public | la_slaqz0 (wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, rec, info) |
| SLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**T, B = Q1*T*Z1**T, as computed by SGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**T, T = Q*P*Z**T, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from SGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**T, B = (Q1*Q)*P*(Z1*Z)**T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973),
pp. 241–256.
Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer.
Anal., 29(2006), pp. 199–227.
Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation". | |
| recursive subroutine, public | la_dlaqz0 (wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, rec, info) |
| DLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**T, B = Q1*T*Z1**T, as computed by DGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**T, T = Q*P*Z**T, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from DGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**T, B = (Q1*Q)*P*(Z1*Z)**T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973),
pp. 241–256.
Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer.
Anal., 29(2006), pp. 199–227.
Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation". | |
| recursive subroutine, public | la_qlaqz0 (wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, rec, info) |
| QLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**T, B = Q1*T*Z1**T, as computed by QGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**T, T = Q*P*Z**T, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from QGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**T, B = (Q1*Q)*P*(Z1*Z)**T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973),
pp. 241–256.
Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer.
Anal., 29(2006), pp. 199–227.
Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation". | |
| recursive subroutine, public | la_slaqz3 (ilschur, ilq, ilz, n, ilo, ihi, nw, a, lda, b, ldb, q, ldq, z, ldz, ns, nd, alphar, alphai, beta, qc, ldqc, zc, ldzc, work, lwork, rec, info) |
| SLAQZ3: performs AED. | |
| recursive subroutine, public | la_dlaqz3 (ilschur, ilq, ilz, n, ilo, ihi, nw, a, lda, b, ldb, q, ldq, z, ldz, ns, nd, alphar, alphai, beta, qc, ldqc, zc, ldzc, work, lwork, rec, info) |
| DLAQZ3: performs AED. | |
| recursive subroutine, public | la_qlaqz3 (ilschur, ilq, ilz, n, ilo, ihi, nw, a, lda, b, ldb, q, ldq, z, ldz, ns, nd, alphar, alphai, beta, qc, ldqc, zc, ldzc, work, lwork, rec, info) |
| QLAQZ3: performs AED. | |
| pure subroutine, public | la_claqr1 (n, h, ldh, s1, s2, v) |
| Given a 2-by-2 or 3-by-3 matrix H, CLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - s1*I)*(H - s2*I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm. | |
| pure subroutine, public | la_zlaqr1 (n, h, ldh, s1, s2, v) |
| Given a 2-by-2 or 3-by-3 matrix H, ZLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - s1*I)*(H - s2*I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm. | |
| pure subroutine, public | la_wlaqr1 (n, h, ldh, s1, s2, v) |
| Given a 2-by-2 or 3-by-3 matrix H, WLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - s1*I)*(H - s2*I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm. | |
| pure subroutine, public | la_clahqr (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info) |
| CLAHQR: is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI. | |
| pure subroutine, public | la_zlahqr (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info) |
| ZLAHQR: is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI. | |
| pure subroutine, public | la_wlahqr (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info) |
| WLAHQR: is an auxiliary routine called by ZHSEQR to update the eigenvalues and Schur decomposition already computed by ZHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI. | |
| pure subroutine, public | la_claqr5 (wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) |
| CLAQR5: called by CLAQR0 performs a single small-bulge multi-shift QR sweep. | |
| pure subroutine, public | la_zlaqr5 (wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) |
| ZLAQR5:, called by ZLAQR0, performs a single small-bulge multi-shift QR sweep. | |
| pure subroutine, public | la_wlaqr5 (wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) |
| WLAQR5:, called by WLAQR0, performs a single small-bulge multi-shift QR sweep. | |
| pure subroutine, public | la_claqz1 (ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz) |
| CLAQZ1: chases a 1x1 shift bulge in a matrix pencil down a single position. | |
| pure subroutine, public | la_zlaqz1 (ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz) |
| ZLAQZ1: chases a 1x1 shift bulge in a matrix pencil down a single position. | |
| pure subroutine, public | la_wlaqz1 (ilq, ilz, k, istartm, istopm, ihi, a, lda, b, ldb, nq, qstart, q, ldq, nz, zstart, z, ldz) |
| WLAQZ1: chases a 1x1 shift bulge in a matrix pencil down a single position. | |
| pure subroutine, public | la_claqz3 (ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, alpha, beta, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info) |
| CLAQZ3: Executes a single multishift QZ sweep. | |
| pure subroutine, public | la_zlaqz3 (ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, alpha, beta, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info) |
| ZLAQZ3: Executes a single multishift QZ sweep. | |
| pure subroutine, public | la_wlaqz3 (ilschur, ilq, ilz, n, ilo, ihi, nshifts, nblock_desired, alpha, beta, a, lda, b, ldb, q, ldq, z, ldz, qc, ldqc, zc, ldzc, work, lwork, info) |
| WLAQZ3: Executes a single multishift QZ sweep. | |
| pure subroutine, public | la_claqr2 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| CLAQR2: is identical to CLAQR3 except that it avoids recursion by calling CLAHQR instead of CLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| pure subroutine, public | la_zlaqr2 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| ZLAQR2: is identical to ZLAQR3 except that it avoids recursion by calling ZLAHQR instead of ZLAQR4. Aggressive early deflation: ZLAQR2 accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| pure subroutine, public | la_wlaqr2 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| WLAQR2: is identical to WLAQR3 except that it avoids recursion by calling WLAHQR instead of WLAQR4. Aggressive early deflation: WLAQR2 accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| pure subroutine, public | la_claqr0 (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) |
| CLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H. | |
| pure subroutine, public | la_zlaqr0 (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) |
| ZLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H. | |
| pure subroutine, public | la_wlaqr0 (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) |
| WLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H. | |
| pure subroutine, public | la_claqr3 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| Aggressive early deflation: CLAQR3: accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| pure subroutine, public | la_zlaqr3 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| Aggressive early deflation: ZLAQR3: accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| pure subroutine, public | la_wlaqr3 (wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) |
| Aggressive early deflation: WLAQR3: accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries. | |
| pure subroutine, public | la_claqr4 (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) |
| CLAQR4: implements one level of recursion for CLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by CLAQR0 and, for large enough deflation window size, it may be called by CLAQR3. This subroutine is identical to CLAQR0 except that it calls CLAQR2 instead of CLAQR3. CLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H. | |
| pure subroutine, public | la_zlaqr4 (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) |
| ZLAQR4: implements one level of recursion for ZLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by ZLAQR0 and, for large enough deflation window size, it may be called by ZLAQR3. This subroutine is identical to ZLAQR0 except that it calls ZLAQR2 instead of ZLAQR3. ZLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H. | |
| pure subroutine, public | la_wlaqr4 (wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) |
| WLAQR4: implements one level of recursion for WLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by WLAQR0 and, for large enough deflation window size, it may be called by WLAQR3. This subroutine is identical to WLAQR0 except that it calls WLAQR2 instead of WLAQR3. WLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H. | |
| recursive subroutine, public | la_claqz0 (wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, rec, info) |
| CLAQZ0: computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a matrix pair (A,B): A = Q1*H*Z1**H, B = Q1*T*Z1**H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**H, T = Q*P*Z**H, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**H, B = (Q1*Q)*P*(Z1*Z)**H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973),
pp. 241–256.
Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer.
Anal., 29(2006), pp. 199–227.
Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation". | |
| recursive subroutine, public | la_zlaqz0 (wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, rec, info) |
| ZLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**H, B = Q1*T*Z1**H, as computed by ZGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**H, T = Q*P*Z**H, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from ZGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**H, B = (Q1*Q)*P*(Z1*Z)**H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973),
pp. 241–256.
Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer.
Anal., 29(2006), pp. 199–227.
Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation". | |
| recursive subroutine, public | la_wlaqz0 (wants, wantq, wantz, n, ilo, ihi, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, rec, info) |
| WLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**H, B = Q1*T*Z1**H, as computed by WGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**H, T = Q*P*Z**H, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from WGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**H, B = (Q1*Q)*P*(Z1*Z)**H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973),
pp. 241–256.
Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer.
Anal., 29(2006), pp. 199–227.
Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation". | |
| recursive subroutine, public | la_claqz2 (ilschur, ilq, ilz, n, ilo, ihi, nw, a, lda, b, ldb, q, ldq, z, ldz, ns, nd, alpha, beta, qc, ldqc, zc, ldzc, work, lwork, rwork, rec, info) |
| CLAQZ2: performs AED. | |
| recursive subroutine, public | la_zlaqz2 (ilschur, ilq, ilz, n, ilo, ihi, nw, a, lda, b, ldb, q, ldq, z, ldz, ns, nd, alpha, beta, qc, ldqc, zc, ldzc, work, lwork, rwork, rec, info) |
| ZLAQZ2: performs AED. | |
| recursive subroutine, public | la_wlaqz2 (ilschur, ilq, ilz, n, ilo, ihi, nw, a, lda, b, ldb, q, ldq, z, ldz, ns, nd, alpha, beta, qc, ldqc, zc, ldzc, work, lwork, rwork, rec, info) |
| WLAQZ2: performs AED. | |
Detailed Description
Nonsymmetric eigenproblem kernels: multishift QR and QZ sweeps with aggressive early deflation.
Function/Subroutine Documentation
◆ la_clahqr()
| pure subroutine, public la_lapack_eigv_gen3::la_clahqr | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(sp), dimension(*), intent(out) | w, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | info ) |
CLAHQR: is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
◆ la_claqr0()
| pure subroutine, public la_lapack_eigv_gen3::la_claqr0 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(sp), dimension(*), intent(out) | w, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H.
◆ la_claqr1()
| pure subroutine, public la_lapack_eigv_gen3::la_claqr1 | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(ldh,*), intent(in) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(sp), intent(in) | s1, | ||
| complex(sp), intent(in) | s2, | ||
| complex(sp), dimension(*), intent(out) | v ) |
Given a 2-by-2 or 3-by-3 matrix H, CLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - s1*I)*(H - s2*I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.
◆ la_claqr2()
| pure subroutine, public la_lapack_eigv_gen3::la_claqr2 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| complex(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| complex(sp), dimension(*), intent(out) | sh, | ||
| complex(sp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| complex(sp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| complex(sp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
CLAQR2: is identical to CLAQR3 except that it avoids recursion by calling CLAHQR instead of CLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_claqr3()
| pure subroutine, public la_lapack_eigv_gen3::la_claqr3 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| complex(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| complex(sp), dimension(*), intent(out) | sh, | ||
| complex(sp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| complex(sp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| complex(sp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
Aggressive early deflation: CLAQR3: accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_claqr4()
| pure subroutine, public la_lapack_eigv_gen3::la_claqr4 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(sp), dimension(*), intent(out) | w, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CLAQR4: implements one level of recursion for CLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by CLAQR0 and, for large enough deflation window size, it may be called by CLAQR3. This subroutine is identical to CLAQR0 except that it calls CLAQR2 instead of CLAQR3. CLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H.
◆ la_claqr5()
| pure subroutine, public la_lapack_eigv_gen3::la_claqr5 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | kacc22, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nshfts, | ||
| complex(sp), dimension(*), intent(inout) | s, | ||
| complex(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(sp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(sp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| integer(ilp), intent(in) | nv, | ||
| complex(sp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| integer(ilp), intent(in) | nh, | ||
| complex(sp), dimension(ldwh,*), intent(out) | wh, | ||
| integer(ilp), intent(in) | ldwh ) |
CLAQR5: called by CLAQR0 performs a single small-bulge multi-shift QR sweep.
◆ la_claqz0()
| recursive subroutine, public la_lapack_eigv_gen3::la_claqz0 | ( | character, intent(in) | wants, |
| character, intent(in) | wantq, | ||
| character, intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(*), intent(inout) | alpha, | ||
| complex(sp), dimension(*), intent(inout) | beta, | ||
| complex(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(sp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
CLAQZ0: computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a matrix pair (A,B): A = Q1*H*Z1**H, B = Q1*T*Z1**H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**H, T = Q*P*Z**H, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from CGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**H, B = (Q1*Q)*P*(Z1*Z)**H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199–227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation".
◆ la_claqz1()
| pure subroutine, public la_lapack_eigv_gen3::la_claqz1 | ( | logical(lk), intent(in) | ilq, |
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | istartm, | ||
| integer(ilp), intent(in) | istopm, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(in) | nq, | ||
| integer(ilp), intent(in) | qstart, | ||
| complex(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| integer(ilp), intent(in) | nz, | ||
| integer(ilp), intent(in) | zstart, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz ) |
CLAQZ1: chases a 1x1 shift bulge in a matrix pencil down a single position.
◆ la_claqz2()
| recursive subroutine, public la_lapack_eigv_gen3::la_claqz2 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nw, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| complex(sp), dimension(*), intent(inout) | alpha, | ||
| complex(sp), dimension(*), intent(inout) | beta, | ||
| complex(sp), dimension(ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| complex(sp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
CLAQZ2: performs AED.
◆ la_claqz3()
| pure subroutine, public la_lapack_eigv_gen3::la_claqz3 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nshifts, | ||
| integer(ilp), intent(in) | nblock_desired, | ||
| complex(sp), dimension(*), intent(inout) | alpha, | ||
| complex(sp), dimension(*), intent(inout) | beta, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(sp), dimension( ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| complex(sp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| complex(sp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CLAQZ3: Executes a single multishift QZ sweep.
◆ la_dlahqr()
| pure subroutine, public la_lapack_eigv_gen3::la_dlahqr | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(dp), dimension(*), intent(out) | wr, | ||
| real(dp), dimension(*), intent(out) | wi, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | info ) |
DLAHQR: is an auxiliary routine called by DHSEQR to update the eigenvalues and Schur decomposition already computed by DHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
◆ la_dlaqr0()
| subroutine, public la_lapack_eigv_gen3::la_dlaqr0 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(dp), dimension(*), intent(out) | wr, | ||
| real(dp), dimension(*), intent(out) | wi, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T.
◆ la_dlaqr1()
| pure subroutine, public la_lapack_eigv_gen3::la_dlaqr1 | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(ldh,*), intent(in) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(dp), intent(in) | sr1, | ||
| real(dp), intent(in) | si1, | ||
| real(dp), intent(in) | sr2, | ||
| real(dp), intent(in) | si2, | ||
| real(dp), dimension(*), intent(out) | v ) |
Given a 2-by-2 or 3-by-3 matrix H, DLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm.
◆ la_dlaqr2()
| subroutine, public la_lapack_eigv_gen3::la_dlaqr2 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| real(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| real(dp), dimension(*), intent(out) | sr, | ||
| real(dp), dimension(*), intent(out) | si, | ||
| real(dp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| real(dp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| real(dp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
DLAQR2: is identical to DLAQR3 except that it avoids recursion by calling DLAHQR instead of DLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_dlaqr3()
| subroutine, public la_lapack_eigv_gen3::la_dlaqr3 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| real(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| real(dp), dimension(*), intent(out) | sr, | ||
| real(dp), dimension(*), intent(out) | si, | ||
| real(dp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| real(dp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| real(dp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
Aggressive early deflation: DLAQR3: accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_dlaqr4()
| subroutine, public la_lapack_eigv_gen3::la_dlaqr4 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(dp), dimension(*), intent(out) | wr, | ||
| real(dp), dimension(*), intent(out) | wi, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DLAQR4: implements one level of recursion for DLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by DLAQR0 and, for large enough deflation window size, it may be called by DLAQR3. This subroutine is identical to DLAQR0 except that it calls DLAQR2 instead of DLAQR3. DLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T.
◆ la_dlaqr5()
| pure subroutine, public la_lapack_eigv_gen3::la_dlaqr5 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | kacc22, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nshfts, | ||
| real(dp), dimension(*), intent(inout) | sr, | ||
| real(dp), dimension(*), intent(inout) | si, | ||
| real(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(dp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(dp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| integer(ilp), intent(in) | nv, | ||
| real(dp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| integer(ilp), intent(in) | nh, | ||
| real(dp), dimension(ldwh,*), intent(out) | wh, | ||
| integer(ilp), intent(in) | ldwh ) |
DLAQR5:, called by DLAQR0, performs a single small-bulge multi-shift QR sweep.
◆ la_dlaqtr()
| subroutine, public la_lapack_eigv_gen3::la_dlaqtr | ( | logical(lk), intent(in) | ltran, |
| logical(lk), intent(in) | lreal, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(ldt,*), intent(in) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| real(dp), dimension(*), intent(in) | b, | ||
| real(dp), intent(in) | w, | ||
| real(dp), intent(out) | scale, | ||
| real(dp), dimension(*), intent(inout) | x, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
DLAQTR: solves the real quasi-triangular system op(T)*p = scale*c, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)*(p+iq) = scale*(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or A**T, A**T denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine DTRSNA.
◆ la_dlaqz0()
| recursive subroutine, public la_lapack_eigv_gen3::la_dlaqz0 | ( | character, intent(in) | wants, |
| character, intent(in) | wantq, | ||
| character, intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension( *), intent(inout) | alphar, | ||
| real(dp), dimension(*), intent(inout) | alphai, | ||
| real(dp), dimension(*), intent(inout) | beta, | ||
| real(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(dp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
DLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**T, B = Q1*T*Z1**T, as computed by DGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**T, T = Q*P*Z**T, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from DGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**T, B = (Q1*Q)*P*(Z1*Z)**T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199–227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation".
◆ la_dlaqz1()
| pure subroutine, public la_lapack_eigv_gen3::la_dlaqz1 | ( | real(dp), dimension(lda,*), intent(in) | a, |
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), intent(in) | sr1, | ||
| real(dp), intent(in) | sr2, | ||
| real(dp), intent(in) | si, | ||
| real(dp), intent(in) | beta1, | ||
| real(dp), intent(in) | beta2, | ||
| real(dp), dimension(*), intent(out) | v ) |
Given a 3-by-3 matrix pencil (A,B), DLAQZ1: sets v to a scalar multiple of the first column of the product (*) K = (A - (beta2*sr2 - i*si)*B)*B^(-1)*(beta1*A - (sr2 + i*si2)*B)*B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm.
◆ la_dlaqz2()
| pure subroutine, public la_lapack_eigv_gen3::la_dlaqz2 | ( | logical(lk), intent(in) | ilq, |
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | istartm, | ||
| integer(ilp), intent(in) | istopm, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(in) | nq, | ||
| integer(ilp), intent(in) | qstart, | ||
| real(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| integer(ilp), intent(in) | nz, | ||
| integer(ilp), intent(in) | zstart, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz ) |
DLAQZ2: chases a 2x2 shift bulge in a matrix pencil down a single position.
◆ la_dlaqz3()
| recursive subroutine, public la_lapack_eigv_gen3::la_dlaqz3 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nw, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| real(dp), dimension( *), intent(inout) | alphar, | ||
| real(dp), dimension(*), intent(inout) | alphai, | ||
| real(dp), dimension(*), intent(inout) | beta, | ||
| real(dp), dimension(ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| real(dp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
DLAQZ3: performs AED.
◆ la_dlaqz4()
| pure subroutine, public la_lapack_eigv_gen3::la_dlaqz4 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nshifts, | ||
| integer(ilp), intent(in) | nblock_desired, | ||
| real(dp), dimension(*), intent(inout) | sr, | ||
| real(dp), dimension(*), intent(inout) | si, | ||
| real(dp), dimension(*), intent(inout) | ss, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(dp), dimension( ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| real(dp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| real(dp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DLAQZ4: Executes a single multishift QZ sweep.
◆ la_qlahqr()
| pure subroutine, public la_lapack_eigv_gen3::la_qlahqr | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(qp), dimension(*), intent(out) | wr, | ||
| real(qp), dimension(*), intent(out) | wi, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | info ) |
QLAHQR: is an auxiliary routine called by QHSEQR to update the eigenvalues and Schur decomposition already computed by QHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
◆ la_qlaqr0()
| subroutine, public la_lapack_eigv_gen3::la_qlaqr0 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(qp), dimension(*), intent(out) | wr, | ||
| real(qp), dimension(*), intent(out) | wi, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T.
◆ la_qlaqr1()
| pure subroutine, public la_lapack_eigv_gen3::la_qlaqr1 | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(ldh,*), intent(in) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(qp), intent(in) | sr1, | ||
| real(qp), intent(in) | si1, | ||
| real(qp), intent(in) | sr2, | ||
| real(qp), intent(in) | si2, | ||
| real(qp), dimension(*), intent(out) | v ) |
Given a 2-by-2 or 3-by-3 matrix H, QLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm.
◆ la_qlaqr2()
| subroutine, public la_lapack_eigv_gen3::la_qlaqr2 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| real(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| real(qp), dimension(*), intent(out) | sr, | ||
| real(qp), dimension(*), intent(out) | si, | ||
| real(qp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| real(qp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| real(qp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
QLAQR2: is identical to QLAQR3 except that it avoids recursion by calling QLAHQR instead of QLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_qlaqr3()
| subroutine, public la_lapack_eigv_gen3::la_qlaqr3 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| real(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| real(qp), dimension(*), intent(out) | sr, | ||
| real(qp), dimension(*), intent(out) | si, | ||
| real(qp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| real(qp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| real(qp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
Aggressive early deflation: QLAQR3: accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_qlaqr4()
| subroutine, public la_lapack_eigv_gen3::la_qlaqr4 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(qp), dimension(*), intent(out) | wr, | ||
| real(qp), dimension(*), intent(out) | wi, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QLAQR4: implements one level of recursion for QLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by QLAQR0 and, for large enough deflation window size, it may be called by QLAQR3. This subroutine is identical to QLAQR0 except that it calls QLAQR2 instead of QLAQR3. QLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T.
◆ la_qlaqr5()
| pure subroutine, public la_lapack_eigv_gen3::la_qlaqr5 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | kacc22, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nshfts, | ||
| real(qp), dimension(*), intent(inout) | sr, | ||
| real(qp), dimension(*), intent(inout) | si, | ||
| real(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(qp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| integer(ilp), intent(in) | nv, | ||
| real(qp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| integer(ilp), intent(in) | nh, | ||
| real(qp), dimension(ldwh,*), intent(out) | wh, | ||
| integer(ilp), intent(in) | ldwh ) |
QLAQR5:, called by QLAQR0, performs a single small-bulge multi-shift QR sweep.
◆ la_qlaqtr()
| subroutine, public la_lapack_eigv_gen3::la_qlaqtr | ( | logical(lk), intent(in) | ltran, |
| logical(lk), intent(in) | lreal, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(ldt,*), intent(in) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| real(qp), dimension(*), intent(in) | b, | ||
| real(qp), intent(in) | w, | ||
| real(qp), intent(out) | scale, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QLAQTR: solves the real quasi-triangular system op(T)*p = scale*c, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)*(p+iq) = scale*(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or A**T, A**T denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine QTRSNA.
◆ la_qlaqz0()
| recursive subroutine, public la_lapack_eigv_gen3::la_qlaqz0 | ( | character, intent(in) | wants, |
| character, intent(in) | wantq, | ||
| character, intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension( *), intent(inout) | alphar, | ||
| real(qp), dimension(*), intent(inout) | alphai, | ||
| real(qp), dimension(*), intent(inout) | beta, | ||
| real(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
QLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**T, B = Q1*T*Z1**T, as computed by QGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**T, T = Q*P*Z**T, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from QGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**T, B = (Q1*Q)*P*(Z1*Z)**T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199–227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation".
◆ la_qlaqz1()
| pure subroutine, public la_lapack_eigv_gen3::la_qlaqz1 | ( | real(qp), dimension(lda,*), intent(in) | a, |
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | sr1, | ||
| real(qp), intent(in) | sr2, | ||
| real(qp), intent(in) | si, | ||
| real(qp), intent(in) | beta1, | ||
| real(qp), intent(in) | beta2, | ||
| real(qp), dimension(*), intent(out) | v ) |
Given a 3-by-3 matrix pencil (A,B), QLAQZ1: sets v to a scalar multiple of the first column of the product (*) K = (A - (beta2*sr2 - i*si)*B)*B^(-1)*(beta1*A - (sr2 + i*si2)*B)*B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm.
◆ la_qlaqz2()
| pure subroutine, public la_lapack_eigv_gen3::la_qlaqz2 | ( | logical(lk), intent(in) | ilq, |
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | istartm, | ||
| integer(ilp), intent(in) | istopm, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(in) | nq, | ||
| integer(ilp), intent(in) | qstart, | ||
| real(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| integer(ilp), intent(in) | nz, | ||
| integer(ilp), intent(in) | zstart, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz ) |
QLAQZ2: chases a 2x2 shift bulge in a matrix pencil down a single position.
◆ la_qlaqz3()
| recursive subroutine, public la_lapack_eigv_gen3::la_qlaqz3 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nw, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| real(qp), dimension( *), intent(inout) | alphar, | ||
| real(qp), dimension(*), intent(inout) | alphai, | ||
| real(qp), dimension(*), intent(inout) | beta, | ||
| real(qp), dimension(ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| real(qp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
QLAQZ3: performs AED.
◆ la_qlaqz4()
| pure subroutine, public la_lapack_eigv_gen3::la_qlaqz4 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nshifts, | ||
| integer(ilp), intent(in) | nblock_desired, | ||
| real(qp), dimension(*), intent(inout) | sr, | ||
| real(qp), dimension(*), intent(inout) | si, | ||
| real(qp), dimension(*), intent(inout) | ss, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(qp), dimension( ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| real(qp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| real(qp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QLAQZ4: Executes a single multishift QZ sweep.
◆ la_slahqr()
| pure subroutine, public la_lapack_eigv_gen3::la_slahqr | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(sp), dimension(*), intent(out) | wr, | ||
| real(sp), dimension(*), intent(out) | wi, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | info ) |
SLAHQR: is an auxiliary routine called by SHSEQR to update the eigenvalues and Schur decomposition already computed by SHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
◆ la_slaqr0()
| subroutine, public la_lapack_eigv_gen3::la_slaqr0 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(sp), dimension(*), intent(out) | wr, | ||
| real(sp), dimension(*), intent(out) | wi, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T.
◆ la_slaqr1()
| pure subroutine, public la_lapack_eigv_gen3::la_slaqr1 | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(ldh,*), intent(in) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(sp), intent(in) | sr1, | ||
| real(sp), intent(in) | si1, | ||
| real(sp), intent(in) | sr2, | ||
| real(sp), intent(in) | si2, | ||
| real(sp), dimension(*), intent(out) | v ) |
Given a 2-by-2 or 3-by-3 matrix H, SLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I) scaling to avoid overflows and most underflows. It is assumed that either 1) sr1 = sr2 and si1 = -si2 or 2) si1 = si2 = 0. This is useful for starting double implicit shift bulges in the QR algorithm.
◆ la_slaqr2()
| subroutine, public la_lapack_eigv_gen3::la_slaqr2 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| real(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| real(sp), dimension(*), intent(out) | sr, | ||
| real(sp), dimension(*), intent(out) | si, | ||
| real(sp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| real(sp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| real(sp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
SLAQR2: is identical to SLAQR3 except that it avoids recursion by calling SLAHQR instead of SLAQR4. Aggressive early deflation: This subroutine accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_slaqr3()
| subroutine, public la_lapack_eigv_gen3::la_slaqr3 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| real(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| real(sp), dimension(*), intent(out) | sr, | ||
| real(sp), dimension(*), intent(out) | si, | ||
| real(sp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| real(sp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| real(sp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
Aggressive early deflation: SLAQR3: accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an orthogonal similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_slaqr4()
| subroutine, public la_lapack_eigv_gen3::la_slaqr4 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| real(sp), dimension(*), intent(out) | wr, | ||
| real(sp), dimension(*), intent(out) | wi, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SLAQR4: implements one level of recursion for SLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by SLAQR0 and, for large enough deflation window size, it may be called by SLAQR3. This subroutine is identical to SLAQR0 except that it calls SLAQR2 instead of SLAQR3. SLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**T, where T is an upper quasi-triangular matrix (the Schur form), and Z is the orthogonal matrix of Schur vectors. Optionally Z may be postmultiplied into an input orthogonal matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T.
◆ la_slaqr5()
| pure subroutine, public la_lapack_eigv_gen3::la_slaqr5 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | kacc22, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nshfts, | ||
| real(sp), dimension(*), intent(inout) | sr, | ||
| real(sp), dimension(*), intent(inout) | si, | ||
| real(sp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(sp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(sp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| integer(ilp), intent(in) | nv, | ||
| real(sp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| integer(ilp), intent(in) | nh, | ||
| real(sp), dimension(ldwh,*), intent(out) | wh, | ||
| integer(ilp), intent(in) | ldwh ) |
SLAQR5:, called by SLAQR0, performs a single small-bulge multi-shift QR sweep.
◆ la_slaqtr()
| subroutine, public la_lapack_eigv_gen3::la_slaqtr | ( | logical(lk), intent(in) | ltran, |
| logical(lk), intent(in) | lreal, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(ldt,*), intent(in) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| real(sp), dimension(*), intent(in) | b, | ||
| real(sp), intent(in) | w, | ||
| real(sp), intent(out) | scale, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
SLAQTR: solves the real quasi-triangular system op(T)*p = scale*c, if LREAL = .TRUE. or the complex quasi-triangular systems op(T + iB)*(p+iq) = scale*(c+id), if LREAL = .FALSE. in real arithmetic, where T is upper quasi-triangular. If LREAL = .FALSE., then the first diagonal block of T must be 1 by 1, B is the specially structured matrix B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or A**T, A**T denotes the transpose of matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] This subroutine is designed for the condition number estimation in routine STRSNA.
◆ la_slaqz0()
| recursive subroutine, public la_lapack_eigv_gen3::la_slaqz0 | ( | character, intent(in) | wants, |
| character, intent(in) | wantq, | ||
| character, intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension( *), intent(inout) | alphar, | ||
| real(sp), dimension(*), intent(inout) | alphai, | ||
| real(sp), dimension(*), intent(inout) | beta, | ||
| real(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(sp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
SLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**T, B = Q1*T*Z1**T, as computed by SGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**T, T = Q*P*Z**T, where Q and Z are orthogonal matrices, P is an upper triangular matrix, and S is a quasi-triangular matrix with 1-by-1 and 2-by-2 diagonal blocks. The 1-by-1 blocks correspond to real eigenvalues of the matrix pair (H,T) and the 2-by-2 blocks correspond to complex conjugate pairs of eigenvalues. Additionally, the 2-by-2 upper triangular diagonal blocks of P corresponding to 2-by-2 blocks of S are reduced to positive diagonal form, i.e., if S(j+1,j) is non-zero, then P(j+1,j) = P(j,j+1) = 0, P(j,j) > 0, and P(j+1,j+1) > 0. Optionally, the orthogonal matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the orthogonal matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the orthogonal matrices from SGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**T, B = (Q1*Q)*P*(Z1*Z)**T. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Real eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199–227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation".
◆ la_slaqz1()
| pure subroutine, public la_lapack_eigv_gen3::la_slaqz1 | ( | real(sp), dimension(lda,*), intent(in) | a, |
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | sr1, | ||
| real(sp), intent(in) | sr2, | ||
| real(sp), intent(in) | si, | ||
| real(sp), intent(in) | beta1, | ||
| real(sp), intent(in) | beta2, | ||
| real(sp), dimension(*), intent(out) | v ) |
Given a 3-by-3 matrix pencil (A,B), SLAQZ1: sets v to a scalar multiple of the first column of the product (*) K = (A - (beta2*sr2 - i*si)*B)*B^(-1)*(beta1*A - (sr2 + i*si2)*B)*B^(-1). It is assumed that either 1) sr1 = sr2 or 2) si = 0. This is useful for starting double implicit shift bulges in the QZ algorithm.
◆ la_slaqz2()
| pure subroutine, public la_lapack_eigv_gen3::la_slaqz2 | ( | logical(lk), intent(in) | ilq, |
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | istartm, | ||
| integer(ilp), intent(in) | istopm, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(in) | nq, | ||
| integer(ilp), intent(in) | qstart, | ||
| real(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| integer(ilp), intent(in) | nz, | ||
| integer(ilp), intent(in) | zstart, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz ) |
SLAQZ2: chases a 2x2 shift bulge in a matrix pencil down a single position.
◆ la_slaqz3()
| recursive subroutine, public la_lapack_eigv_gen3::la_slaqz3 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nw, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| real(sp), dimension( *), intent(inout) | alphar, | ||
| real(sp), dimension(*), intent(inout) | alphai, | ||
| real(sp), dimension(*), intent(inout) | beta, | ||
| real(sp), dimension(ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| real(sp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
SLAQZ3: performs AED.
◆ la_slaqz4()
| pure subroutine, public la_lapack_eigv_gen3::la_slaqz4 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nshifts, | ||
| integer(ilp), intent(in) | nblock_desired, | ||
| real(sp), dimension(*), intent(inout) | sr, | ||
| real(sp), dimension(*), intent(inout) | si, | ||
| real(sp), dimension(*), intent(inout) | ss, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| real(sp), dimension( ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| real(sp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| real(sp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SLAQZ4: Executes a single multishift QZ sweep.
◆ la_wlahqr()
| pure subroutine, public la_lapack_eigv_gen3::la_wlahqr | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(qp), dimension(*), intent(out) | w, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | info ) |
WLAHQR: is an auxiliary routine called by ZHSEQR to update the eigenvalues and Schur decomposition already computed by ZHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
◆ la_wlaqr0()
| pure subroutine, public la_lapack_eigv_gen3::la_wlaqr0 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(qp), dimension(*), intent(out) | w, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H.
◆ la_wlaqr1()
| pure subroutine, public la_lapack_eigv_gen3::la_wlaqr1 | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(ldh,*), intent(in) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(qp), intent(in) | s1, | ||
| complex(qp), intent(in) | s2, | ||
| complex(qp), dimension(*), intent(out) | v ) |
Given a 2-by-2 or 3-by-3 matrix H, WLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - s1*I)*(H - s2*I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.
◆ la_wlaqr2()
| pure subroutine, public la_lapack_eigv_gen3::la_wlaqr2 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| complex(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| complex(qp), dimension(*), intent(out) | sh, | ||
| complex(qp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| complex(qp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| complex(qp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
WLAQR2: is identical to WLAQR3 except that it avoids recursion by calling WLAHQR instead of WLAQR4. Aggressive early deflation: WLAQR2 accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_wlaqr3()
| pure subroutine, public la_lapack_eigv_gen3::la_wlaqr3 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| complex(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| complex(qp), dimension(*), intent(out) | sh, | ||
| complex(qp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| complex(qp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| complex(qp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
Aggressive early deflation: WLAQR3: accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_wlaqr4()
| pure subroutine, public la_lapack_eigv_gen3::la_wlaqr4 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(qp), dimension(*), intent(out) | w, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WLAQR4: implements one level of recursion for WLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by WLAQR0 and, for large enough deflation window size, it may be called by WLAQR3. This subroutine is identical to WLAQR0 except that it calls WLAQR2 instead of WLAQR3. WLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H.
◆ la_wlaqr5()
| pure subroutine, public la_lapack_eigv_gen3::la_wlaqr5 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | kacc22, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nshfts, | ||
| complex(qp), dimension(*), intent(inout) | s, | ||
| complex(qp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(qp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| integer(ilp), intent(in) | nv, | ||
| complex(qp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| integer(ilp), intent(in) | nh, | ||
| complex(qp), dimension(ldwh,*), intent(out) | wh, | ||
| integer(ilp), intent(in) | ldwh ) |
WLAQR5:, called by WLAQR0, performs a single small-bulge multi-shift QR sweep.
◆ la_wlaqz0()
| recursive subroutine, public la_lapack_eigv_gen3::la_wlaqz0 | ( | character, intent(in) | wants, |
| character, intent(in) | wantq, | ||
| character, intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(*), intent(inout) | alpha, | ||
| complex(qp), dimension(*), intent(inout) | beta, | ||
| complex(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
WLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**H, B = Q1*T*Z1**H, as computed by WGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**H, T = Q*P*Z**H, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from WGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**H, B = (Q1*Q)*P*(Z1*Z)**H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199–227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation".
◆ la_wlaqz1()
| pure subroutine, public la_lapack_eigv_gen3::la_wlaqz1 | ( | logical(lk), intent(in) | ilq, |
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | istartm, | ||
| integer(ilp), intent(in) | istopm, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(in) | nq, | ||
| integer(ilp), intent(in) | qstart, | ||
| complex(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| integer(ilp), intent(in) | nz, | ||
| integer(ilp), intent(in) | zstart, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz ) |
WLAQZ1: chases a 1x1 shift bulge in a matrix pencil down a single position.
◆ la_wlaqz2()
| recursive subroutine, public la_lapack_eigv_gen3::la_wlaqz2 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nw, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| complex(qp), dimension(*), intent(inout) | alpha, | ||
| complex(qp), dimension(*), intent(inout) | beta, | ||
| complex(qp), dimension(ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| complex(qp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(qp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
WLAQZ2: performs AED.
◆ la_wlaqz3()
| pure subroutine, public la_lapack_eigv_gen3::la_wlaqz3 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nshifts, | ||
| integer(ilp), intent(in) | nblock_desired, | ||
| complex(qp), dimension(*), intent(inout) | alpha, | ||
| complex(qp), dimension(*), intent(inout) | beta, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(qp), dimension( ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| complex(qp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| complex(qp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WLAQZ3: Executes a single multishift QZ sweep.
◆ la_zlahqr()
| pure subroutine, public la_lapack_eigv_gen3::la_zlahqr | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(dp), dimension(*), intent(out) | w, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | info ) |
ZLAHQR: is an auxiliary routine called by CHSEQR to update the eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with the Hessenberg submatrix in rows and columns ILO to IHI.
◆ la_zlaqr0()
| pure subroutine, public la_lapack_eigv_gen3::la_zlaqr0 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(dp), dimension(*), intent(out) | w, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZLAQR0: computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H.
◆ la_zlaqr1()
| pure subroutine, public la_lapack_eigv_gen3::la_zlaqr1 | ( | integer(ilp), intent(in) | n, |
| complex(dp), dimension(ldh,*), intent(in) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(dp), intent(in) | s1, | ||
| complex(dp), intent(in) | s2, | ||
| complex(dp), dimension(*), intent(out) | v ) |
Given a 2-by-2 or 3-by-3 matrix H, ZLAQR1: sets v to a scalar multiple of the first column of the product (*) K = (H - s1*I)*(H - s2*I) scaling to avoid overflows and most underflows. This is useful for starting double implicit shift bulges in the QR algorithm.
◆ la_zlaqr2()
| pure subroutine, public la_lapack_eigv_gen3::la_zlaqr2 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| complex(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| complex(dp), dimension(*), intent(out) | sh, | ||
| complex(dp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| complex(dp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| complex(dp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
ZLAQR2: is identical to ZLAQR3 except that it avoids recursion by calling ZLAHQR instead of ZLAQR4. Aggressive early deflation: ZLAQR2 accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_zlaqr3()
| pure subroutine, public la_lapack_eigv_gen3::la_zlaqr3 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nw, | ||
| complex(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| complex(dp), dimension(*), intent(out) | sh, | ||
| complex(dp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(in) | nh, | ||
| complex(dp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| integer(ilp), intent(in) | nv, | ||
| complex(dp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork ) |
Aggressive early deflation: ZLAQR3: accepts as input an upper Hessenberg matrix H and performs an unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. On output H has been over- written by a new Hessenberg matrix that is a perturbation of an unitary similarity transformation of H. It is to be hoped that the final version of H has many zero subdiagonal entries.
◆ la_zlaqr4()
| pure subroutine, public la_lapack_eigv_gen3::la_zlaqr4 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| complex(dp), dimension(*), intent(out) | w, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZLAQR4: implements one level of recursion for ZLAQR0. It is a complete implementation of the small bulge multi-shift QR algorithm. It may be called by ZLAQR0 and, for large enough deflation window size, it may be called by ZLAQR3. This subroutine is identical to ZLAQR0 except that it calls ZLAQR2 instead of ZLAQR3. ZLAQR4 computes the eigenvalues of a Hessenberg matrix H and, optionally, the matrices T and Z from the Schur decomposition H = Z T Z**H, where T is an upper triangular matrix (the Schur form), and Z is the unitary matrix of Schur vectors. Optionally Z may be postmultiplied into an input unitary matrix Q so that this routine can give the Schur factorization of a matrix A which has been reduced to the Hessenberg form H by the unitary matrix Q: A = Q*H*Q**H = (QZ)*H*(QZ)**H.
◆ la_zlaqr5()
| pure subroutine, public la_lapack_eigv_gen3::la_zlaqr5 | ( | logical(lk), intent(in) | wantt, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | kacc22, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ktop, | ||
| integer(ilp), intent(in) | kbot, | ||
| integer(ilp), intent(in) | nshfts, | ||
| complex(dp), dimension(*), intent(inout) | s, | ||
| complex(dp), dimension(ldh,*), intent(inout) | h, | ||
| integer(ilp), intent(in) | ldh, | ||
| integer(ilp), intent(in) | iloz, | ||
| integer(ilp), intent(in) | ihiz, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(dp), dimension(ldv,*), intent(out) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(dp), dimension(ldu,*), intent(out) | u, | ||
| integer(ilp), intent(in) | ldu, | ||
| integer(ilp), intent(in) | nv, | ||
| complex(dp), dimension(ldwv,*), intent(out) | wv, | ||
| integer(ilp), intent(in) | ldwv, | ||
| integer(ilp), intent(in) | nh, | ||
| complex(dp), dimension(ldwh,*), intent(out) | wh, | ||
| integer(ilp), intent(in) | ldwh ) |
ZLAQR5:, called by ZLAQR0, performs a single small-bulge multi-shift QR sweep.
◆ la_zlaqz0()
| recursive subroutine, public la_lapack_eigv_gen3::la_zlaqz0 | ( | character, intent(in) | wants, |
| character, intent(in) | wantq, | ||
| character, intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(*), intent(inout) | alpha, | ||
| complex(dp), dimension(*), intent(inout) | beta, | ||
| complex(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(dp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
ZLAQZ0: computes the eigenvalues of a real matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the double-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a real matrix pair (A,B): A = Q1*H*Z1**H, B = Q1*T*Z1**H, as computed by ZGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = Q*S*Z**H, T = Q*P*Z**H, where Q and Z are unitary matrices, P and S are an upper triangular matrices. Optionally, the unitary matrix Q from the generalized Schur factorization may be postmultiplied into an input matrix Q1, and the unitary matrix Z may be postmultiplied into an input matrix Z1. If Q1 and Z1 are the unitary matrices from ZGGHRD that reduced the matrix pair (A,B) to generalized upper Hessenberg form, then the output matrices Q1*Q and Z1*Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1*Q)*S*(Z1*Z)**H, B = (Q1*Q)*P*(Z1*Z)**H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of values (alpha,beta), where alpha is complex and beta real. If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) A*x = lambda*B*x and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP mu*A*y = B*y. Eigenvalues can be read directly from the generalized Schur form: alpha = S(i,i), beta = P(i,i). Ref: C.B. Moler Eigenvalue Problems", SIAM J. Numer. Anal., 10(1973), pp. 241–256. Ref: B. Kagstrom, D. Kressner, "Multishift Variants of the QZ Algorithm with Aggressive Early Deflation", SIAM J. Numer. Anal., 29(2006), pp. 199–227. Ref: T. Steel, D. Camps, K. Meerbergen, R. Vandebril "A multishift, multipole rational QZ method with agressive early deflation".
◆ la_zlaqz1()
| pure subroutine, public la_lapack_eigv_gen3::la_zlaqz1 | ( | logical(lk), intent(in) | ilq, |
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | istartm, | ||
| integer(ilp), intent(in) | istopm, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| integer(ilp), intent(in) | nq, | ||
| integer(ilp), intent(in) | qstart, | ||
| complex(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| integer(ilp), intent(in) | nz, | ||
| integer(ilp), intent(in) | zstart, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz ) |
ZLAQZ1: chases a 1x1 shift bulge in a matrix pencil down a single position.
◆ la_zlaqz2()
| recursive subroutine, public la_lapack_eigv_gen3::la_zlaqz2 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nw, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | ns, | ||
| integer(ilp), intent(out) | nd, | ||
| complex(dp), dimension(*), intent(inout) | alpha, | ||
| complex(dp), dimension(*), intent(inout) | beta, | ||
| complex(dp), dimension(ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| complex(dp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| integer(ilp), intent(in) | rec, | ||
| integer(ilp), intent(out) | info ) |
ZLAQZ2: performs AED.
◆ la_zlaqz3()
| pure subroutine, public la_lapack_eigv_gen3::la_zlaqz3 | ( | logical(lk), intent(in) | ilschur, |
| logical(lk), intent(in) | ilq, | ||
| logical(lk), intent(in) | ilz, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| integer(ilp), intent(in) | nshifts, | ||
| integer(ilp), intent(in) | nblock_desired, | ||
| complex(dp), dimension(*), intent(inout) | alpha, | ||
| complex(dp), dimension(*), intent(inout) | beta, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| complex(dp), dimension( ldqc,*), intent(inout) | qc, | ||
| integer(ilp), intent(in) | ldqc, | ||
| complex(dp), dimension(ldzc,*), intent(inout) | zc, | ||
| integer(ilp), intent(in) | ldzc, | ||
| complex(dp), dimension(*), intent(inout) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZLAQZ3: Executes a single multishift QZ sweep.
