Nonsymmetric eigenproblem helpers: 2-by-2 standardization, Sylvester solves, diagonal block swaps. More...
Functions/Subroutines | |
| pure subroutine, public | la_slasy2 (ltranl, ltranr, isgn, n1, n2, tl, ldtl, tr, ldtr, b, ldb, scale, x, ldx, xnorm, info) |
| SLASY2: solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in op(TL)*X + ISGN*X*op(TR) = SCALE*B, where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or -1. op(T) = T or T**T, where T**T denotes the transpose of T. | |
| pure subroutine, public | la_dlasy2 (ltranl, ltranr, isgn, n1, n2, tl, ldtl, tr, ldtr, b, ldb, scale, x, ldx, xnorm, info) |
| DLASY2: solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in op(TL)*X + ISGN*X*op(TR) = SCALE*B, where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or -1. op(T) = T or T**T, where T**T denotes the transpose of T. | |
| pure subroutine, public | la_qlasy2 (ltranl, ltranr, isgn, n1, n2, tl, ldtl, tr, ldtr, b, ldb, scale, x, ldx, xnorm, info) |
| QLASY2: solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in op(TL)*X + ISGN*X*op(TR) = SCALE*B, where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or -1. op(T) = T or T**T, where T**T denotes the transpose of T. | |
| pure subroutine, public | la_slaln2 (ltrans, na, nw, smin, ca, a, lda, d1, d2, b, ldb, wr, wi, x, ldx, scale, xnorm, info) |
| SLALN2: solves a system of the form (ca A - w D ) X = s B or (ca A**T - w D) X = s B with possible scaling ("s") and perturbation of A. (A**T means A-transpose.) A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA real diagonal matrix, w is a real or complex value, and X and B are NA x 1 matrices – real if w is real, complex if w is complex. NA may be 1 or 2. If w is complex, X and B are represented as NA x 2 matrices, the first column of each being the real part and the second being the imaginary part. "s" is a scaling factor (<= 1), computed by SLALN2, which is so chosen that X can be computed without overflow. X is further scaled if necessary to assure that norm(ca A - w D)*norm(X) is less than overflow. If both singular values of (ca A - w D) are less than SMIN, SMIN*identity will be used instead of (ca A - w D). If only one singular value is less than SMIN, one element of (ca A - w D) will be perturbed enough to make the smallest singular value roughly SMIN. If both singular values are at least SMIN, (ca A - w D) will not be perturbed. In any case, the perturbation will be at most some small multiple of max( SMIN, ulp*norm(ca A - w D) ). The singular values are computed by infinity-norm approximations, and thus will only be correct to a factor of 2 or so. Note: all input quantities are assumed to be smaller than overflow by a reasonable factor. (See BIGNUM.) | |
| pure subroutine, public | la_dlaln2 (ltrans, na, nw, smin, ca, a, lda, d1, d2, b, ldb, wr, wi, x, ldx, scale, xnorm, info) |
| DLALN2: solves a system of the form (ca A - w D ) X = s B or (ca A**T - w D) X = s B with possible scaling ("s") and perturbation of A. (A**T means A-transpose.) A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA real diagonal matrix, w is a real or complex value, and X and B are NA x 1 matrices – real if w is real, complex if w is complex. NA may be 1 or 2. If w is complex, X and B are represented as NA x 2 matrices, the first column of each being the real part and the second being the imaginary part. "s" is a scaling factor (<= 1), computed by DLALN2, which is so chosen that X can be computed without overflow. X is further scaled if necessary to assure that norm(ca A - w D)*norm(X) is less than overflow. If both singular values of (ca A - w D) are less than SMIN, SMIN*identity will be used instead of (ca A - w D). If only one singular value is less than SMIN, one element of (ca A - w D) will be perturbed enough to make the smallest singular value roughly SMIN. If both singular values are at least SMIN, (ca A - w D) will not be perturbed. In any case, the perturbation will be at most some small multiple of max( SMIN, ulp*norm(ca A - w D) ). The singular values are computed by infinity-norm approximations, and thus will only be correct to a factor of 2 or so. Note: all input quantities are assumed to be smaller than overflow by a reasonable factor. (See BIGNUM.) | |
| pure subroutine, public | la_qlaln2 (ltrans, na, nw, smin, ca, a, lda, d1, d2, b, ldb, wr, wi, x, ldx, scale, xnorm, info) |
| QLALN2: solves a system of the form (ca A - w D ) X = s B or (ca A**T - w D) X = s B with possible scaling ("s") and perturbation of A. (A**T means A-transpose.) A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA real diagonal matrix, w is a real or complex value, and X and B are NA x 1 matrices – real if w is real, complex if w is complex. NA may be 1 or 2. If w is complex, X and B are represented as NA x 2 matrices, the first column of each being the real part and the second being the imaginary part. "s" is a scaling factor (<= 1), computed by QLALN2, which is so chosen that X can be computed without overflow. X is further scaled if necessary to assure that norm(ca A - w D)*norm(X) is less than overflow. If both singular values of (ca A - w D) are less than SMIN, SMIN*identity will be used instead of (ca A - w D). If only one singular value is less than SMIN, one element of (ca A - w D) will be perturbed enough to make the smallest singular value roughly SMIN. If both singular values are at least SMIN, (ca A - w D) will not be perturbed. In any case, the perturbation will be at most some small multiple of max( SMIN, ulp*norm(ca A - w D) ). The singular values are computed by infinity-norm approximations, and thus will only be correct to a factor of 2 or so. Note: all input quantities are assumed to be smaller than overflow by a reasonable factor. (See BIGNUM.) | |
| pure subroutine, public | la_slanv2 (a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn) |
| SLANV2: computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form: [ A B ] = [ CS -SN ] [ AA BB ] [ CS SN ] [ C D ] [ SN CS ] [ CC DD ] [-SN CS ] where either 1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or 2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex conjugate eigenvalues. | |
| pure subroutine, public | la_dlanv2 (a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn) |
| DLANV2: computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form: [ A B ] = [ CS -SN ] [ AA BB ] [ CS SN ] [ C D ] [ SN CS ] [ CC DD ] [-SN CS ] where either 1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or 2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex conjugate eigenvalues. | |
| pure subroutine, public | la_qlanv2 (a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn) |
| QLANV2: computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form: [ A B ] = [ CS -SN ] [ AA BB ] [ CS SN ] [ C D ] [ SN CS ] [ CC DD ] [-SN CS ] where either 1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or 2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex conjugate eigenvalues. | |
| subroutine, public | la_slaexc (wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info) |
| SLAEXC: swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, 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_dlaexc (wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info) |
| DLAEXC: swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, 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_qlaexc (wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info) |
| QLAEXC: swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, 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_strexc (compq, n, t, ldt, q, ldq, ifst, ilst, work, info) |
| STREXC: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. 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_dtrexc (compq, n, t, ldt, q, ldq, ifst, ilst, work, info) |
| DTREXC: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. 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_qtrexc (compq, n, t, ldt, q, ldq, ifst, ilst, work, info) |
| QTREXC: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. 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. | |
| pure subroutine, public | la_ctrexc (compq, n, t, ldt, q, ldq, ifst, ilst, info) |
| CTREXC: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z. | |
| pure subroutine, public | la_ztrexc (compq, n, t, ldt, q, ldq, ifst, ilst, info) |
| ZTREXC: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z. | |
| pure subroutine, public | la_wtrexc (compq, n, t, ldt, q, ldq, ifst, ilst, info) |
| WTREXC: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z. | |
Detailed Description
Nonsymmetric eigenproblem helpers: 2-by-2 standardization, Sylvester solves, diagonal block swaps.
Function/Subroutine Documentation
◆ la_ctrexc()
| pure subroutine, public la_lapack_eigv_gen_aux::la_ctrexc | ( | character, intent(in) | compq, |
| 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, | ||
| integer(ilp), intent(in) | ifst, | ||
| integer(ilp), intent(in) | ilst, | ||
| integer(ilp), intent(out) | info ) |
CTREXC: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.
◆ la_dlaexc()
| subroutine, public la_lapack_eigv_gen_aux::la_dlaexc | ( | logical(lk), intent(in) | wantq, |
| 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, | ||
| integer(ilp), intent(in) | j1, | ||
| integer(ilp), intent(in) | n1, | ||
| integer(ilp), intent(in) | n2, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
DLAEXC: swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, 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.
◆ la_dlaln2()
| pure subroutine, public la_lapack_eigv_gen_aux::la_dlaln2 | ( | logical(lk), intent(in) | ltrans, |
| integer(ilp), intent(in) | na, | ||
| integer(ilp), intent(in) | nw, | ||
| real(dp), intent(in) | smin, | ||
| real(dp), intent(in) | ca, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), intent(in) | d1, | ||
| real(dp), intent(in) | d2, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), intent(in) | wr, | ||
| real(dp), intent(in) | wi, | ||
| real(dp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), intent(out) | scale, | ||
| real(dp), intent(out) | xnorm, | ||
| integer(ilp), intent(out) | info ) |
DLALN2: solves a system of the form (ca A - w D ) X = s B or (ca A**T - w D) X = s B with possible scaling ("s") and perturbation of A. (A**T means A-transpose.) A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA real diagonal matrix, w is a real or complex value, and X and B are NA x 1 matrices – real if w is real, complex if w is complex. NA may be 1 or 2. If w is complex, X and B are represented as NA x 2 matrices, the first column of each being the real part and the second being the imaginary part. "s" is a scaling factor (<= 1), computed by DLALN2, which is so chosen that X can be computed without overflow. X is further scaled if necessary to assure that norm(ca A - w D)*norm(X) is less than overflow. If both singular values of (ca A - w D) are less than SMIN, SMIN*identity will be used instead of (ca A - w D). If only one singular value is less than SMIN, one element of (ca A - w D) will be perturbed enough to make the smallest singular value roughly SMIN. If both singular values are at least SMIN, (ca A - w D) will not be perturbed. In any case, the perturbation will be at most some small multiple of max( SMIN, ulp*norm(ca A - w D) ). The singular values are computed by infinity-norm approximations, and thus will only be correct to a factor of 2 or so. Note: all input quantities are assumed to be smaller than overflow by a reasonable factor. (See BIGNUM.)
◆ la_dlanv2()
| pure subroutine, public la_lapack_eigv_gen_aux::la_dlanv2 | ( | real(dp), intent(inout) | a, |
| real(dp), intent(inout) | b, | ||
| real(dp), intent(inout) | c, | ||
| real(dp), intent(inout) | d, | ||
| real(dp), intent(out) | rt1r, | ||
| real(dp), intent(out) | rt1i, | ||
| real(dp), intent(out) | rt2r, | ||
| real(dp), intent(out) | rt2i, | ||
| real(dp), intent(out) | cs, | ||
| real(dp), intent(out) | sn ) |
DLANV2: computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form: [ A B ] = [ CS -SN ] [ AA BB ] [ CS SN ] [ C D ] [ SN CS ] [ CC DD ] [-SN CS ] where either 1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or 2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex conjugate eigenvalues.
◆ la_dlasy2()
| pure subroutine, public la_lapack_eigv_gen_aux::la_dlasy2 | ( | logical(lk), intent(in) | ltranl, |
| logical(lk), intent(in) | ltranr, | ||
| integer(ilp), intent(in) | isgn, | ||
| integer(ilp), intent(in) | n1, | ||
| integer(ilp), intent(in) | n2, | ||
| real(dp), dimension(ldtl,*), intent(in) | tl, | ||
| integer(ilp), intent(in) | ldtl, | ||
| real(dp), dimension(ldtr,*), intent(in) | tr, | ||
| integer(ilp), intent(in) | ldtr, | ||
| real(dp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), intent(out) | scale, | ||
| real(dp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(dp), intent(out) | xnorm, | ||
| integer(ilp), intent(out) | info ) |
DLASY2: solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in op(TL)*X + ISGN*X*op(TR) = SCALE*B, where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or -1. op(T) = T or T**T, where T**T denotes the transpose of T.
◆ la_dtrexc()
| subroutine, public la_lapack_eigv_gen_aux::la_dtrexc | ( | character, intent(in) | compq, |
| 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, | ||
| integer(ilp), intent(inout) | ifst, | ||
| integer(ilp), intent(inout) | ilst, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
DTREXC: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. 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.
◆ la_qlaexc()
| subroutine, public la_lapack_eigv_gen_aux::la_qlaexc | ( | logical(lk), intent(in) | wantq, |
| 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, | ||
| integer(ilp), intent(in) | j1, | ||
| integer(ilp), intent(in) | n1, | ||
| integer(ilp), intent(in) | n2, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QLAEXC: swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, 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.
◆ la_qlaln2()
| pure subroutine, public la_lapack_eigv_gen_aux::la_qlaln2 | ( | logical(lk), intent(in) | ltrans, |
| integer(ilp), intent(in) | na, | ||
| integer(ilp), intent(in) | nw, | ||
| real(qp), intent(in) | smin, | ||
| real(qp), intent(in) | ca, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | d1, | ||
| real(qp), intent(in) | d2, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | wr, | ||
| real(qp), intent(in) | wi, | ||
| real(qp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), intent(out) | scale, | ||
| real(qp), intent(out) | xnorm, | ||
| integer(ilp), intent(out) | info ) |
QLALN2: solves a system of the form (ca A - w D ) X = s B or (ca A**T - w D) X = s B with possible scaling ("s") and perturbation of A. (A**T means A-transpose.) A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA real diagonal matrix, w is a real or complex value, and X and B are NA x 1 matrices – real if w is real, complex if w is complex. NA may be 1 or 2. If w is complex, X and B are represented as NA x 2 matrices, the first column of each being the real part and the second being the imaginary part. "s" is a scaling factor (<= 1), computed by QLALN2, which is so chosen that X can be computed without overflow. X is further scaled if necessary to assure that norm(ca A - w D)*norm(X) is less than overflow. If both singular values of (ca A - w D) are less than SMIN, SMIN*identity will be used instead of (ca A - w D). If only one singular value is less than SMIN, one element of (ca A - w D) will be perturbed enough to make the smallest singular value roughly SMIN. If both singular values are at least SMIN, (ca A - w D) will not be perturbed. In any case, the perturbation will be at most some small multiple of max( SMIN, ulp*norm(ca A - w D) ). The singular values are computed by infinity-norm approximations, and thus will only be correct to a factor of 2 or so. Note: all input quantities are assumed to be smaller than overflow by a reasonable factor. (See BIGNUM.)
◆ la_qlanv2()
| pure subroutine, public la_lapack_eigv_gen_aux::la_qlanv2 | ( | real(qp), intent(inout) | a, |
| real(qp), intent(inout) | b, | ||
| real(qp), intent(inout) | c, | ||
| real(qp), intent(inout) | d, | ||
| real(qp), intent(out) | rt1r, | ||
| real(qp), intent(out) | rt1i, | ||
| real(qp), intent(out) | rt2r, | ||
| real(qp), intent(out) | rt2i, | ||
| real(qp), intent(out) | cs, | ||
| real(qp), intent(out) | sn ) |
QLANV2: computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form: [ A B ] = [ CS -SN ] [ AA BB ] [ CS SN ] [ C D ] [ SN CS ] [ CC DD ] [-SN CS ] where either 1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or 2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex conjugate eigenvalues.
◆ la_qlasy2()
| pure subroutine, public la_lapack_eigv_gen_aux::la_qlasy2 | ( | logical(lk), intent(in) | ltranl, |
| logical(lk), intent(in) | ltranr, | ||
| integer(ilp), intent(in) | isgn, | ||
| integer(ilp), intent(in) | n1, | ||
| integer(ilp), intent(in) | n2, | ||
| real(qp), dimension(ldtl,*), intent(in) | tl, | ||
| integer(ilp), intent(in) | ldtl, | ||
| real(qp), dimension(ldtr,*), intent(in) | tr, | ||
| integer(ilp), intent(in) | ldtr, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(out) | scale, | ||
| real(qp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(qp), intent(out) | xnorm, | ||
| integer(ilp), intent(out) | info ) |
QLASY2: solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in op(TL)*X + ISGN*X*op(TR) = SCALE*B, where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or -1. op(T) = T or T**T, where T**T denotes the transpose of T.
◆ la_qtrexc()
| subroutine, public la_lapack_eigv_gen_aux::la_qtrexc | ( | character, intent(in) | compq, |
| 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, | ||
| integer(ilp), intent(inout) | ifst, | ||
| integer(ilp), intent(inout) | ilst, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QTREXC: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. 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.
◆ la_slaexc()
| subroutine, public la_lapack_eigv_gen_aux::la_slaexc | ( | logical(lk), intent(in) | wantq, |
| 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, | ||
| integer(ilp), intent(in) | j1, | ||
| integer(ilp), intent(in) | n1, | ||
| integer(ilp), intent(in) | n2, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
SLAEXC: swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation. T must be in Schur canonical form, 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.
◆ la_slaln2()
| pure subroutine, public la_lapack_eigv_gen_aux::la_slaln2 | ( | logical(lk), intent(in) | ltrans, |
| integer(ilp), intent(in) | na, | ||
| integer(ilp), intent(in) | nw, | ||
| real(sp), intent(in) | smin, | ||
| real(sp), intent(in) | ca, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), intent(in) | d1, | ||
| real(sp), intent(in) | d2, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | wr, | ||
| real(sp), intent(in) | wi, | ||
| real(sp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), intent(out) | scale, | ||
| real(sp), intent(out) | xnorm, | ||
| integer(ilp), intent(out) | info ) |
SLALN2: solves a system of the form (ca A - w D ) X = s B or (ca A**T - w D) X = s B with possible scaling ("s") and perturbation of A. (A**T means A-transpose.) A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA real diagonal matrix, w is a real or complex value, and X and B are NA x 1 matrices – real if w is real, complex if w is complex. NA may be 1 or 2. If w is complex, X and B are represented as NA x 2 matrices, the first column of each being the real part and the second being the imaginary part. "s" is a scaling factor (<= 1), computed by SLALN2, which is so chosen that X can be computed without overflow. X is further scaled if necessary to assure that norm(ca A - w D)*norm(X) is less than overflow. If both singular values of (ca A - w D) are less than SMIN, SMIN*identity will be used instead of (ca A - w D). If only one singular value is less than SMIN, one element of (ca A - w D) will be perturbed enough to make the smallest singular value roughly SMIN. If both singular values are at least SMIN, (ca A - w D) will not be perturbed. In any case, the perturbation will be at most some small multiple of max( SMIN, ulp*norm(ca A - w D) ). The singular values are computed by infinity-norm approximations, and thus will only be correct to a factor of 2 or so. Note: all input quantities are assumed to be smaller than overflow by a reasonable factor. (See BIGNUM.)
◆ la_slanv2()
| pure subroutine, public la_lapack_eigv_gen_aux::la_slanv2 | ( | real(sp), intent(inout) | a, |
| real(sp), intent(inout) | b, | ||
| real(sp), intent(inout) | c, | ||
| real(sp), intent(inout) | d, | ||
| real(sp), intent(out) | rt1r, | ||
| real(sp), intent(out) | rt1i, | ||
| real(sp), intent(out) | rt2r, | ||
| real(sp), intent(out) | rt2i, | ||
| real(sp), intent(out) | cs, | ||
| real(sp), intent(out) | sn ) |
SLANV2: computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form: [ A B ] = [ CS -SN ] [ AA BB ] [ CS SN ] [ C D ] [ SN CS ] [ CC DD ] [-SN CS ] where either 1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or 2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex conjugate eigenvalues.
◆ la_slasy2()
| pure subroutine, public la_lapack_eigv_gen_aux::la_slasy2 | ( | logical(lk), intent(in) | ltranl, |
| logical(lk), intent(in) | ltranr, | ||
| integer(ilp), intent(in) | isgn, | ||
| integer(ilp), intent(in) | n1, | ||
| integer(ilp), intent(in) | n2, | ||
| real(sp), dimension(ldtl,*), intent(in) | tl, | ||
| integer(ilp), intent(in) | ldtl, | ||
| real(sp), dimension(ldtr,*), intent(in) | tr, | ||
| integer(ilp), intent(in) | ldtr, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(out) | scale, | ||
| real(sp), dimension(ldx,*), intent(out) | x, | ||
| integer(ilp), intent(in) | ldx, | ||
| real(sp), intent(out) | xnorm, | ||
| integer(ilp), intent(out) | info ) |
SLASY2: solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in op(TL)*X + ISGN*X*op(TR) = SCALE*B, where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or -1. op(T) = T or T**T, where T**T denotes the transpose of T.
◆ la_strexc()
| subroutine, public la_lapack_eigv_gen_aux::la_strexc | ( | character, intent(in) | compq, |
| 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, | ||
| integer(ilp), intent(inout) | ifst, | ||
| integer(ilp), intent(inout) | ilst, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
STREXC: reorders the real Schur factorization of a real matrix A = Q*T*Q**T, so that the diagonal block of T with row index IFST is moved to row ILST. The real Schur form T is reordered by an orthogonal similarity transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultiplying it with Z. 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.
◆ la_wtrexc()
| pure subroutine, public la_lapack_eigv_gen_aux::la_wtrexc | ( | character, intent(in) | compq, |
| 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, | ||
| integer(ilp), intent(in) | ifst, | ||
| integer(ilp), intent(in) | ilst, | ||
| integer(ilp), intent(out) | info ) |
WTREXC: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.
◆ la_ztrexc()
| pure subroutine, public la_lapack_eigv_gen_aux::la_ztrexc | ( | character, intent(in) | compq, |
| 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, | ||
| integer(ilp), intent(in) | ifst, | ||
| integer(ilp), intent(in) | ilst, | ||
| integer(ilp), intent(out) | info ) |
ZTREXC: reorders the Schur factorization of a complex matrix A = Q*T*Q**H, so that the diagonal element of T with row index IFST is moved to row ILST. The Schur form T is reordered by a unitary similarity transformation Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by postmultplying it with Z.
