Generalized nonsymmetric eigenproblem components: balancing, Hessenberg-triangular reduction, QZ iteration. More...

Functions/Subroutines
pure subroutine, public	la_sggbak (job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)
	SGGBAK: forms the right or left eigenvectors of a real generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by SGGBAL.

pure subroutine, public	la_dggbak (job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)
	DGGBAK: forms the right or left eigenvectors of a real generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by DGGBAL.

pure subroutine, public	la_qggbak (job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)
	QGGBAK: forms the right or left eigenvectors of a real generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by QGGBAL.

pure subroutine, public	la_sggbal (job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)
	SGGBAL: balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

pure subroutine, public	la_dggbal (job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)
	DGGBAL: balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

pure subroutine, public	la_qggbal (job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)
	QGGBAL: balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

pure subroutine, public	la_sgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)
	SGGHRD: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Tx. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*T = (Q1Q) * H * (Z1Z)T Q1 B * Z1*T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaBx, then SGGHRD reduces the original problem to generalized Hessenberg form.

pure subroutine, public	la_dgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)
	DGGHRD: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Tx. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*T = (Q1Q) * H * (Z1Z)T Q1 B * Z1*T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaBx, then DGGHRD reduces the original problem to generalized Hessenberg form.

pure subroutine, public	la_qgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)
	QGGHRD: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Tx. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*T = (Q1Q) * H * (Z1Z)T Q1 B * Z1*T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaBx, then QGGHRD reduces the original problem to generalized Hessenberg form.

pure subroutine, public	la_sgghd3 (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, info)
	SGGHD3: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Tx. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*T = (Q1Q) * H * (Z1Z)T Q1 B * Z1*T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaBx, then SGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of SGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

pure subroutine, public	la_dgghd3 (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, info)
	DGGHD3: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Tx. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*T = (Q1Q) * H * (Z1Z)T Q1 B * Z1*T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaBx, then DGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of DGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

pure subroutine, public	la_qgghd3 (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, info)
	QGGHD3: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QTAZ = H and transforms B to another upper triangular matrix T: QTBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Tx. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*T = (Q1Q) * H * (Z1Z)T Q1 B * Z1*T = (Q1Q) * T * (Z1Z)T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation Ax = lambdaBx, then QGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of QGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

subroutine, public	la_shgeqz (job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, info)
	SHGEQZ: 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 = Q1HZ1*T, B = Q1TZ1T, as computed by SGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, 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 Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)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) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = 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.

subroutine, public	la_dhgeqz (job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, info)
	DHGEQZ: 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 = Q1HZ1*T, B = Q1TZ1T, as computed by DGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, 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 Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)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) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = 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.

subroutine, public	la_qhgeqz (job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, ldq, z, ldz, work, lwork, info)
	QHGEQZ: 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 = Q1HZ1*T, B = Q1TZ1T, as computed by QGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZT, T = QPZT, 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 Q1Q and Z1Z are the orthogonal factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)T, B = (Q1Q)P(Z1Z)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) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = 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.

pure subroutine, public	la_cggbak (job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)
	CGGBAK: forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by CGGBAL.

pure subroutine, public	la_zggbak (job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)
	ZGGBAK: forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by ZGGBAL.

pure subroutine, public	la_wggbak (job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info)
	WGGBAK: forms the right or left eigenvectors of a complex generalized eigenvalue problem Ax = lambdaB*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by WGGBAL.

pure subroutine, public	la_cggbal (job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)
	CGGBAL: balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

pure subroutine, public	la_zggbal (job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)
	ZGGBAL: balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

pure subroutine, public	la_wggbal (job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info)
	WGGBAL: balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem Ax = lambdaB*x.

pure subroutine, public	la_cgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)
	CGGHRD: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Hx. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*H = (Q1Q) * H * (Z1Z)H Q1 B * Z1*H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaBx, then CGGHRD reduces the original problem to generalized Hessenberg form.

pure subroutine, public	la_zgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)
	ZGGHRD: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Hx. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*H = (Q1Q) * H * (Z1Z)H Q1 B * Z1*H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaBx, then ZGGHRD reduces the original problem to generalized Hessenberg form.

pure subroutine, public	la_wgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info)
	WGGHRD: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Hx. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*H = (Q1Q) * H * (Z1Z)H Q1 B * Z1*H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaBx, then WGGHRD reduces the original problem to generalized Hessenberg form.

pure subroutine, public	la_cgghd3 (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, info)
	CGGHD3: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Hx. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*H = (Q1Q) * H * (Z1Z)H Q1 B * Z1*H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaBx, then CGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of CGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

pure subroutine, public	la_zgghd3 (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, info)
	ZGGHD3: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Hx. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*H = (Q1Q) * H * (Z1Z)H Q1 B * Z1*H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaBx, then ZGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of CGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

pure subroutine, public	la_wgghd3 (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, info)
	WGGHD3: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is Ax = lambdaBx, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: QHAZ = H and transforms B to another upper triangular matrix T: QHBZ = T in order to reduce the problem to its standard form Hy = lambdaTy where y = Z*Hx. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1*H = (Q1Q) * H * (Z1Z)H Q1 B * Z1*H = (Q1Q) * T * (Z1Z)H If Q1 is the unitary matrix from the QR factorization of B in the original equation Ax = lambdaBx, then WGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of ZGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

subroutine, public	la_chgeqz (job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info)
	CHGEQZ: computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1*H, B = Q1TZ1H, as computed by CGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. 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 Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = B*y. The values of alpha and beta for the i-th eigenvalue 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.

subroutine, public	la_zhgeqz (job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info)
	ZHGEQZ: computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1*H, B = Q1TZ1H, as computed by ZGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. 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 Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = B*y. The values of alpha and beta for the i-th eigenvalue 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.

subroutine, public	la_whgeqz (job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, work, lwork, rwork, info)
	WHGEQZ: computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex matrix pair (A,B): A = Q1HZ1*H, B = Q1TZ1H, as computed by WGGHRD. If JOB='S', then the Hessenberg-triangular pair (H,T) is also reduced to generalized Schur form, H = QSZH, T = QPZH, where Q and Z are unitary matrices and S and P are upper triangular. 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 Hessenberg form, then the output matrices Q1Q and Z1Z are the unitary factors from the generalized Schur factorization of (A,B): A = (Q1Q)S(Z1Z)H, B = (Q1Q)P(Z1Z)H. To avoid overflow, eigenvalues of the matrix pair (H,T) (equivalently, of (A,B)) are computed as a pair of complex values (alpha,beta). If beta is nonzero, lambda = alpha / beta is an eigenvalue of the generalized nonsymmetric eigenvalue problem (GNEP) Ax = lambdaBx and if alpha is nonzero, mu = beta / alpha is an eigenvalue of the alternate form of the GNEP muAy = B*y. The values of alpha and beta for the i-th eigenvalue 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.

Detailed Description

Generalized nonsymmetric eigenproblem components: balancing, Hessenberg-triangular reduction, QZ iteration.

Function/Subroutine Documentation

◆ la_cggbak()

pure subroutine, public la_lapack_eigv_comp::la_cggbak	(	character, intent(in)	job,
		character, intent(in)	side,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		real(sp), dimension(*), intent(in)	lscale,
		real(sp), dimension(*), intent(in)	rscale,
		integer(ilp), intent(in)	m,
		complex(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	info )

CGGBAK: forms the right or left eigenvectors of a complex generalized eigenvalue problem A*x = lambda*B*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by CGGBAL.

Here is the call graph for this function:

◆ la_cggbal()

pure subroutine, public la_lapack_eigv_comp::la_cggbal	(	character, intent(in)	job,
		integer(ilp), intent(in)	n,
		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(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(sp), dimension(*), intent(out)	lscale,
		real(sp), dimension(*), intent(out)	rscale,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

CGGBAL: balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem A*x = lambda*B*x.

Here is the call graph for this function:

◆ la_cgghd3()

pure subroutine, public la_lapack_eigv_comp::la_cgghd3	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

CGGHD3: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**H*A*Z = H and transforms B to another upper triangular matrix T: Q**H*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**H*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then CGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of CGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

Here is the call graph for this function:

◆ la_cgghrd()

pure subroutine, public la_lapack_eigv_comp::la_cgghrd	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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)	info )

CGGHRD: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**H*A*Z = H and transforms B to another upper triangular matrix T: Q**H*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**H*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then CGGHRD reduces the original problem to generalized Hessenberg form.

Here is the call graph for this function:

◆ la_chgeqz()

subroutine, public la_lapack_eigv_comp::la_chgeqz	(	character, intent(in)	job,
		character, intent(in)	compq,
		character, intent(in)	compz,
		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(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(*), intent(out)	alpha,
		complex(sp), dimension(*), intent(out)	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(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

CHGEQZ: computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex 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 and S and P are upper triangular. 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 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 complex values (alpha,beta). 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. The values of alpha and beta for the i-th eigenvalue 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.

Here is the call graph for this function:

◆ la_dggbak()

pure subroutine, public la_lapack_eigv_comp::la_dggbak	(	character, intent(in)	job,
		character, intent(in)	side,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		real(dp), dimension(*), intent(in)	lscale,
		real(dp), dimension(*), intent(in)	rscale,
		integer(ilp), intent(in)	m,
		real(dp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	info )

DGGBAK: forms the right or left eigenvectors of a real generalized eigenvalue problem A*x = lambda*B*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by DGGBAL.

Here is the call graph for this function:

◆ la_dggbal()

pure subroutine, public la_lapack_eigv_comp::la_dggbal	(	character, intent(in)	job,
		integer(ilp), intent(in)	n,
		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(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(dp), dimension(*), intent(out)	lscale,
		real(dp), dimension(*), intent(out)	rscale,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

DGGBAL: balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem A*x = lambda*B*x.

Here is the call graph for this function:

◆ la_dgghd3()

pure subroutine, public la_lapack_eigv_comp::la_dgghd3	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

DGGHD3: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**T*A*Z = H and transforms B to another upper triangular matrix T: Q**T*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**T*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then DGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of DGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

Here is the call graph for this function:

◆ la_dgghrd()

pure subroutine, public la_lapack_eigv_comp::la_dgghrd	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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)	info )

DGGHRD: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**T*A*Z = H and transforms B to another upper triangular matrix T: Q**T*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**T*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then DGGHRD reduces the original problem to generalized Hessenberg form.

Here is the call graph for this function:

◆ la_dhgeqz()

subroutine, public la_lapack_eigv_comp::la_dhgeqz	(	character, intent(in)	job,
		character, intent(in)	compq,
		character, intent(in)	compz,
		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(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		real(dp), dimension(*), intent(out)	alphar,
		real(dp), dimension(*), intent(out)	alphai,
		real(dp), dimension(*), intent(out)	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(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

DHGEQZ: 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.

Here is the call graph for this function:

◆ la_qggbak()

pure subroutine, public la_lapack_eigv_comp::la_qggbak	(	character, intent(in)	job,
		character, intent(in)	side,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		real(qp), dimension(*), intent(in)	lscale,
		real(qp), dimension(*), intent(in)	rscale,
		integer(ilp), intent(in)	m,
		real(qp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	info )

QGGBAK: forms the right or left eigenvectors of a real generalized eigenvalue problem A*x = lambda*B*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by QGGBAL.

Here is the call graph for this function:

◆ la_qggbal()

pure subroutine, public la_lapack_eigv_comp::la_qggbal	(	character, intent(in)	job,
		integer(ilp), intent(in)	n,
		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(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(qp), dimension(*), intent(out)	lscale,
		real(qp), dimension(*), intent(out)	rscale,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

QGGBAL: balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem A*x = lambda*B*x.

Here is the call graph for this function:

◆ la_qgghd3()

pure subroutine, public la_lapack_eigv_comp::la_qgghd3	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

QGGHD3: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**T*A*Z = H and transforms B to another upper triangular matrix T: Q**T*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**T*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then QGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of QGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

Here is the call graph for this function:

◆ la_qgghrd()

pure subroutine, public la_lapack_eigv_comp::la_qgghrd	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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)	info )

QGGHRD: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**T*A*Z = H and transforms B to another upper triangular matrix T: Q**T*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**T*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then QGGHRD reduces the original problem to generalized Hessenberg form.

Here is the call graph for this function:

◆ la_qhgeqz()

subroutine, public la_lapack_eigv_comp::la_qhgeqz	(	character, intent(in)	job,
		character, intent(in)	compq,
		character, intent(in)	compz,
		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(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		real(qp), dimension(*), intent(out)	alphar,
		real(qp), dimension(*), intent(out)	alphai,
		real(qp), dimension(*), intent(out)	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(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

QHGEQZ: 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.

Here is the call graph for this function:

◆ la_sggbak()

pure subroutine, public la_lapack_eigv_comp::la_sggbak	(	character, intent(in)	job,
		character, intent(in)	side,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		real(sp), dimension(*), intent(in)	lscale,
		real(sp), dimension(*), intent(in)	rscale,
		integer(ilp), intent(in)	m,
		real(sp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	info )

SGGBAK: forms the right or left eigenvectors of a real generalized eigenvalue problem A*x = lambda*B*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by SGGBAL.

Here is the call graph for this function:

◆ la_sggbal()

pure subroutine, public la_lapack_eigv_comp::la_sggbal	(	character, intent(in)	job,
		integer(ilp), intent(in)	n,
		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(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(sp), dimension(*), intent(out)	lscale,
		real(sp), dimension(*), intent(out)	rscale,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

SGGBAL: balances a pair of general real matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem A*x = lambda*B*x.

Here is the call graph for this function:

◆ la_sgghd3()

pure subroutine, public la_lapack_eigv_comp::la_sgghd3	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

SGGHD3: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**T*A*Z = H and transforms B to another upper triangular matrix T: Q**T*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**T*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then SGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of SGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

Here is the call graph for this function:

◆ la_sgghrd()

pure subroutine, public la_lapack_eigv_comp::la_sgghrd	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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)	info )

SGGHRD: reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**T*A*Z = H and transforms B to another upper triangular matrix T: Q**T*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**T*x. The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T If Q1 is the orthogonal matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then SGGHRD reduces the original problem to generalized Hessenberg form.

Here is the call graph for this function:

◆ la_shgeqz()

subroutine, public la_lapack_eigv_comp::la_shgeqz	(	character, intent(in)	job,
		character, intent(in)	compq,
		character, intent(in)	compz,
		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(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		real(sp), dimension(*), intent(out)	alphar,
		real(sp), dimension(*), intent(out)	alphai,
		real(sp), dimension(*), intent(out)	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(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

SHGEQZ: 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.

Here is the call graph for this function:

◆ la_wggbak()

pure subroutine, public la_lapack_eigv_comp::la_wggbak	(	character, intent(in)	job,
		character, intent(in)	side,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		real(qp), dimension(*), intent(in)	lscale,
		real(qp), dimension(*), intent(in)	rscale,
		integer(ilp), intent(in)	m,
		complex(qp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	info )

WGGBAK: forms the right or left eigenvectors of a complex generalized eigenvalue problem A*x = lambda*B*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by WGGBAL.

Here is the call graph for this function:

◆ la_wggbal()

pure subroutine, public la_lapack_eigv_comp::la_wggbal	(	character, intent(in)	job,
		integer(ilp), intent(in)	n,
		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(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(qp), dimension(*), intent(out)	lscale,
		real(qp), dimension(*), intent(out)	rscale,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

WGGBAL: balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem A*x = lambda*B*x.

Here is the call graph for this function:

◆ la_wgghd3()

pure subroutine, public la_lapack_eigv_comp::la_wgghd3	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

WGGHD3: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**H*A*Z = H and transforms B to another upper triangular matrix T: Q**H*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**H*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then WGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of ZGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

Here is the call graph for this function:

◆ la_wgghrd()

pure subroutine, public la_lapack_eigv_comp::la_wgghrd	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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)	info )

WGGHRD: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**H*A*Z = H and transforms B to another upper triangular matrix T: Q**H*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**H*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then WGGHRD reduces the original problem to generalized Hessenberg form.

Here is the call graph for this function:

◆ la_whgeqz()

subroutine, public la_lapack_eigv_comp::la_whgeqz	(	character, intent(in)	job,
		character, intent(in)	compq,
		character, intent(in)	compz,
		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(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(qp), dimension(*), intent(out)	alpha,
		complex(qp), dimension(*), intent(out)	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(out)	work,
		integer(ilp), intent(in)	lwork,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

WHGEQZ: computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex 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 and S and P are upper triangular. 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 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 complex values (alpha,beta). 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. The values of alpha and beta for the i-th eigenvalue 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.

Here is the call graph for this function:

◆ la_zggbak()

pure subroutine, public la_lapack_eigv_comp::la_zggbak	(	character, intent(in)	job,
		character, intent(in)	side,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	ilo,
		integer(ilp), intent(in)	ihi,
		real(dp), dimension(*), intent(in)	lscale,
		real(dp), dimension(*), intent(in)	rscale,
		integer(ilp), intent(in)	m,
		complex(dp), dimension(ldv,*), intent(inout)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	info )

ZGGBAK: forms the right or left eigenvectors of a complex generalized eigenvalue problem A*x = lambda*B*x, by backward transformation on the computed eigenvectors of the balanced pair of matrices output by ZGGBAL.

Here is the call graph for this function:

◆ la_zggbal()

pure subroutine, public la_lapack_eigv_comp::la_zggbal	(	character, intent(in)	job,
		integer(ilp), intent(in)	n,
		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(out)	ilo,
		integer(ilp), intent(out)	ihi,
		real(dp), dimension(*), intent(out)	lscale,
		real(dp), dimension(*), intent(out)	rscale,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

ZGGBAL: balances a pair of general complex matrices (A,B). This involves, first, permuting A and B by similarity transformations to isolate eigenvalues in the first 1 to ILO$-$1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrices, and improve the accuracy of the computed eigenvalues and/or eigenvectors in the generalized eigenvalue problem A*x = lambda*B*x.

Here is the call graph for this function:

◆ la_zgghd3()

pure subroutine, public la_lapack_eigv_comp::la_zgghd3	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

ZGGHD3: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**H*A*Z = H and transforms B to another upper triangular matrix T: Q**H*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**H*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then ZGGHD3 reduces the original problem to generalized Hessenberg form. This is a blocked variant of CGGHRD, using matrix-matrix multiplications for parts of the computation to enhance performance.

Here is the call graph for this function:

◆ la_zgghrd()

pure subroutine, public la_lapack_eigv_comp::la_zgghrd	(	character, intent(in)	compq,
		character, intent(in)	compz,
		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(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)	info )

ZGGHRD: reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is A*x = lambda*B*x, and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. This subroutine simultaneously reduces A to a Hessenberg matrix H: Q**H*A*Z = H and transforms B to another upper triangular matrix T: Q**H*B*Z = T in order to reduce the problem to its standard form H*y = lambda*T*y where y = Z**H*x. The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then ZGGHRD reduces the original problem to generalized Hessenberg form.

Here is the call graph for this function:

◆ la_zhgeqz()

subroutine, public la_lapack_eigv_comp::la_zhgeqz	(	character, intent(in)	job,
		character, intent(in)	compq,
		character, intent(in)	compz,
		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(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(dp), dimension(*), intent(out)	alpha,
		complex(dp), dimension(*), intent(out)	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(out)	work,
		integer(ilp), intent(in)	lwork,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

ZHGEQZ: computes the eigenvalues of a complex matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single-shift QZ method. Matrix pairs of this type are produced by the reduction to generalized upper Hessenberg form of a complex 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 and S and P are upper triangular. 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 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 complex values (alpha,beta). 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. The values of alpha and beta for the i-th eigenvalue 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.

Here is the call graph for this function:

Functions/Subroutines

Detailed Description

Function/Subroutine Documentation

◆ la_cggbak()

◆ la_cggbal()

◆ la_cgghd3()

◆ la_cgghrd()

◆ la_chgeqz()

◆ la_dggbak()

◆ la_dggbal()

◆ la_dgghd3()

◆ la_dgghrd()

◆ la_dhgeqz()

◆ la_qggbak()

◆ la_qggbal()

◆ la_qgghd3()

◆ la_qgghrd()

◆ la_qhgeqz()

◆ la_sggbak()

◆ la_sggbal()

◆ la_sgghd3()

◆ la_sgghrd()

◆ la_shgeqz()

◆ la_wggbak()

◆ la_wggbal()

◆ la_wgghd3()

◆ la_wgghrd()

◆ la_whgeqz()

◆ la_zggbak()

◆ la_zggbal()

◆ la_zgghd3()

◆ la_zgghrd()

◆ la_zhgeqz()