sgeevx()

subroutine sgeevx	(	character	balanc,
		character	jobvl,
		character	jobvr,
		character	sense,
		integer	n,
		real, dimension( lda, * )	a,
		integer	lda,
		real, dimension( * )	wr,
		real, dimension( * )	wi,
		real, dimension( ldvl, * )	vl,
		integer	ldvl,
		real, dimension( ldvr, * )	vr,
		integer	ldvr,
		integer	ilo,
		integer	ihi,
		real, dimension( * )	scale,
		real	abnrm,
		real, dimension( * )	rconde,
		real, dimension( * )	rcondv,
		real, dimension( * )	work,
		integer	lwork,
		integer, dimension( * )	iwork,
		integer	info )

SGEEVX computes the eigenvalues and, optionally, the left and/or right eigenvectors for GE matrices

Download SGEEVX + dependencies [TGZ] [ZIP] [TXT]

Purpose:

!>
!> SGEEVX computes for an N-by-N real nonsymmetric matrix A, the
!> eigenvalues and, optionally, the left and/or right eigenvectors.
!>
!> Optionally also, it computes a balancing transformation to improve
!> the conditioning of the eigenvalues and eigenvectors (ILO, IHI,
!> SCALE, and ABNRM), reciprocal condition numbers for the eigenvalues
!> (RCONDE), and reciprocal condition numbers for the right
!> eigenvectors (RCONDV).
!>
!> The right eigenvector v(j) of A satisfies
!>                  A * v(j) = lambda(j) * v(j)
!> where lambda(j) is its eigenvalue.
!> The left eigenvector u(j) of A satisfies
!>               u(j)**H * A = lambda(j) * u(j)**H
!> where u(j)**H denotes the conjugate-transpose of u(j).
!>
!> The computed eigenvectors are normalized to have Euclidean norm
!> equal to 1 and largest component real.
!>
!> Balancing a matrix means permuting the rows and columns to make it
!> more nearly upper triangular, and applying a diagonal similarity
!> transformation D * A * D**(-1), where D is a diagonal matrix, to
!> make its rows and columns closer in norm and the condition numbers
!> of its eigenvalues and eigenvectors smaller.  The computed
!> reciprocal condition numbers correspond to the balanced matrix.
!> Permuting rows and columns will not change the condition numbers
!> (in exact arithmetic) but diagonal scaling will.  For further
!> explanation of balancing, see section 4.10.2 of the LAPACK
!> Users' Guide.
!> 

Parameters

[in]	BALANC	!> BALANC is CHARACTER*1 !> Indicates how the input matrix should be diagonally scaled !> and/or permuted to improve the conditioning of its !> eigenvalues. !> = 'N': Do not diagonally scale or permute; !> = 'P': Perform permutations to make the matrix more nearly !> upper triangular. Do not diagonally scale; !> = 'S': Diagonally scale the matrix, i.e. replace A by !> D*A*D**(-1), where D is a diagonal matrix chosen !> to make the rows and columns of A more equal in !> norm. Do not permute; !> = 'B': Both diagonally scale and permute A. !> !> Computed reciprocal condition numbers will be for the matrix !> after balancing and/or permuting. Permuting does not change !> condition numbers (in exact arithmetic), but balancing does. !>
[in]	JOBVL	!> JOBVL is CHARACTER*1 !> = 'N': left eigenvectors of A are not computed; !> = 'V': left eigenvectors of A are computed. !> If SENSE = 'E' or 'B', JOBVL must = 'V'. !>
[in]	JOBVR	!> JOBVR is CHARACTER*1 !> = 'N': right eigenvectors of A are not computed; !> = 'V': right eigenvectors of A are computed. !> If SENSE = 'E' or 'B', JOBVR must = 'V'. !>
[in]	SENSE	!> SENSE is CHARACTER*1 !> Determines which reciprocal condition numbers are computed. !> = 'N': None are computed; !> = 'E': Computed for eigenvalues only; !> = 'V': Computed for right eigenvectors only; !> = 'B': Computed for eigenvalues and right eigenvectors. !> !> If SENSE = 'E' or 'B', both left and right eigenvectors !> must also be computed (JOBVL = 'V' and JOBVR = 'V'). !>
[in]	N	!> N is INTEGER !> The order of the matrix A. N >= 0. !>
[in,out]	A	!> A is REAL array, dimension (LDA,N) !> On entry, the N-by-N matrix A. !> On exit, A has been overwritten. If JOBVL = 'V' or !> JOBVR = 'V', A contains the real Schur form of the balanced !> version of the input matrix A. !>
[in]	LDA	!> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !>
[out]	WR	!> WR is REAL array, dimension (N) !>
[out]	WI	!> WI is REAL array, dimension (N) !> WR and WI contain the real and imaginary parts, !> respectively, of the computed eigenvalues. Complex !> conjugate pairs of eigenvalues will appear consecutively !> with the eigenvalue having the positive imaginary part !> first. !>
[out]	VL	!> VL is REAL array, dimension (LDVL,N) !> If JOBVL = 'V', the left eigenvectors u(j) are stored one !> after another in the columns of VL, in the same order !> as their eigenvalues. !> If JOBVL = 'N', VL is not referenced. !> If the j-th eigenvalue is real, then u(j) = VL(:,j), !> the j-th column of VL. !> 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). !>
[in]	LDVL	!> LDVL is INTEGER !> The leading dimension of the array VL. LDVL >= 1; if !> JOBVL = 'V', LDVL >= N. !>
[out]	VR	!> VR is REAL array, dimension (LDVR,N) !> If JOBVR = 'V', the right eigenvectors v(j) are stored one !> after another in the columns of VR, in the same order !> as their eigenvalues. !> If JOBVR = 'N', VR is not referenced. !> If the j-th eigenvalue is real, then v(j) = VR(:,j), !> the j-th column of VR. !> If the j-th and (j+1)-st eigenvalues form a complex !> conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and !> v(j+1) = VR(:,j) - i*VR(:,j+1). !>
[in]	LDVR	!> LDVR is INTEGER !> The leading dimension of the array VR. LDVR >= 1, and if !> JOBVR = 'V', LDVR >= N. !>
[out]	ILO	!> ILO is INTEGER !>
[out]	IHI	!> IHI is INTEGER !> ILO and IHI are integer values determined when A was !> balanced. The balanced A(i,j) = 0 if I > J and !> J = 1,...,ILO-1 or I = IHI+1,...,N. !>
[out]	SCALE	!> SCALE is REAL array, dimension (N) !> Details of the permutations and scaling factors applied !> when balancing A. If P(j) is the index of the row and column !> interchanged with row and column j, and D(j) is the scaling !> factor applied to row and column j, then !> SCALE(J) = P(J), for J = 1,...,ILO-1 !> = D(J), for J = ILO,...,IHI !> = P(J) for J = IHI+1,...,N. !> The order in which the interchanges are made is N to IHI+1, !> then 1 to ILO-1. !>
[out]	ABNRM	!> ABNRM is REAL !> The one-norm of the balanced matrix (the maximum !> of the sum of absolute values of elements of any column). !>
[out]	RCONDE	!> RCONDE is REAL array, dimension (N) !> RCONDE(j) is the reciprocal condition number of the j-th !> eigenvalue. !>
[out]	RCONDV	!> RCONDV is REAL array, dimension (N) !> RCONDV(j) is the reciprocal condition number of the j-th !> right eigenvector. !>
[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. If SENSE = 'N' or 'E', !> LWORK >= max(1,2*N), and if JOBVL = 'V' or JOBVR = 'V', !> LWORK >= 3*N. If SENSE = 'V' or 'B', LWORK >= N*(N+6). !> For good performance, LWORK must generally be larger. !> !> 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]	IWORK	!> IWORK is INTEGER array, dimension (2*N-2) !> If SENSE = 'N' or 'E', not referenced. !>
[out]	INFO	!> INFO is INTEGER !> = 0: successful exit !> < 0: if INFO = -i, the i-th argument had an illegal value. !> > 0: if INFO = i, the QR algorithm failed to compute all the !> eigenvalues, and no eigenvectors or condition numbers !> have been computed; elements 1:ILO-1 and i+1:N of WR !> and WI contain eigenvalues which have converged. !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.