la_lapack_eigv_gen2 Module Reference

Nonsymmetric eigenproblem components: Schur factorization, eigenvectors, reordering and condition numbers. More...

Functions/Subroutines
pure subroutine, public	la_slaein (rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, bignum, info)
	SLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.
pure subroutine, public	la_dlaein (rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, bignum, info)
	DLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.
pure subroutine, public	la_qlaein (rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, bignum, info)
	QLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.
pure subroutine, public	la_strevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info)
	STREVC: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by SHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.
pure subroutine, public	la_dtrevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info)
	DTREVC: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by DHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.
pure subroutine, public	la_qtrevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info)
	QTREVC: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by QHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.
pure subroutine, public	la_strevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, info)
	STREVC3: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by SHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**T)*T = w*(y**T) where y**T denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
pure subroutine, public	la_dtrevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, info)
	DTREVC3: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by DHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**T)*T = w*(y**T) where y**T denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
pure subroutine, public	la_qtrevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, info)
	QTREVC3: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by QHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**T)*T = w*(y**T) where y**T denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
subroutine, public	la_strsyl (trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)
	STRSYL: solves the real Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
subroutine, public	la_dtrsyl (trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)
	DTRSYL: solves the real Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
subroutine, public	la_qtrsyl (trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)
	QTRSYL: solves the real Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by QHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
subroutine, public	la_shsein (side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info)
	SHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.
subroutine, public	la_dhsein (side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info)
	DHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.
subroutine, public	la_qhsein (side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info)
	QHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.
subroutine, public	la_strsen (job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info)
	STRSEN: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
subroutine, public	la_dtrsen (job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info)
	DTRSEN: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
subroutine, public	la_qtrsen (job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info)
	QTRSEN: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by QHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
subroutine, public	la_strsna (job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info)
	STRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q orthogonal). T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
subroutine, public	la_dtrsna (job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info)
	DTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q orthogonal). T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
subroutine, public	la_qtrsna (job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info)
	QTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q orthogonal). T must be in Schur canonical form (as returned by QHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.
subroutine, public	la_shseqr (job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info)
	SHSEQR: 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_dhseqr (job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info)
	DHSEQR: 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_qhseqr (job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info)
	QHSEQR: 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.
pure subroutine, public	la_ctrevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)
	CTREVC: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.
pure subroutine, public	la_ztrevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)
	ZTREVC: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by ZHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.
pure subroutine, public	la_wtrevc (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info)
	WTREVC: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by WHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.
pure subroutine, public	la_ctrevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info)
	CTREVC3: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
pure subroutine, public	la_ztrevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info)
	ZTREVC3: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by ZHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
pure subroutine, public	la_wtrevc3 (side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, rwork, lrwork, info)
	WTREVC3: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by WHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.
pure subroutine, public	la_ctrsna (job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info)
	CTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix Q*T*Q**H with Q unitary).
pure subroutine, public	la_ztrsna (job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info)
	ZTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix Q*T*Q**H with Q unitary).
pure subroutine, public	la_wtrsna (job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info)
	WTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix Q*T*Q**H with Q unitary).
pure subroutine, public	la_claein (rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info)
	CLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.
pure subroutine, public	la_zlaein (rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info)
	ZLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.
pure subroutine, public	la_wlaein (rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info)
	WLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.
subroutine, public	la_ctrsyl (trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)
	CTRSYL: solves the complex Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.
subroutine, public	la_ztrsyl (trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)
	ZTRSYL: solves the complex Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.
subroutine, public	la_wtrsyl (trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info)
	WTRSYL: solves the complex Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.
subroutine, public	la_chsein (side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)
	CHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.
subroutine, public	la_zhsein (side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)
	ZHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.
subroutine, public	la_whsein (side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info)
	WHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.
subroutine, public	la_ctrsen (job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info)
	CTRSEN: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.
subroutine, public	la_ztrsen (job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info)
	ZTRSEN: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.
subroutine, public	la_wtrsen (job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info)
	WTRSEN: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.
pure subroutine, public	la_chseqr (job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info)
	CHSEQR: 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)*T*(QZ)**H.
pure subroutine, public	la_zhseqr (job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info)
	ZHSEQR: 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)*T*(QZ)**H.
pure subroutine, public	la_whseqr (job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info)
	WHSEQR: 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)*T*(QZ)**H.

Detailed Description

Nonsymmetric eigenproblem components: Schur factorization, eigenvectors, reordering and condition numbers.

Function/Subroutine Documentation

la_chsein()

subroutine, public la_lapack_eigv_gen2::la_chsein	(	character, intent(in)	side,
		character, intent(in)	eigsrc,
		character, intent(in)	initv,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), dimension(*), intent(inout)	w,
		complex(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	ifaill,
		integer(ilp), dimension(*), intent(out)	ifailr,
		integer(ilp), intent(out)	info )

CHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.

Here is the call graph for this function:

la_chseqr()

pure subroutine, public la_lapack_eigv_gen2::la_chseqr	(	character, intent(in)	job,
		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(*), intent(out)	w,
		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 )

CHSEQR: 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)*T*(QZ)**H.

Here is the call graph for this function:

la_claein()

pure subroutine, public la_lapack_eigv_gen2::la_claein	(	logical(lk), intent(in)	rightv,
		logical(lk), intent(in)	noinit,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		complex(sp), intent(in)	w,
		complex(sp), dimension(*), intent(inout)	v,
		complex(sp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(*), intent(out)	rwork,
		real(sp), intent(in)	eps3,
		real(sp), intent(in)	smlnum,
		integer(ilp), intent(out)	info )

CLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.

Here is the call graph for this function:

la_ctrevc()

pure subroutine, public la_lapack_eigv_gen2::la_ctrevc	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(*), intent(out)	work,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

CTREVC: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.

Here is the call graph for this function:

la_ctrevc3()

pure subroutine, public la_lapack_eigv_gen2::la_ctrevc3	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info )

CTREVC3: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by CHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

Here is the call graph for this function:

la_ctrsen()

subroutine, public la_lapack_eigv_gen2::la_ctrsen	(	character, intent(in)	job,
		character, intent(in)	compq,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(sp), dimension(*), intent(out)	w,
		integer(ilp), intent(out)	m,
		real(sp), intent(out)	s,
		real(sp), intent(out)	sep,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

CTRSEN: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.

Here is the call graph for this function:

la_ctrsna()

pure subroutine, public la_lapack_eigv_gen2::la_ctrsna	(	character, intent(in)	job,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(sp), dimension(ldvl,*), intent(in)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(sp), dimension(ldvr,*), intent(in)	vr,
		integer(ilp), intent(in)	ldvr,
		real(sp), dimension(*), intent(out)	s,
		real(sp), dimension(*), intent(out)	sep,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(sp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

CTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix Q*T*Q**H with Q unitary).

Here is the call graph for this function:

la_ctrsyl()

subroutine, public la_lapack_eigv_gen2::la_ctrsyl	(	character, intent(in)	trana,
		character, intent(in)	tranb,
		integer(ilp), intent(in)	isgn,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		real(sp), intent(out)	scale,
		integer(ilp), intent(out)	info )

CTRSYL: solves the complex Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.

Here is the call graph for this function:

la_dhsein()

subroutine, public la_lapack_eigv_gen2::la_dhsein	(	character, intent(in)	side,
		character, intent(in)	eigsrc,
		character, intent(in)	initv,
		logical(lk), dimension(*), intent(inout)	select,
		integer(ilp), intent(in)	n,
		real(dp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		real(dp), dimension(*), intent(inout)	wr,
		real(dp), dimension(*), intent(in)	wi,
		real(dp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		real(dp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	ifaill,
		integer(ilp), dimension(*), intent(out)	ifailr,
		integer(ilp), intent(out)	info )

DHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.

Here is the call graph for this function:

la_dhseqr()

subroutine, public la_lapack_eigv_gen2::la_dhseqr	(	character, intent(in)	job,
		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(*), intent(out)	wr,
		real(dp), dimension(*), intent(out)	wi,
		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 )

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

Here is the call graph for this function:

la_dlaein()

pure subroutine, public la_lapack_eigv_gen2::la_dlaein	(	logical(lk), intent(in)	rightv,
		logical(lk), intent(in)	noinit,
		integer(ilp), intent(in)	n,
		real(dp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		real(dp), intent(in)	wr,
		real(dp), intent(in)	wi,
		real(dp), dimension(*), intent(inout)	vr,
		real(dp), dimension(*), intent(inout)	vi,
		real(dp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(*), intent(out)	work,
		real(dp), intent(in)	eps3,
		real(dp), intent(in)	smlnum,
		real(dp), intent(in)	bignum,
		integer(ilp), intent(out)	info )

DLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.

Here is the call graph for this function:

la_dtrevc()

pure subroutine, public la_lapack_eigv_gen2::la_dtrevc	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(inout)	select,
		integer(ilp), intent(in)	n,
		real(dp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		real(dp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		real(dp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

DTREVC: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by DHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.

Here is the call graph for this function:

la_dtrevc3()

pure subroutine, public la_lapack_eigv_gen2::la_dtrevc3	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(inout)	select,
		integer(ilp), intent(in)	n,
		real(dp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		real(dp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		real(dp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

DTREVC3: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by DHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**T)*T = w*(y**T) where y**T denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

Here is the call graph for this function:

la_dtrsen()

subroutine, public la_lapack_eigv_gen2::la_dtrsen	(	character, intent(in)	job,
		character, intent(in)	compq,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		real(dp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		real(dp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		real(dp), dimension(*), intent(out)	wr,
		real(dp), dimension(*), intent(out)	wi,
		integer(ilp), intent(out)	m,
		real(dp), intent(out)	s,
		real(dp), intent(out)	sep,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info )

DTRSEN: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

Here is the call graph for this function:

la_dtrsna()

subroutine, public la_lapack_eigv_gen2::la_dtrsna	(	character, intent(in)	job,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		real(dp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		real(dp), dimension(ldvl,*), intent(in)	vl,
		integer(ilp), intent(in)	ldvl,
		real(dp), dimension(ldvr,*), intent(in)	vr,
		integer(ilp), intent(in)	ldvr,
		real(dp), dimension(*), intent(out)	s,
		real(dp), dimension(*), intent(out)	sep,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(dp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

DTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q orthogonal). T must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

Here is the call graph for this function:

la_dtrsyl()

subroutine, public la_lapack_eigv_gen2::la_dtrsyl	(	character, intent(in)	trana,
		character, intent(in)	tranb,
		integer(ilp), intent(in)	isgn,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		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), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		real(dp), intent(out)	scale,
		integer(ilp), intent(out)	info )

DTRSYL: solves the real Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by DHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

Here is the call graph for this function:

la_qhsein()

subroutine, public la_lapack_eigv_gen2::la_qhsein	(	character, intent(in)	side,
		character, intent(in)	eigsrc,
		character, intent(in)	initv,
		logical(lk), dimension(*), intent(inout)	select,
		integer(ilp), intent(in)	n,
		real(qp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		real(qp), dimension(*), intent(inout)	wr,
		real(qp), dimension(*), intent(in)	wi,
		real(qp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		real(qp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	ifaill,
		integer(ilp), dimension(*), intent(out)	ifailr,
		integer(ilp), intent(out)	info )

QHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.

Here is the call graph for this function:

la_qhseqr()

subroutine, public la_lapack_eigv_gen2::la_qhseqr	(	character, intent(in)	job,
		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(*), intent(out)	wr,
		real(qp), dimension(*), intent(out)	wi,
		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 )

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

Here is the call graph for this function:

la_qlaein()

pure subroutine, public la_lapack_eigv_gen2::la_qlaein	(	logical(lk), intent(in)	rightv,
		logical(lk), intent(in)	noinit,
		integer(ilp), intent(in)	n,
		real(qp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		real(qp), intent(in)	wr,
		real(qp), intent(in)	wi,
		real(qp), dimension(*), intent(inout)	vr,
		real(qp), dimension(*), intent(inout)	vi,
		real(qp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(*), intent(out)	work,
		real(qp), intent(in)	eps3,
		real(qp), intent(in)	smlnum,
		real(qp), intent(in)	bignum,
		integer(ilp), intent(out)	info )

QLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.

Here is the call graph for this function:

la_qtrevc()

pure subroutine, public la_lapack_eigv_gen2::la_qtrevc	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(inout)	select,
		integer(ilp), intent(in)	n,
		real(qp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		real(qp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		real(qp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

QTREVC: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by QHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.

Here is the call graph for this function:

la_qtrevc3()

pure subroutine, public la_lapack_eigv_gen2::la_qtrevc3	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(inout)	select,
		integer(ilp), intent(in)	n,
		real(qp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		real(qp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		real(qp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

QTREVC3: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by QHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**T)*T = w*(y**T) where y**T denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

Here is the call graph for this function:

la_qtrsen()

subroutine, public la_lapack_eigv_gen2::la_qtrsen	(	character, intent(in)	job,
		character, intent(in)	compq,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		real(qp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		real(qp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		real(qp), dimension(*), intent(out)	wr,
		real(qp), dimension(*), intent(out)	wi,
		integer(ilp), intent(out)	m,
		real(qp), intent(out)	s,
		real(qp), intent(out)	sep,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info )

QTRSEN: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by QHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

Here is the call graph for this function:

la_qtrsna()

subroutine, public la_lapack_eigv_gen2::la_qtrsna	(	character, intent(in)	job,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		real(qp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		real(qp), dimension(ldvl,*), intent(in)	vl,
		integer(ilp), intent(in)	ldvl,
		real(qp), dimension(ldvr,*), intent(in)	vr,
		integer(ilp), intent(in)	ldvr,
		real(qp), dimension(*), intent(out)	s,
		real(qp), dimension(*), intent(out)	sep,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(qp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

QTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q orthogonal). T must be in Schur canonical form (as returned by QHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

Here is the call graph for this function:

la_qtrsyl()

subroutine, public la_lapack_eigv_gen2::la_qtrsyl	(	character, intent(in)	trana,
		character, intent(in)	tranb,
		integer(ilp), intent(in)	isgn,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		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), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		real(qp), intent(out)	scale,
		integer(ilp), intent(out)	info )

QTRSYL: solves the real Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by QHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

Here is the call graph for this function:

la_shsein()

subroutine, public la_lapack_eigv_gen2::la_shsein	(	character, intent(in)	side,
		character, intent(in)	eigsrc,
		character, intent(in)	initv,
		logical(lk), dimension(*), intent(inout)	select,
		integer(ilp), intent(in)	n,
		real(sp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		real(sp), dimension(*), intent(inout)	wr,
		real(sp), dimension(*), intent(in)	wi,
		real(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		real(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), dimension(*), intent(out)	ifaill,
		integer(ilp), dimension(*), intent(out)	ifailr,
		integer(ilp), intent(out)	info )

SHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a real upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.

Here is the call graph for this function:

la_shseqr()

subroutine, public la_lapack_eigv_gen2::la_shseqr	(	character, intent(in)	job,
		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(*), intent(out)	wr,
		real(sp), dimension(*), intent(out)	wi,
		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 )

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

Here is the call graph for this function:

la_slaein()

pure subroutine, public la_lapack_eigv_gen2::la_slaein	(	logical(lk), intent(in)	rightv,
		logical(lk), intent(in)	noinit,
		integer(ilp), intent(in)	n,
		real(sp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		real(sp), intent(in)	wr,
		real(sp), intent(in)	wi,
		real(sp), dimension(*), intent(inout)	vr,
		real(sp), dimension(*), intent(inout)	vi,
		real(sp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb,
		real(sp), dimension(*), intent(out)	work,
		real(sp), intent(in)	eps3,
		real(sp), intent(in)	smlnum,
		real(sp), intent(in)	bignum,
		integer(ilp), intent(out)	info )

SLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg matrix H.

Here is the call graph for this function:

la_strevc()

pure subroutine, public la_lapack_eigv_gen2::la_strevc	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(inout)	select,
		integer(ilp), intent(in)	n,
		real(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		real(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		real(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(out)	info )

STREVC: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by SHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.

Here is the call graph for this function:

la_strevc3()

pure subroutine, public la_lapack_eigv_gen2::la_strevc3	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(inout)	select,
		integer(ilp), intent(in)	n,
		real(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		real(sp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		real(sp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

STREVC3: computes some or all of the right and/or left eigenvectors of a real upper quasi-triangular matrix T. Matrices of this type are produced by the Schur factorization of a real general matrix: A = Q*T*Q**T, as computed by SHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**T)*T = w*(y**T) where y**T denotes the transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal blocks of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the orthogonal factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

Here is the call graph for this function:

la_strsen()

subroutine, public la_lapack_eigv_gen2::la_strsen	(	character, intent(in)	job,
		character, intent(in)	compq,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		real(sp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		real(sp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		real(sp), dimension(*), intent(out)	wr,
		real(sp), dimension(*), intent(out)	wi,
		integer(ilp), intent(out)	m,
		real(sp), intent(out)	s,
		real(sp), intent(out)	sep,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		integer(ilp), intent(out)	info )

STRSEN: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace. T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

Here is the call graph for this function:

la_strsna()

subroutine, public la_lapack_eigv_gen2::la_strsna	(	character, intent(in)	job,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		real(sp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		real(sp), dimension(ldvl,*), intent(in)	vl,
		integer(ilp), intent(in)	ldvl,
		real(sp), dimension(ldvr,*), intent(in)	vr,
		integer(ilp), intent(in)	ldvr,
		real(sp), dimension(*), intent(out)	s,
		real(sp), dimension(*), intent(out)	sep,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		real(sp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(out)	info )

STRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a real upper quasi-triangular matrix T (or of any matrix Q*T*Q**T with Q orthogonal). T must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

Here is the call graph for this function:

la_strsyl()

subroutine, public la_lapack_eigv_gen2::la_strsyl	(	character, intent(in)	trana,
		character, intent(in)	tranb,
		integer(ilp), intent(in)	isgn,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		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), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		real(sp), intent(out)	scale,
		integer(ilp), intent(out)	info )

STRSYL: solves the real Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**T, and A and B are both upper quasi- triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X. A and B must be in Schur canonical form (as returned by SHSEQR), that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

Here is the call graph for this function:

la_whsein()

subroutine, public la_lapack_eigv_gen2::la_whsein	(	character, intent(in)	side,
		character, intent(in)	eigsrc,
		character, intent(in)	initv,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		complex(qp), dimension(*), intent(inout)	w,
		complex(qp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(qp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(qp), dimension(*), intent(out)	work,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	ifaill,
		integer(ilp), dimension(*), intent(out)	ifailr,
		integer(ilp), intent(out)	info )

WHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.

Here is the call graph for this function:

la_whseqr()

pure subroutine, public la_lapack_eigv_gen2::la_whseqr	(	character, intent(in)	job,
		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(*), intent(out)	w,
		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 )

WHSEQR: 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)*T*(QZ)**H.

Here is the call graph for this function:

la_wlaein()

pure subroutine, public la_lapack_eigv_gen2::la_wlaein	(	logical(lk), intent(in)	rightv,
		logical(lk), intent(in)	noinit,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		complex(qp), intent(in)	w,
		complex(qp), dimension(*), intent(inout)	v,
		complex(qp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb,
		real(qp), dimension(*), intent(out)	rwork,
		real(qp), intent(in)	eps3,
		real(qp), intent(in)	smlnum,
		integer(ilp), intent(out)	info )

WLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.

Here is the call graph for this function:

la_wtrevc()

pure subroutine, public la_lapack_eigv_gen2::la_wtrevc	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(qp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(qp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(qp), dimension(*), intent(out)	work,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

WTREVC: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by WHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.

Here is the call graph for this function:

la_wtrevc3()

pure subroutine, public la_lapack_eigv_gen2::la_wtrevc3	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(qp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(qp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info )

WTREVC3: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by WHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

Here is the call graph for this function:

la_wtrsen()

subroutine, public la_lapack_eigv_gen2::la_wtrsen	(	character, intent(in)	job,
		character, intent(in)	compq,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(qp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(qp), dimension(*), intent(out)	w,
		integer(ilp), intent(out)	m,
		real(qp), intent(out)	s,
		real(qp), intent(out)	sep,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

WTRSEN: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.

Here is the call graph for this function:

la_wtrsna()

pure subroutine, public la_lapack_eigv_gen2::la_wtrsna	(	character, intent(in)	job,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(qp), dimension(ldvl,*), intent(in)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(qp), dimension(ldvr,*), intent(in)	vr,
		integer(ilp), intent(in)	ldvr,
		real(qp), dimension(*), intent(out)	s,
		real(qp), dimension(*), intent(out)	sep,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(qp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

WTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix Q*T*Q**H with Q unitary).

Here is the call graph for this function:

la_wtrsyl()

subroutine, public la_lapack_eigv_gen2::la_wtrsyl	(	character, intent(in)	trana,
		character, intent(in)	tranb,
		integer(ilp), intent(in)	isgn,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(qp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		real(qp), intent(out)	scale,
		integer(ilp), intent(out)	info )

WTRSYL: solves the complex Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.

Here is the call graph for this function:

la_zhsein()

subroutine, public la_lapack_eigv_gen2::la_zhsein	(	character, intent(in)	side,
		character, intent(in)	eigsrc,
		character, intent(in)	initv,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		complex(dp), dimension(*), intent(inout)	w,
		complex(dp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(dp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(dp), dimension(*), intent(out)	work,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), dimension(*), intent(out)	ifaill,
		integer(ilp), dimension(*), intent(out)	ifailr,
		integer(ilp), intent(out)	info )

ZHSEIN: uses inverse iteration to find specified right and/or left eigenvectors of a complex upper Hessenberg matrix H. The right eigenvector x and the left eigenvector y of the matrix H corresponding to an eigenvalue w are defined by: H * x = w * x, y**h * H = w * y**h where y**h denotes the conjugate transpose of the vector y.

Here is the call graph for this function:

la_zhseqr()

pure subroutine, public la_lapack_eigv_gen2::la_zhseqr	(	character, intent(in)	job,
		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(*), intent(out)	w,
		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 )

ZHSEQR: 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)*T*(QZ)**H.

Here is the call graph for this function:

la_zlaein()

pure subroutine, public la_lapack_eigv_gen2::la_zlaein	(	logical(lk), intent(in)	rightv,
		logical(lk), intent(in)	noinit,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(ldh,*), intent(in)	h,
		integer(ilp), intent(in)	ldh,
		complex(dp), intent(in)	w,
		complex(dp), dimension(*), intent(inout)	v,
		complex(dp), dimension(ldb,*), intent(out)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), dimension(*), intent(out)	rwork,
		real(dp), intent(in)	eps3,
		real(dp), intent(in)	smlnum,
		integer(ilp), intent(out)	info )

ZLAEIN: uses inverse iteration to find a right or left eigenvector corresponding to the eigenvalue W of a complex upper Hessenberg matrix H.

Here is the call graph for this function:

la_ztrevc()

pure subroutine, public la_lapack_eigv_gen2::la_ztrevc	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(dp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(dp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(dp), dimension(*), intent(out)	work,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

ZTREVC: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by ZHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A.

Here is the call graph for this function:

la_ztrevc3()

pure subroutine, public la_lapack_eigv_gen2::la_ztrevc3	(	character, intent(in)	side,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(dp), dimension(ldvl,*), intent(inout)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(dp), dimension(ldvr,*), intent(inout)	vr,
		integer(ilp), intent(in)	ldvr,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info )

ZTREVC3: computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix T. Matrices of this type are produced by the Schur factorization of a complex general matrix: A = Q*T*Q**H, as computed by ZHSEQR. The right eigenvector x and the left eigenvector y of T corresponding to an eigenvalue w are defined by: T*x = w*x, (y**H)*T = w*(y**H) where y**H denotes the conjugate transpose of the vector y. The eigenvalues are not input to this routine, but are read directly from the diagonal of T. This routine returns the matrices X and/or Y of right and left eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an input matrix. If Q is the unitary factor that reduces a matrix A to Schur form T, then Q*X and Q*Y are the matrices of right and left eigenvectors of A. This uses a Level 3 BLAS version of the back transformation.

Here is the call graph for this function:

la_ztrsen()

subroutine, public la_lapack_eigv_gen2::la_ztrsen	(	character, intent(in)	job,
		character, intent(in)	compq,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(ldt,*), intent(inout)	t,
		integer(ilp), intent(in)	ldt,
		complex(dp), dimension(ldq,*), intent(inout)	q,
		integer(ilp), intent(in)	ldq,
		complex(dp), dimension(*), intent(out)	w,
		integer(ilp), intent(out)	m,
		real(dp), intent(out)	s,
		real(dp), intent(out)	sep,
		complex(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

ZTRSEN: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in the leading positions on the diagonal of the upper triangular matrix T, and the leading columns of Q form an orthonormal basis of the corresponding right invariant subspace. Optionally the routine computes the reciprocal condition numbers of the cluster of eigenvalues and/or the invariant subspace.

Here is the call graph for this function:

la_ztrsna()

pure subroutine, public la_lapack_eigv_gen2::la_ztrsna	(	character, intent(in)	job,
		character, intent(in)	howmny,
		logical(lk), dimension(*), intent(in)	select,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(ldt,*), intent(in)	t,
		integer(ilp), intent(in)	ldt,
		complex(dp), dimension(ldvl,*), intent(in)	vl,
		integer(ilp), intent(in)	ldvl,
		complex(dp), dimension(ldvr,*), intent(in)	vr,
		integer(ilp), intent(in)	ldvr,
		real(dp), dimension(*), intent(out)	s,
		real(dp), dimension(*), intent(out)	sep,
		integer(ilp), intent(in)	mm,
		integer(ilp), intent(out)	m,
		complex(dp), dimension(ldwork,*), intent(out)	work,
		integer(ilp), intent(in)	ldwork,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

ZTRSNA: estimates reciprocal condition numbers for specified eigenvalues and/or right eigenvectors of a complex upper triangular matrix T (or of any matrix Q*T*Q**H with Q unitary).

Here is the call graph for this function:

la_ztrsyl()

subroutine, public la_lapack_eigv_gen2::la_ztrsyl	(	character, intent(in)	trana,
		character, intent(in)	tranb,
		integer(ilp), intent(in)	isgn,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		complex(dp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		real(dp), intent(out)	scale,
		integer(ilp), intent(out)	info )

ZTRSYL: solves the complex Sylvester matrix equation: op(A)*X + X*op(B) = scale*C or op(A)*X - X*op(B) = scale*C, where op(A) = A or A**H, and A and B are both upper triangular. A is M-by-M and B is N-by-N; the right hand side C and the solution X are M-by-N; and scale is an output scale factor, set <= 1 to avoid overflow in X.

Here is the call graph for this function: