Generalized nonsymmetric eigenproblem components: eigenvectors, block swaps, deflating subspaces, Sylvester solves. More...
Functions/Subroutines | |
| pure subroutine, public | la_stgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, iwork, pq, info) |
| STGSY2: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F, using Level 1 and 2 BLAS. where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively, with real entries. (A, D) and (B, E) must be in generalized Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Z*x = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ], Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. In the process of solving (1), we solve a number of such systems where Dim(In), Dim(In) = 1 or 2. If TRANS = 'T', solve the transposed system Z**T*y = scale*b for y, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = sigma_min(Z) using reverse communication with SLACON. STGSY2 also (IJOB >= 1) contributes to the computation in STGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of the matrix pair in STGSYL. See STGSYL for details. | |
| pure subroutine, public | la_dtgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, iwork, pq, info) |
| DTGSY2: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F, using Level 1 and 2 BLAS. where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively, with real entries. (A, D) and (B, E) must be in generalized Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Z*x = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ], Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. In the process of solving (1), we solve a number of such systems where Dim(In), Dim(In) = 1 or 2. If TRANS = 'T', solve the transposed system Z**T*y = scale*b for y, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = sigma_min(Z) using reverse communication with DLACON. DTGSY2 also (IJOB >= 1) contributes to the computation in DTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of the matrix pair in DTGSYL. See DTGSYL for details. | |
| pure subroutine, public | la_qtgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, iwork, pq, info) |
| QTGSY2: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F, using Level 1 and 2 BLAS. where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively, with real entries. (A, D) and (B, E) must be in generalized Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Z*x = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ], Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. In the process of solving (1), we solve a number of such systems where Dim(In), Dim(In) = 1 or 2. If TRANS = 'T', solve the transposed system Z**T*y = scale*b for y, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = sigma_min(Z) using reverse communication with QLACON. QTGSY2 also (IJOB >= 1) contributes to the computation in QTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of the matrix pair in QTGSYL. See QTGSYL for details. | |
| pure subroutine, public | la_stgsyl (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) |
| STGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ]. Here Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', STGSYL solves the transposed system Z**T*y = scale*b, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using SLACON. If IJOB >= 1, STGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm. | |
| pure subroutine, public | la_dtgsyl (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) |
| DTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ]. Here Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', DTGSYL solves the transposed system Z**T*y = scale*b, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using DLACON. If IJOB >= 1, DTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm. | |
| pure subroutine, public | la_qtgsyl (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) |
| QTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ]. Here Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', QTGSYL solves the transposed system Z**T*y = scale*b, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using QLACON. If IJOB >= 1, QTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm. | |
| pure subroutine, public | la_slagv2 (a, lda, b, ldb, alphar, alphai, beta, csl, snl, csr, snr) |
| SLAGV2: computes the Generalized Schur factorization of a real 2-by-2 matrix pencil (A,B) where B is upper triangular. This routine computes orthogonal (rotation) matrices given by CSL, SNL and CSR, SNR such that 1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0 types), then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ 0 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 b12 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ], 2) if the pencil (A,B) has a pair of complex conjugate eigenvalues, then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ a21 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 0 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ] where b11 >= b22 > 0. | |
| pure subroutine, public | la_dlagv2 (a, lda, b, ldb, alphar, alphai, beta, csl, snl, csr, snr) |
| DLAGV2: computes the Generalized Schur factorization of a real 2-by-2 matrix pencil (A,B) where B is upper triangular. This routine computes orthogonal (rotation) matrices given by CSL, SNL and CSR, SNR such that 1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0 types), then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ 0 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 b12 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ], 2) if the pencil (A,B) has a pair of complex conjugate eigenvalues, then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ a21 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 0 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ] where b11 >= b22 > 0. | |
| pure subroutine, public | la_qlagv2 (a, lda, b, ldb, alphar, alphai, beta, csl, snl, csr, snr) |
| QLAGV2: computes the Generalized Schur factorization of a real 2-by-2 matrix pencil (A,B) where B is upper triangular. This routine computes orthogonal (rotation) matrices given by CSL, SNL and CSR, SNR such that 1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0 types), then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ 0 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 b12 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ], 2) if the pencil (A,B) has a pair of complex conjugate eigenvalues, then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ a21 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 0 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ] where b11 >= b22 > 0. | |
| pure subroutine, public | la_stgevc (side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, info) |
| STGEVC: computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = Q*S*Z**T, B = Q*P*Z**T as computed by SGGHRD + SHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B). | |
| pure subroutine, public | la_dtgevc (side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, info) |
| DTGEVC: computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = Q*S*Z**T, B = Q*P*Z**T as computed by DGGHRD + DHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B). | |
| pure subroutine, public | la_qtgevc (side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, info) |
| QTGEVC: computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = Q*S*Z**T, B = Q*P*Z**T as computed by QGGHRD + QHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B). | |
| pure subroutine, public | la_stgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, n1, n2, work, lwork, info) |
| STGEX2: swaps adjacent diagonal blocks (A11, B11) and (A22, B22) of size 1-by-1 or 2-by-2 in an upper (quasi) triangular matrix pair (A, B) by an orthogonal equivalence transformation. (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T. | |
| pure subroutine, public | la_dtgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, n1, n2, work, lwork, info) |
| DTGEX2: swaps adjacent diagonal blocks (A11, B11) and (A22, B22) of size 1-by-1 or 2-by-2 in an upper (quasi) triangular matrix pair (A, B) by an orthogonal equivalence transformation. (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T. | |
| pure subroutine, public | la_qtgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, n1, n2, work, lwork, info) |
| QTGEX2: swaps adjacent diagonal blocks (A11, B11) and (A22, B22) of size 1-by-1 or 2-by-2 in an upper (quasi) triangular matrix pair (A, B) by an orthogonal equivalence transformation. (A, B) must be in generalized real Schur canonical form (as returned by QGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T. | |
| pure subroutine, public | la_stgexc (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info) |
| STGEXC: reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * Z**T, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T. | |
| pure subroutine, public | la_dtgexc (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info) |
| DTGEXC: reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * Z**T, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T. | |
| pure subroutine, public | la_qtgexc (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info) |
| QTGEXC: reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * Z**T, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by QGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T. | |
| pure subroutine, public | la_stgsen (ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) |
| STGSEN: reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. STGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + i*ALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, STGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block. | |
| pure subroutine, public | la_dtgsen (ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) |
| DTGSEN: reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. DTGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + i*ALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, DTGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block. | |
| pure subroutine, public | la_qtgsen (ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) |
| QTGSEN: reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by QGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. QTGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + i*ALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, QTGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block. | |
| pure subroutine, public | la_stgsna (job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) |
| STGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. | |
| pure subroutine, public | la_dtgsna (job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) |
| DTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. | |
| pure subroutine, public | la_qtgsna (job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) |
| QTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by QGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. | |
| pure subroutine, public | la_ctgevc (side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info) |
| CTGEVC: computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = Q*S*Z**H, B = Q*P*Z**H as computed by CGGHRD + CHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B). | |
| pure subroutine, public | la_ztgevc (side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info) |
| ZTGEVC: computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = Q*S*Z**H, B = Q*P*Z**H as computed by ZGGHRD + ZHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B). | |
| pure subroutine, public | la_wtgevc (side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, rwork, info) |
| WTGEVC: computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = Q*S*Z**H, B = Q*P*Z**H as computed by WGGHRD + WHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B). | |
| pure subroutine, public | la_ctgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info) |
| CTGEX2: swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22) in an upper triangular matrix pair (A, B) by an unitary equivalence transformation. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H. | |
| pure subroutine, public | la_ztgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info) |
| ZTGEX2: swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22) in an upper triangular matrix pair (A, B) by an unitary equivalence transformation. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H. | |
| pure subroutine, public | la_wtgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info) |
| WTGEX2: swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22) in an upper triangular matrix pair (A, B) by an unitary equivalence transformation. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H. | |
| pure subroutine, public | la_ctgexc (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info) |
| CTGEXC: reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * Z**H, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H. | |
| pure subroutine, public | la_ztgexc (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info) |
| ZTGEXC: reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * Z**H, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H. | |
| pure subroutine, public | la_wtgexc (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info) |
| WTGEXC: reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * Z**H, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H. | |
| pure subroutine, public | la_ctgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, info) |
| CTGSY2: solves the generalized Sylvester equation A * R - L * B = scale * C (1) D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Zx = scale * b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Ik is the identity matrix of size k and X**H is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = = sigma_min(Z) using reverse communication with CLACON. CTGSY2 also (IJOB >= 1) contributes to the computation in CTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of two matrix pairs in CTGSYL. | |
| pure subroutine, public | la_ztgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, info) |
| ZTGSY2: solves the generalized Sylvester equation A * R - L * B = scale * C (1) D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Zx = scale * b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Ik is the identity matrix of size k and X**H is the conjuguate transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = = sigma_min(Z) using reverse communication with ZLACON. ZTGSY2 also (IJOB >= 1) contributes to the computation in ZTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of two matrix pairs in ZTGSYL. | |
| pure subroutine, public | la_wtgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, info) |
| WTGSY2: solves the generalized Sylvester equation A * R - L * B = scale * C (1) D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Zx = scale * b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Ik is the identity matrix of size k and X**H is the conjuguate transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = = sigma_min(Z) using reverse communication with WLACON. WTGSY2 also (IJOB >= 1) contributes to the computation in WTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of two matrix pairs in WTGSYL. | |
| pure subroutine, public | la_ctgsyl (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) |
| CTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Here Ix is the identity matrix of size x and X**H is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H *y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using CLACON. If IJOB >= 1, CTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm. | |
| pure subroutine, public | la_ztgsyl (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) |
| ZTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Here Ix is the identity matrix of size x and X**H is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H *y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using ZLACON. If IJOB >= 1, ZTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm. | |
| pure subroutine, public | la_wtgsyl (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info) |
| WTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Here Ix is the identity matrix of size x and X**H is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H *y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using WLACON. If IJOB >= 1, WTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm. | |
| pure subroutine, public | la_ctgsen (ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) |
| CTGSEN: reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. CTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block. | |
| pure subroutine, public | la_ztgsen (ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) |
| ZTGSEN: reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. ZTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block. | |
| pure subroutine, public | la_wtgsen (ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) |
| WTGSEN: reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. WTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block. | |
| pure subroutine, public | la_ctgsna (job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) |
| CTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. | |
| pure subroutine, public | la_ztgsna (job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) |
| ZTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. | |
| pure subroutine, public | la_wtgsna (job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info) |
| WTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. | |
Detailed Description
Generalized nonsymmetric eigenproblem components: eigenvectors, block swaps, deflating subspaces, Sylvester solves.
Function/Subroutine Documentation
◆ la_ctgevc()
| pure subroutine, public la_lapack_eigv_comp2::la_ctgevc | ( | character, intent(in) | side, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lds,*), intent(in) | s, | ||
| integer(ilp), intent(in) | lds, | ||
| complex(sp), dimension(ldp,*), intent(in) | p, | ||
| integer(ilp), intent(in) | ldp, | ||
| 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 ) |
CTGEVC: computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = Q*S*Z**H, B = Q*P*Z**H as computed by CGGHRD + CHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B).
◆ la_ctgex2()
| pure subroutine, public la_lapack_eigv_comp2::la_ctgex2 | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(in) | j1, | ||
| integer(ilp), intent(out) | info ) |
CTGEX2: swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22) in an upper triangular matrix pair (A, B) by an unitary equivalence transformation. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H.
◆ la_ctgexc()
| pure subroutine, public la_lapack_eigv_comp2::la_ctgexc | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(in) | ifst, | ||
| integer(ilp), intent(inout) | ilst, | ||
| integer(ilp), intent(out) | info ) |
CTGEXC: reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * Z**H, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H.
◆ la_ctgsen()
| pure subroutine, public la_lapack_eigv_comp2::la_ctgsen | ( | integer(ilp), intent(in) | ijob, |
| logical(lk), intent(in) | wantq, | ||
| logical(lk), intent(in) | wantz, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(sp), dimension(*), intent(out) | alpha, | ||
| complex(sp), dimension(*), intent(out) | beta, | ||
| complex(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | m, | ||
| real(sp), intent(out) | pl, | ||
| real(sp), intent(out) | pr, | ||
| real(sp), dimension(*), intent(out) | dif, | ||
| complex(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 ) |
CTGSEN: reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. CTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
◆ la_ctgsna()
| pure subroutine, public la_lapack_eigv_comp2::la_ctgsna | ( | character, intent(in) | job, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| 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(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) | dif, | ||
| integer(ilp), intent(in) | mm, | ||
| integer(ilp), intent(out) | m, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
CTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.
◆ la_ctgsy2()
| pure subroutine, public la_lapack_eigv_comp2::la_ctgsy2 | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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, | ||
| complex(sp), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| complex(sp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| complex(sp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(sp), intent(out) | scale, | ||
| real(sp), intent(inout) | rdsum, | ||
| real(sp), intent(inout) | rdscal, | ||
| integer(ilp), intent(out) | info ) |
CTGSY2: solves the generalized Sylvester equation A * R - L * B = scale * C (1) D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Zx = scale * b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Ik is the identity matrix of size k and X**H is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = = sigma_min(Z) using reverse communication with CLACON. CTGSY2 also (IJOB >= 1) contributes to the computation in CTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of two matrix pairs in CTGSYL.
◆ la_ctgsyl()
| pure subroutine, public la_lapack_eigv_comp2::la_ctgsyl | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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, | ||
| complex(sp), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| complex(sp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| complex(sp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(sp), intent(out) | scale, | ||
| real(sp), intent(out) | dif, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
CTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Here Ix is the identity matrix of size x and X**H is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H *y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using CLACON. If IJOB >= 1, CTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.
◆ la_dlagv2()
| pure subroutine, public la_lapack_eigv_comp2::la_dlagv2 | ( | real(dp), dimension(lda,*), intent(inout) | a, |
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(2), intent(out) | alphar, | ||
| real(dp), dimension(2), intent(out) | alphai, | ||
| real(dp), dimension(2), intent(out) | beta, | ||
| real(dp), intent(out) | csl, | ||
| real(dp), intent(out) | snl, | ||
| real(dp), intent(out) | csr, | ||
| real(dp), intent(out) | snr ) |
DLAGV2: computes the Generalized Schur factorization of a real 2-by-2 matrix pencil (A,B) where B is upper triangular. This routine computes orthogonal (rotation) matrices given by CSL, SNL and CSR, SNR such that 1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0 types), then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ 0 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 b12 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ], 2) if the pencil (A,B) has a pair of complex conjugate eigenvalues, then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ a21 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 0 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ] where b11 >= b22 > 0.
◆ la_dtgevc()
| pure subroutine, public la_lapack_eigv_comp2::la_dtgevc | ( | character, intent(in) | side, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lds,*), intent(in) | s, | ||
| integer(ilp), intent(in) | lds, | ||
| real(dp), dimension(ldp,*), intent(in) | p, | ||
| integer(ilp), intent(in) | ldp, | ||
| 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 ) |
DTGEVC: computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = Q*S*Z**T, B = Q*P*Z**T as computed by DGGHRD + DHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B).
◆ la_dtgex2()
| pure subroutine, public la_lapack_eigv_comp2::la_dtgex2 | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(in) | j1, | ||
| integer(ilp), intent(in) | n1, | ||
| integer(ilp), intent(in) | n2, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DTGEX2: swaps adjacent diagonal blocks (A11, B11) and (A22, B22) of size 1-by-1 or 2-by-2 in an upper (quasi) triangular matrix pair (A, B) by an orthogonal equivalence transformation. (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T.
◆ la_dtgexc()
| pure subroutine, public la_lapack_eigv_comp2::la_dtgexc | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(inout) | ifst, | ||
| integer(ilp), intent(inout) | ilst, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DTGEXC: reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * Z**T, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T.
◆ la_dtgsen()
| pure subroutine, public la_lapack_eigv_comp2::la_dtgsen | ( | integer(ilp), intent(in) | ijob, |
| logical(lk), intent(in) | wantq, | ||
| logical(lk), intent(in) | wantz, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(dp), dimension(*), intent(out) | alphar, | ||
| real(dp), dimension(*), intent(out) | alphai, | ||
| real(dp), dimension(*), intent(out) | beta, | ||
| real(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | m, | ||
| real(dp), intent(out) | pl, | ||
| real(dp), intent(out) | pr, | ||
| real(dp), dimension(*), intent(out) | dif, | ||
| 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 ) |
DTGSEN: reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. DTGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + i*ALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, DTGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
◆ la_dtgsna()
| pure subroutine, public la_lapack_eigv_comp2::la_dtgsna | ( | character, intent(in) | job, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| 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(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) | dif, | ||
| integer(ilp), intent(in) | mm, | ||
| integer(ilp), intent(out) | m, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by DGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular.
◆ la_dtgsy2()
| pure subroutine, public la_lapack_eigv_comp2::la_dtgsy2 | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| real(dp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| real(dp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(dp), intent(out) | scale, | ||
| real(dp), intent(inout) | rdsum, | ||
| real(dp), intent(inout) | rdscal, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | pq, | ||
| integer(ilp), intent(out) | info ) |
DTGSY2: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F, using Level 1 and 2 BLAS. where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively, with real entries. (A, D) and (B, E) must be in generalized Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Z*x = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ], Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. In the process of solving (1), we solve a number of such systems where Dim(In), Dim(In) = 1 or 2. If TRANS = 'T', solve the transposed system Z**T*y = scale*b for y, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = sigma_min(Z) using reverse communication with DLACON. DTGSY2 also (IJOB >= 1) contributes to the computation in DTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of the matrix pair in DTGSYL. See DTGSYL for details.
◆ la_dtgsyl()
| pure subroutine, public la_lapack_eigv_comp2::la_dtgsyl | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| real(dp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| real(dp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(dp), intent(out) | scale, | ||
| real(dp), intent(out) | dif, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
DTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ]. Here Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', DTGSYL solves the transposed system Z**T*y = scale*b, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using DLACON. If IJOB >= 1, DTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm.
◆ la_qlagv2()
| pure subroutine, public la_lapack_eigv_comp2::la_qlagv2 | ( | real(qp), dimension(lda,*), intent(inout) | a, |
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(2), intent(out) | alphar, | ||
| real(qp), dimension(2), intent(out) | alphai, | ||
| real(qp), dimension(2), intent(out) | beta, | ||
| real(qp), intent(out) | csl, | ||
| real(qp), intent(out) | snl, | ||
| real(qp), intent(out) | csr, | ||
| real(qp), intent(out) | snr ) |
QLAGV2: computes the Generalized Schur factorization of a real 2-by-2 matrix pencil (A,B) where B is upper triangular. This routine computes orthogonal (rotation) matrices given by CSL, SNL and CSR, SNR such that 1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0 types), then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ 0 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 b12 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ], 2) if the pencil (A,B) has a pair of complex conjugate eigenvalues, then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ a21 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 0 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ] where b11 >= b22 > 0.
◆ la_qtgevc()
| pure subroutine, public la_lapack_eigv_comp2::la_qtgevc | ( | character, intent(in) | side, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lds,*), intent(in) | s, | ||
| integer(ilp), intent(in) | lds, | ||
| real(qp), dimension(ldp,*), intent(in) | p, | ||
| integer(ilp), intent(in) | ldp, | ||
| 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 ) |
QTGEVC: computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = Q*S*Z**T, B = Q*P*Z**T as computed by QGGHRD + QHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B).
◆ la_qtgex2()
| pure subroutine, public la_lapack_eigv_comp2::la_qtgex2 | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(in) | j1, | ||
| integer(ilp), intent(in) | n1, | ||
| integer(ilp), intent(in) | n2, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QTGEX2: swaps adjacent diagonal blocks (A11, B11) and (A22, B22) of size 1-by-1 or 2-by-2 in an upper (quasi) triangular matrix pair (A, B) by an orthogonal equivalence transformation. (A, B) must be in generalized real Schur canonical form (as returned by QGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T.
◆ la_qtgexc()
| pure subroutine, public la_lapack_eigv_comp2::la_qtgexc | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(inout) | ifst, | ||
| integer(ilp), intent(inout) | ilst, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QTGEXC: reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * Z**T, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by QGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T.
◆ la_qtgsen()
| pure subroutine, public la_lapack_eigv_comp2::la_qtgsen | ( | integer(ilp), intent(in) | ijob, |
| logical(lk), intent(in) | wantq, | ||
| logical(lk), intent(in) | wantz, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), dimension(*), intent(out) | alphar, | ||
| real(qp), dimension(*), intent(out) | alphai, | ||
| real(qp), dimension(*), intent(out) | beta, | ||
| real(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), intent(out) | pl, | ||
| real(qp), intent(out) | pr, | ||
| real(qp), dimension(*), intent(out) | dif, | ||
| 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 ) |
QTGSEN: reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by QGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. QTGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + i*ALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, QTGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
◆ la_qtgsna()
| pure subroutine, public la_lapack_eigv_comp2::la_qtgsna | ( | character, intent(in) | job, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| 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(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) | dif, | ||
| integer(ilp), intent(in) | mm, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by QGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular.
◆ la_qtgsy2()
| pure subroutine, public la_lapack_eigv_comp2::la_qtgsy2 | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| real(qp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| real(qp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(qp), intent(out) | scale, | ||
| real(qp), intent(inout) | rdsum, | ||
| real(qp), intent(inout) | rdscal, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | pq, | ||
| integer(ilp), intent(out) | info ) |
QTGSY2: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F, using Level 1 and 2 BLAS. where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively, with real entries. (A, D) and (B, E) must be in generalized Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Z*x = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ], Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. In the process of solving (1), we solve a number of such systems where Dim(In), Dim(In) = 1 or 2. If TRANS = 'T', solve the transposed system Z**T*y = scale*b for y, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = sigma_min(Z) using reverse communication with QLACON. QTGSY2 also (IJOB >= 1) contributes to the computation in QTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of the matrix pair in QTGSYL. See QTGSYL for details.
◆ la_qtgsyl()
| pure subroutine, public la_lapack_eigv_comp2::la_qtgsyl | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| real(qp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| real(qp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(qp), intent(out) | scale, | ||
| real(qp), intent(out) | dif, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
QTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ]. Here Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', QTGSYL solves the transposed system Z**T*y = scale*b, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using QLACON. If IJOB >= 1, QTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm.
◆ la_slagv2()
| pure subroutine, public la_lapack_eigv_comp2::la_slagv2 | ( | real(sp), dimension(lda,*), intent(inout) | a, |
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(2), intent(out) | alphar, | ||
| real(sp), dimension(2), intent(out) | alphai, | ||
| real(sp), dimension(2), intent(out) | beta, | ||
| real(sp), intent(out) | csl, | ||
| real(sp), intent(out) | snl, | ||
| real(sp), intent(out) | csr, | ||
| real(sp), intent(out) | snr ) |
SLAGV2: computes the Generalized Schur factorization of a real 2-by-2 matrix pencil (A,B) where B is upper triangular. This routine computes orthogonal (rotation) matrices given by CSL, SNL and CSR, SNR such that 1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0 types), then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ 0 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 b12 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ], 2) if the pencil (A,B) has a pair of complex conjugate eigenvalues, then [ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ] [ a21 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ] [ b11 0 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ] [ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ] where b11 >= b22 > 0.
◆ la_stgevc()
| pure subroutine, public la_lapack_eigv_comp2::la_stgevc | ( | character, intent(in) | side, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lds,*), intent(in) | s, | ||
| integer(ilp), intent(in) | lds, | ||
| real(sp), dimension(ldp,*), intent(in) | p, | ||
| integer(ilp), intent(in) | ldp, | ||
| 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 ) |
STGEVC: computes some or all of the right and/or left eigenvectors of a pair of real matrices (S,P), where S is a quasi-triangular matrix and P is upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a matrix pair (A,B): A = Q*S*Z**T, B = Q*P*Z**T as computed by SGGHRD + SHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal blocks of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the orthogonal factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B).
◆ la_stgex2()
| pure subroutine, public la_lapack_eigv_comp2::la_stgex2 | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(in) | j1, | ||
| integer(ilp), intent(in) | n1, | ||
| integer(ilp), intent(in) | n2, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
STGEX2: swaps adjacent diagonal blocks (A11, B11) and (A22, B22) of size 1-by-1 or 2-by-2 in an upper (quasi) triangular matrix pair (A, B) by an orthogonal equivalence transformation. (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T.
◆ la_stgexc()
| pure subroutine, public la_lapack_eigv_comp2::la_stgexc | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(inout) | ifst, | ||
| integer(ilp), intent(inout) | ilst, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
STGEXC: reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation (A, B) = Q * (A, B) * Z**T, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**T = Q(out) * A(out) * Z(out)**T Q(in) * B(in) * Z(in)**T = Q(out) * B(out) * Z(out)**T.
◆ la_stgsen()
| pure subroutine, public la_lapack_eigv_comp2::la_stgsen | ( | integer(ilp), intent(in) | ijob, |
| logical(lk), intent(in) | wantq, | ||
| logical(lk), intent(in) | wantz, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), dimension(*), intent(out) | alphar, | ||
| real(sp), dimension(*), intent(out) | alphai, | ||
| real(sp), dimension(*), intent(out) | beta, | ||
| real(sp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| real(sp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | m, | ||
| real(sp), intent(out) | pl, | ||
| real(sp), intent(out) | pr, | ||
| real(sp), dimension(*), intent(out) | dif, | ||
| 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 ) |
STGSEN: reorders the generalized real Schur decomposition of a real matrix pair (A, B) (in terms of an orthonormal equivalence trans- formation Q**T * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. The leading columns of Q and Z form orthonormal bases of the corresponding left and right eigen- spaces (deflating subspaces). (A, B) must be in generalized real Schur canonical form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular. STGSEN also computes the generalized eigenvalues w(j) = (ALPHAR(j) + i*ALPHAI(j))/BETA(j) of the reordered matrix pair (A, B). Optionally, STGSEN computes the estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
◆ la_stgsna()
| pure subroutine, public la_lapack_eigv_comp2::la_stgsna | ( | character, intent(in) | job, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| 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(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) | dif, | ||
| integer(ilp), intent(in) | mm, | ||
| integer(ilp), intent(out) | m, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
STGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form (or of any matrix pair (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where Z**T denotes the transpose of Z. (A, B) must be in generalized real Schur form (as returned by SGGES), i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal blocks. B is upper triangular.
◆ la_stgsy2()
| pure subroutine, public la_lapack_eigv_comp2::la_stgsy2 | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| real(sp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| real(sp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(sp), intent(out) | scale, | ||
| real(sp), intent(inout) | rdsum, | ||
| real(sp), intent(inout) | rdscal, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | pq, | ||
| integer(ilp), intent(out) | info ) |
STGSY2: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F, using Level 1 and 2 BLAS. where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively, with real entries. (A, D) and (B, E) must be in generalized Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Z*x = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ], Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. In the process of solving (1), we solve a number of such systems where Dim(In), Dim(In) = 1 or 2. If TRANS = 'T', solve the transposed system Z**T*y = scale*b for y, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = sigma_min(Z) using reverse communication with SLACON. STGSY2 also (IJOB >= 1) contributes to the computation in STGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of the matrix pair in STGSYL. See STGSYL for details.
◆ la_stgsyl()
| pure subroutine, public la_lapack_eigv_comp2::la_stgsyl | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| real(sp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| real(sp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(sp), intent(out) | scale, | ||
| real(sp), intent(out) | dif, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
STGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular. The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as Z = [ kron(In, A) -kron(B**T, Im) ] (2) [ kron(In, D) -kron(E**T, Im) ]. Here Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'T', STGSYL solves the transposed system Z**T*y = scale*b, which is equivalent to solve for R and L in A**T * R + D**T * L = scale * C (3) R * B**T + L * E**T = scale * -F This case (TRANS = 'T') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using SLACON. If IJOB >= 1, STGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information. This is a level 3 BLAS algorithm.
◆ la_wtgevc()
| pure subroutine, public la_lapack_eigv_comp2::la_wtgevc | ( | character, intent(in) | side, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lds,*), intent(in) | s, | ||
| integer(ilp), intent(in) | lds, | ||
| complex(qp), dimension(ldp,*), intent(in) | p, | ||
| integer(ilp), intent(in) | ldp, | ||
| 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 ) |
WTGEVC: computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = Q*S*Z**H, B = Q*P*Z**H as computed by WGGHRD + WHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B).
◆ la_wtgex2()
| pure subroutine, public la_lapack_eigv_comp2::la_wtgex2 | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(in) | j1, | ||
| integer(ilp), intent(out) | info ) |
WTGEX2: swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22) in an upper triangular matrix pair (A, B) by an unitary equivalence transformation. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H.
◆ la_wtgexc()
| pure subroutine, public la_lapack_eigv_comp2::la_wtgexc | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(in) | ifst, | ||
| integer(ilp), intent(inout) | ilst, | ||
| integer(ilp), intent(out) | info ) |
WTGEXC: reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * Z**H, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H.
◆ la_wtgsen()
| pure subroutine, public la_lapack_eigv_comp2::la_wtgsen | ( | integer(ilp), intent(in) | ijob, |
| logical(lk), intent(in) | wantq, | ||
| logical(lk), intent(in) | wantz, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(qp), dimension(*), intent(out) | alpha, | ||
| complex(qp), dimension(*), intent(out) | beta, | ||
| complex(qp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(qp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | m, | ||
| real(qp), intent(out) | pl, | ||
| real(qp), intent(out) | pr, | ||
| real(qp), dimension(*), intent(out) | dif, | ||
| complex(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 ) |
WTGSEN: reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. WTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
◆ la_wtgsna()
| pure subroutine, public la_lapack_eigv_comp2::la_wtgsna | ( | character, intent(in) | job, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| 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(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) | dif, | ||
| integer(ilp), intent(in) | mm, | ||
| integer(ilp), intent(out) | m, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
WTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.
◆ la_wtgsy2()
| pure subroutine, public la_lapack_eigv_comp2::la_wtgsy2 | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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, | ||
| complex(qp), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| complex(qp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| complex(qp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(qp), intent(out) | scale, | ||
| real(qp), intent(inout) | rdsum, | ||
| real(qp), intent(inout) | rdscal, | ||
| integer(ilp), intent(out) | info ) |
WTGSY2: solves the generalized Sylvester equation A * R - L * B = scale * C (1) D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Zx = scale * b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Ik is the identity matrix of size k and X**H is the conjuguate transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = = sigma_min(Z) using reverse communication with WLACON. WTGSY2 also (IJOB >= 1) contributes to the computation in WTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of two matrix pairs in WTGSYL.
◆ la_wtgsyl()
| pure subroutine, public la_lapack_eigv_comp2::la_wtgsyl | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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, | ||
| complex(qp), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| complex(qp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| complex(qp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(qp), intent(out) | scale, | ||
| real(qp), intent(out) | dif, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
WTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Here Ix is the identity matrix of size x and X**H is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H *y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using WLACON. If IJOB >= 1, WTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.
◆ la_ztgevc()
| pure subroutine, public la_lapack_eigv_comp2::la_ztgevc | ( | character, intent(in) | side, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lds,*), intent(in) | s, | ||
| integer(ilp), intent(in) | lds, | ||
| complex(dp), dimension(ldp,*), intent(in) | p, | ||
| integer(ilp), intent(in) | ldp, | ||
| 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 ) |
ZTGEVC: computes some or all of the right and/or left eigenvectors of a pair of complex matrices (S,P), where S and P are upper triangular. Matrix pairs of this type are produced by the generalized Schur factorization of a complex matrix pair (A,B): A = Q*S*Z**H, B = Q*P*Z**H as computed by ZGGHRD + ZHGEQZ. The right eigenvector x and the left eigenvector y of (S,P) corresponding to an eigenvalue w are defined by: S*x = w*P*x, (y**H)*S = w*(y**H)*P, where y**H denotes the conjugate tranpose of y. The eigenvalues are not input to this routine, but are computed directly from the diagonal elements of S and P. This routine returns the matrices X and/or Y of right and left eigenvectors of (S,P), or the products Z*X and/or Q*Y, where Z and Q are input matrices. If Q and Z are the unitary factors from the generalized Schur factorization of a matrix pair (A,B), then Z*X and Q*Y are the matrices of right and left eigenvectors of (A,B).
◆ la_ztgex2()
| pure subroutine, public la_lapack_eigv_comp2::la_ztgex2 | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(in) | j1, | ||
| integer(ilp), intent(out) | info ) |
ZTGEX2: swaps adjacent diagonal 1 by 1 blocks (A11,B11) and (A22,B22) in an upper triangular matrix pair (A, B) by an unitary equivalence transformation. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H.
◆ la_ztgexc()
| pure subroutine, public la_lapack_eigv_comp2::la_ztgexc | ( | logical(lk), intent(in) | wantq, |
| logical(lk), intent(in) | wantz, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(in) | ifst, | ||
| integer(ilp), intent(inout) | ilst, | ||
| integer(ilp), intent(out) | info ) |
ZTGEXC: reorders the generalized Schur decomposition of a complex matrix pair (A,B), using an unitary equivalence transformation (A, B) := Q * (A, B) * Z**H, so that the diagonal block of (A, B) with row index IFST is moved to row ILST. (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. Optionally, the matrices Q and Z of generalized Schur vectors are updated. Q(in) * A(in) * Z(in)**H = Q(out) * A(out) * Z(out)**H Q(in) * B(in) * Z(in)**H = Q(out) * B(out) * Z(out)**H.
◆ la_ztgsen()
| pure subroutine, public la_lapack_eigv_comp2::la_ztgsen | ( | integer(ilp), intent(in) | ijob, |
| logical(lk), intent(in) | wantq, | ||
| logical(lk), intent(in) | wantz, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| complex(dp), dimension(*), intent(out) | alpha, | ||
| complex(dp), dimension(*), intent(out) | beta, | ||
| complex(dp), dimension(ldq,*), intent(inout) | q, | ||
| integer(ilp), intent(in) | ldq, | ||
| complex(dp), dimension(ldz,*), intent(inout) | z, | ||
| integer(ilp), intent(in) | ldz, | ||
| integer(ilp), intent(out) | m, | ||
| real(dp), intent(out) | pl, | ||
| real(dp), intent(out) | pr, | ||
| real(dp), dimension(*), intent(out) | dif, | ||
| complex(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 ) |
ZTGSEN: reorders the generalized Schur decomposition of a complex matrix pair (A, B) (in terms of an unitary equivalence trans- formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the pair (A,B). The leading columns of Q and Z form unitary bases of the corresponding left and right eigenspaces (deflating subspaces). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular. ZTGSEN also computes the generalized eigenvalues w(j)= ALPHA(j) / BETA(j) of the reordered matrix pair (A, B). Optionally, the routine computes estimates of reciprocal condition numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11), (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s) between the matrix pairs (A11, B11) and (A22,B22) that correspond to the selected cluster and the eigenvalues outside the cluster, resp., and norms of "projections" onto left and right eigenspaces w.r.t. the selected cluster in the (1,1)-block.
◆ la_ztgsna()
| pure subroutine, public la_lapack_eigv_comp2::la_ztgsna | ( | character, intent(in) | job, |
| character, intent(in) | howmny, | ||
| logical(lk), dimension(*), intent(in) | select, | ||
| 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(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) | dif, | ||
| integer(ilp), intent(in) | mm, | ||
| integer(ilp), intent(out) | m, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
ZTGSNA: estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B). (A, B) must be in generalized Schur canonical form, that is, A and B are both upper triangular.
◆ la_ztgsy2()
| pure subroutine, public la_lapack_eigv_comp2::la_ztgsy2 | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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, | ||
| complex(dp), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| complex(dp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| complex(dp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(dp), intent(out) | scale, | ||
| real(dp), intent(inout) | rdsum, | ||
| real(dp), intent(inout) | rdscal, | ||
| integer(ilp), intent(out) | info ) |
ZTGSY2: solves the generalized Sylvester equation A * R - L * B = scale * C (1) D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M, N-by-N and M-by-N, respectively. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation solving equation (1) corresponds to solve Zx = scale * b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Ik is the identity matrix of size k and X**H is the conjuguate transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case is used to compute an estimate of Dif[(A, D), (B, E)] = = sigma_min(Z) using reverse communication with ZLACON. ZTGSY2 also (IJOB >= 1) contributes to the computation in ZTGSYL of an upper bound on the separation between to matrix pairs. Then the input (A, D), (B, E) are sub-pencils of two matrix pairs in ZTGSYL.
◆ la_ztgsyl()
| pure subroutine, public la_lapack_eigv_comp2::la_ztgsyl | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | ijob, | ||
| 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, | ||
| complex(dp), dimension(ldd,*), intent(in) | d, | ||
| integer(ilp), intent(in) | ldd, | ||
| complex(dp), dimension(lde,*), intent(in) | e, | ||
| integer(ilp), intent(in) | lde, | ||
| complex(dp), dimension(ldf,*), intent(inout) | f, | ||
| integer(ilp), intent(in) | ldf, | ||
| real(dp), intent(out) | scale, | ||
| real(dp), intent(out) | dif, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| integer(ilp), intent(out) | info ) |
ZTGSYL: solves the generalized Sylvester equation: A * R - L * B = scale * C (1) D * R - L * E = scale * F where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form). The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow. In matrix notation (1) is equivalent to solve Zx = scale*b, where Z is defined as Z = [ kron(In, A) -kron(B**H, Im) ] (2) [ kron(In, D) -kron(E**H, Im) ], Here Ix is the identity matrix of size x and X**H is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y. If TRANS = 'C', y in the conjugate transposed system Z**H *y = scale*b is solved for, which is equivalent to solve for R and L in A**H * R + D**H * L = scale * C (3) R * B**H + L * E**H = scale * -F This case (TRANS = 'C') is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using ZLACON. If IJOB >= 1, ZTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. This is a level-3 BLAS algorithm.
