 |
LAPACK 3.12.1
LAPACK: Linear Algebra PACKage
|
| subroutine sgegv | ( | character | jobvl, |
| character | jobvr, | ||
| integer | n, | ||
| real, dimension( lda, * ) | a, | ||
| integer | lda, | ||
| real, dimension( ldb, * ) | b, | ||
| integer | ldb, | ||
| real, dimension( * ) | alphar, | ||
| real, dimension( * ) | alphai, | ||
| real, dimension( * ) | beta, | ||
| real, dimension( ldvl, * ) | vl, | ||
| integer | ldvl, | ||
| real, dimension( ldvr, * ) | vr, | ||
| integer | ldvr, | ||
| real, dimension( * ) | work, | ||
| integer | lwork, | ||
| integer | info ) |
SGEGV computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real matrix pair (A,B).
Download SGEGV + dependencies [TGZ] [ZIP] [TXT]
!> !> This routine is deprecated and has been replaced by routine SGGEV. !> !> SGEGV computes the eigenvalues and, optionally, the left and/or right !> eigenvectors of a real matrix pair (A,B). !> Given two square matrices A and B, !> the generalized nonsymmetric eigenvalue problem (GNEP) is to find the !> eigenvalues lambda and corresponding (non-zero) eigenvectors x such !> that !> !> A*x = lambda*B*x. !> !> An alternate form is to find the eigenvalues mu and corresponding !> eigenvectors y such that !> !> mu*A*y = B*y. !> !> These two forms are equivalent with mu = 1/lambda and x = y if !> neither lambda nor mu is zero. In order to deal with the case that !> lambda or mu is zero or small, two values alpha and beta are returned !> for each eigenvalue, such that lambda = alpha/beta and !> mu = beta/alpha. !> !> The vectors x and y in the above equations are right eigenvectors of !> the matrix pair (A,B). Vectors u and v satisfying !> !> u**H*A = lambda*u**H*B or mu*v**H*A = v**H*B !> !> are left eigenvectors of (A,B). !> !> Note: this routine performs on A and B !>
| [in] | JOBVL | !> JOBVL is CHARACTER*1 !> = 'N': do not compute the left generalized eigenvectors; !> = 'V': compute the left generalized eigenvectors (returned !> in VL). !> |
| [in] | JOBVR | !> JOBVR is CHARACTER*1 !> = 'N': do not compute the right generalized eigenvectors; !> = 'V': compute the right generalized eigenvectors (returned !> in VR). !> |
| [in] | N | !> N is INTEGER !> The order of the matrices A, B, VL, and VR. N >= 0. !> |
| [in,out] | A | !> A is REAL array, dimension (LDA, N) !> On entry, the matrix A. !> If JOBVL = 'V' or JOBVR = 'V', then on exit A !> contains the real Schur form of A from the generalized Schur !> factorization of the pair (A,B) after balancing. !> If no eigenvectors were computed, then only the diagonal !> blocks from the Schur form will be correct. See SGGHRD and !> SHGEQZ for details. !> |
| [in] | LDA | !> LDA is INTEGER !> The leading dimension of A. LDA >= max(1,N). !> |
| [in,out] | B | !> B is REAL array, dimension (LDB, N) !> On entry, the matrix B. !> If JOBVL = 'V' or JOBVR = 'V', then on exit B contains the !> upper triangular matrix obtained from B in the generalized !> Schur factorization of the pair (A,B) after balancing. !> If no eigenvectors were computed, then only those elements of !> B corresponding to the diagonal blocks from the Schur form of !> A will be correct. See SGGHRD and SHGEQZ for details. !> |
| [in] | LDB | !> LDB is INTEGER !> The leading dimension of B. LDB >= max(1,N). !> |
| [out] | ALPHAR | !> ALPHAR is REAL array, dimension (N) !> The real parts of each scalar alpha defining an eigenvalue of !> GNEP. !> |
| [out] | ALPHAI | !> ALPHAI is REAL array, dimension (N) !> The imaginary parts of each scalar alpha defining an !> eigenvalue of GNEP. If ALPHAI(j) is zero, then the j-th !> eigenvalue is real; if positive, then the j-th and !> (j+1)-st eigenvalues are a complex conjugate pair, with !> ALPHAI(j+1) = -ALPHAI(j). !> |
| [out] | BETA | !> BETA is REAL array, dimension (N) !> The scalars beta that define the eigenvalues of GNEP. !> !> Together, the quantities alpha = (ALPHAR(j),ALPHAI(j)) and !> beta = BETA(j) represent the j-th eigenvalue of the matrix !> pair (A,B), in one of the forms lambda = alpha/beta or !> mu = beta/alpha. Since either lambda or mu may overflow, !> they should not, in general, be computed. !> |
| [out] | VL | !> VL is REAL array, dimension (LDVL,N) !> If JOBVL = 'V', the left eigenvectors u(j) are stored !> in the columns of VL, in the same order as their eigenvalues. !> If the j-th eigenvalue is real, then u(j) = VL(:,j). !> If the j-th and (j+1)-st eigenvalues form a complex conjugate !> pair, then !> u(j) = VL(:,j) + i*VL(:,j+1) !> and !> u(j+1) = VL(:,j) - i*VL(:,j+1). !> !> Each eigenvector is scaled so that its largest component has !> abs(real part) + abs(imag. part) = 1, except for eigenvectors !> corresponding to an eigenvalue with alpha = beta = 0, which !> are set to zero. !> Not referenced if JOBVL = 'N'. !> |
| [in] | LDVL | !> LDVL is INTEGER !> The leading dimension of the matrix VL. LDVL >= 1, and !> if JOBVL = 'V', LDVL >= N. !> |
| [out] | VR | !> VR is REAL array, dimension (LDVR,N) !> If JOBVR = 'V', the right eigenvectors x(j) are stored !> in the columns of VR, in the same order as their eigenvalues. !> If the j-th eigenvalue is real, then x(j) = VR(:,j). !> If the j-th and (j+1)-st eigenvalues form a complex conjugate !> pair, then !> x(j) = VR(:,j) + i*VR(:,j+1) !> and !> x(j+1) = VR(:,j) - i*VR(:,j+1). !> !> Each eigenvector is scaled so that its largest component has !> abs(real part) + abs(imag. part) = 1, except for eigenvalues !> corresponding to an eigenvalue with alpha = beta = 0, which !> are set to zero. !> Not referenced if JOBVR = 'N'. !> |
| [in] | LDVR | !> LDVR is INTEGER !> The leading dimension of the matrix VR. LDVR >= 1, and !> if JOBVR = 'V', LDVR >= N. !> |
| [out] | WORK | !> WORK is REAL array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !> |
| [in] | LWORK | !> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= max(1,8*N). !> For good performance, LWORK must generally be larger. !> To compute the optimal value of LWORK, call ILAENV to get !> blocksizes (for SGEQRF, SORMQR, and SORGQR.) Then compute: !> NB -- MAX of the blocksizes for SGEQRF, SORMQR, and SORGQR; !> The optimal LWORK is: !> 2*N + MAX( 6*N, N*(NB+1) ). !> !> If LWORK = -1, then a workspace query is assumed; the routine !> only calculates the optimal size of the WORK array, returns !> this value as the first entry of the WORK array, and no error !> message related to LWORK is issued by XERBLA. !> |
| [out] | INFO | !> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value. !> = 1,...,N: !> The QZ iteration failed. No eigenvectors have been !> calculated, but ALPHAR(j), ALPHAI(j), and BETA(j) !> should be correct for j=INFO+1,...,N. !> > N: errors that usually indicate LAPACK problems: !> =N+1: error return from SGGBAL !> =N+2: error return from SGEQRF !> =N+3: error return from SORMQR !> =N+4: error return from SORGQR !> =N+5: error return from SGGHRD !> =N+6: error return from SHGEQZ (other than failed !> iteration) !> =N+7: error return from STGEVC !> =N+8: error return from SGGBAK (computing VL) !> =N+9: error return from SGGBAK (computing VR) !> =N+10: error return from SLASCL (various calls) !> |
!> !> Balancing !> --------- !> !> This driver calls SGGBAL to both permute and scale rows and columns !> of A and B. The permutations PL and PR are chosen so that PL*A*PR !> and PL*B*R will be upper triangular except for the diagonal blocks !> A(i:j,i:j) and B(i:j,i:j), with i and j as close together as !> possible. The diagonal scaling matrices DL and DR are chosen so !> that the pair DL*PL*A*PR*DR, DL*PL*B*PR*DR have elements close to !> one (except for the elements that start out zero.) !> !> After the eigenvalues and eigenvectors of the balanced matrices !> have been computed, SGGBAK transforms the eigenvectors back to what !> they would have been (in perfect arithmetic) if they had not been !> balanced. !> !> Contents of A and B on Exit !> -------- -- - --- - -- ---- !> !> If any eigenvectors are computed (either JOBVL='V' or JOBVR='V' or !> both), then on exit the arrays A and B will contain the real Schur !> form[*] of the versions of A and B. If no eigenvectors !> are computed, then only the diagonal blocks will be correct. !> !> [*] See SHGEQZ, SGEGS, or read the book , !> by Golub & van Loan, pub. by Johns Hopkins U. Press. !>
Definition at line 302 of file sgegv.f.
1.11.0 
