 |
LAPACK 3.3.1
Linear Algebra PACKage
|
|
LAPACK 3.3.1
Linear Algebra PACKage
|
00001 SUBROUTINE ZGEESX( JOBVS, SORT, SELECT, SENSE, N, A, LDA, SDIM, W, 00002 $ VS, LDVS, RCONDE, RCONDV, WORK, LWORK, RWORK, 00003 $ BWORK, INFO ) 00004 * 00005 * -- LAPACK driver routine (version 3.2.2) -- 00006 * -- LAPACK is a software package provided by Univ. of Tennessee, -- 00007 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- 00008 * June 2010 00009 * 00010 * .. Scalar Arguments .. 00011 CHARACTER JOBVS, SENSE, SORT 00012 INTEGER INFO, LDA, LDVS, LWORK, N, SDIM 00013 DOUBLE PRECISION RCONDE, RCONDV 00014 * .. 00015 * .. Array Arguments .. 00016 LOGICAL BWORK( * ) 00017 DOUBLE PRECISION RWORK( * ) 00018 COMPLEX*16 A( LDA, * ), VS( LDVS, * ), W( * ), WORK( * ) 00019 * .. 00020 * .. Function Arguments .. 00021 LOGICAL SELECT 00022 EXTERNAL SELECT 00023 * .. 00024 * 00025 * Purpose 00026 * ======= 00027 * 00028 * ZGEESX computes for an N-by-N complex nonsymmetric matrix A, the 00029 * eigenvalues, the Schur form T, and, optionally, the matrix of Schur 00030 * vectors Z. This gives the Schur factorization A = Z*T*(Z**H). 00031 * 00032 * Optionally, it also orders the eigenvalues on the diagonal of the 00033 * Schur form so that selected eigenvalues are at the top left; 00034 * computes a reciprocal condition number for the average of the 00035 * selected eigenvalues (RCONDE); and computes a reciprocal condition 00036 * number for the right invariant subspace corresponding to the 00037 * selected eigenvalues (RCONDV). The leading columns of Z form an 00038 * orthonormal basis for this invariant subspace. 00039 * 00040 * For further explanation of the reciprocal condition numbers RCONDE 00041 * and RCONDV, see Section 4.10 of the LAPACK Users' Guide (where 00042 * these quantities are called s and sep respectively). 00043 * 00044 * A complex matrix is in Schur form if it is upper triangular. 00045 * 00046 * Arguments 00047 * ========= 00048 * 00049 * JOBVS (input) CHARACTER*1 00050 * = 'N': Schur vectors are not computed; 00051 * = 'V': Schur vectors are computed. 00052 * 00053 * SORT (input) CHARACTER*1 00054 * Specifies whether or not to order the eigenvalues on the 00055 * diagonal of the Schur form. 00056 * = 'N': Eigenvalues are not ordered; 00057 * = 'S': Eigenvalues are ordered (see SELECT). 00058 * 00059 * SELECT (external procedure) LOGICAL FUNCTION of one COMPLEX*16 argument 00060 * SELECT must be declared EXTERNAL in the calling subroutine. 00061 * If SORT = 'S', SELECT is used to select eigenvalues to order 00062 * to the top left of the Schur form. 00063 * If SORT = 'N', SELECT is not referenced. 00064 * An eigenvalue W(j) is selected if SELECT(W(j)) is true. 00065 * 00066 * SENSE (input) CHARACTER*1 00067 * Determines which reciprocal condition numbers are computed. 00068 * = 'N': None are computed; 00069 * = 'E': Computed for average of selected eigenvalues only; 00070 * = 'V': Computed for selected right invariant subspace only; 00071 * = 'B': Computed for both. 00072 * If SENSE = 'E', 'V' or 'B', SORT must equal 'S'. 00073 * 00074 * N (input) INTEGER 00075 * The order of the matrix A. N >= 0. 00076 * 00077 * A (input/output) COMPLEX*16 array, dimension (LDA, N) 00078 * On entry, the N-by-N matrix A. 00079 * On exit, A is overwritten by its Schur form T. 00080 * 00081 * LDA (input) INTEGER 00082 * The leading dimension of the array A. LDA >= max(1,N). 00083 * 00084 * SDIM (output) INTEGER 00085 * If SORT = 'N', SDIM = 0. 00086 * If SORT = 'S', SDIM = number of eigenvalues for which 00087 * SELECT is true. 00088 * 00089 * W (output) COMPLEX*16 array, dimension (N) 00090 * W contains the computed eigenvalues, in the same order 00091 * that they appear on the diagonal of the output Schur form T. 00092 * 00093 * VS (output) COMPLEX*16 array, dimension (LDVS,N) 00094 * If JOBVS = 'V', VS contains the unitary matrix Z of Schur 00095 * vectors. 00096 * If JOBVS = 'N', VS is not referenced. 00097 * 00098 * LDVS (input) INTEGER 00099 * The leading dimension of the array VS. LDVS >= 1, and if 00100 * JOBVS = 'V', LDVS >= N. 00101 * 00102 * RCONDE (output) DOUBLE PRECISION 00103 * If SENSE = 'E' or 'B', RCONDE contains the reciprocal 00104 * condition number for the average of the selected eigenvalues. 00105 * Not referenced if SENSE = 'N' or 'V'. 00106 * 00107 * RCONDV (output) DOUBLE PRECISION 00108 * If SENSE = 'V' or 'B', RCONDV contains the reciprocal 00109 * condition number for the selected right invariant subspace. 00110 * Not referenced if SENSE = 'N' or 'E'. 00111 * 00112 * WORK (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) 00113 * On exit, if INFO = 0, WORK(1) returns the optimal LWORK. 00114 * 00115 * LWORK (input) INTEGER 00116 * The dimension of the array WORK. LWORK >= max(1,2*N). 00117 * Also, if SENSE = 'E' or 'V' or 'B', LWORK >= 2*SDIM*(N-SDIM), 00118 * where SDIM is the number of selected eigenvalues computed by 00119 * this routine. Note that 2*SDIM*(N-SDIM) <= N*N/2. Note also 00120 * that an error is only returned if LWORK < max(1,2*N), but if 00121 * SENSE = 'E' or 'V' or 'B' this may not be large enough. 00122 * For good performance, LWORK must generally be larger. 00123 * 00124 * If LWORK = -1, then a workspace query is assumed; the routine 00125 * only calculates upper bound on the optimal size of the 00126 * array WORK, returns this value as the first entry of the WORK 00127 * array, and no error message related to LWORK is issued by 00128 * XERBLA. 00129 * 00130 * RWORK (workspace) DOUBLE PRECISION array, dimension (N) 00131 * 00132 * BWORK (workspace) LOGICAL array, dimension (N) 00133 * Not referenced if SORT = 'N'. 00134 * 00135 * INFO (output) INTEGER 00136 * = 0: successful exit 00137 * < 0: if INFO = -i, the i-th argument had an illegal value. 00138 * > 0: if INFO = i, and i is 00139 * <= N: the QR algorithm failed to compute all the 00140 * eigenvalues; elements 1:ILO-1 and i+1:N of W 00141 * contain those eigenvalues which have converged; if 00142 * JOBVS = 'V', VS contains the transformation which 00143 * reduces A to its partially converged Schur form. 00144 * = N+1: the eigenvalues could not be reordered because some 00145 * eigenvalues were too close to separate (the problem 00146 * is very ill-conditioned); 00147 * = N+2: after reordering, roundoff changed values of some 00148 * complex eigenvalues so that leading eigenvalues in 00149 * the Schur form no longer satisfy SELECT=.TRUE. This 00150 * could also be caused by underflow due to scaling. 00151 * 00152 * ===================================================================== 00153 * 00154 * .. Parameters .. 00155 DOUBLE PRECISION ZERO, ONE 00156 PARAMETER ( ZERO = 0.0D0, ONE = 1.0D0 ) 00157 * .. 00158 * .. Local Scalars .. 00159 LOGICAL LQUERY, SCALEA, WANTSB, WANTSE, WANTSN, WANTST, 00160 $ WANTSV, WANTVS 00161 INTEGER HSWORK, I, IBAL, ICOND, IERR, IEVAL, IHI, ILO, 00162 $ ITAU, IWRK, LWRK, MAXWRK, MINWRK 00163 DOUBLE PRECISION ANRM, BIGNUM, CSCALE, EPS, SMLNUM 00164 * .. 00165 * .. Local Arrays .. 00166 DOUBLE PRECISION DUM( 1 ) 00167 * .. 00168 * .. External Subroutines .. 00169 EXTERNAL DLABAD, DLASCL, XERBLA, ZCOPY, ZGEBAK, ZGEBAL, 00170 $ ZGEHRD, ZHSEQR, ZLACPY, ZLASCL, ZTRSEN, ZUNGHR 00171 * .. 00172 * .. External Functions .. 00173 LOGICAL LSAME 00174 INTEGER ILAENV 00175 DOUBLE PRECISION DLAMCH, ZLANGE 00176 EXTERNAL LSAME, ILAENV, DLAMCH, ZLANGE 00177 * .. 00178 * .. Intrinsic Functions .. 00179 INTRINSIC MAX, SQRT 00180 * .. 00181 * .. Executable Statements .. 00182 * 00183 * Test the input arguments 00184 * 00185 INFO = 0 00186 WANTVS = LSAME( JOBVS, 'V' ) 00187 WANTST = LSAME( SORT, 'S' ) 00188 WANTSN = LSAME( SENSE, 'N' ) 00189 WANTSE = LSAME( SENSE, 'E' ) 00190 WANTSV = LSAME( SENSE, 'V' ) 00191 WANTSB = LSAME( SENSE, 'B' ) 00192 LQUERY = ( LWORK.EQ.-1 ) 00193 * 00194 IF( ( .NOT.WANTVS ) .AND. ( .NOT.LSAME( JOBVS, 'N' ) ) ) THEN 00195 INFO = -1 00196 ELSE IF( ( .NOT.WANTST ) .AND. ( .NOT.LSAME( SORT, 'N' ) ) ) THEN 00197 INFO = -2 00198 ELSE IF( .NOT.( WANTSN .OR. WANTSE .OR. WANTSV .OR. WANTSB ) .OR. 00199 $ ( .NOT.WANTST .AND. .NOT.WANTSN ) ) THEN 00200 INFO = -4 00201 ELSE IF( N.LT.0 ) THEN 00202 INFO = -5 00203 ELSE IF( LDA.LT.MAX( 1, N ) ) THEN 00204 INFO = -7 00205 ELSE IF( LDVS.LT.1 .OR. ( WANTVS .AND. LDVS.LT.N ) ) THEN 00206 INFO = -11 00207 END IF 00208 * 00209 * Compute workspace 00210 * (Note: Comments in the code beginning "Workspace:" describe the 00211 * minimal amount of real workspace needed at that point in the 00212 * code, as well as the preferred amount for good performance. 00213 * CWorkspace refers to complex workspace, and RWorkspace to real 00214 * workspace. NB refers to the optimal block size for the 00215 * immediately following subroutine, as returned by ILAENV. 00216 * HSWORK refers to the workspace preferred by ZHSEQR, as 00217 * calculated below. HSWORK is computed assuming ILO=1 and IHI=N, 00218 * the worst case. 00219 * If SENSE = 'E', 'V' or 'B', then the amount of workspace needed 00220 * depends on SDIM, which is computed by the routine ZTRSEN later 00221 * in the code.) 00222 * 00223 IF( INFO.EQ.0 ) THEN 00224 IF( N.EQ.0 ) THEN 00225 MINWRK = 1 00226 LWRK = 1 00227 ELSE 00228 MAXWRK = N + N*ILAENV( 1, 'ZGEHRD', ' ', N, 1, N, 0 ) 00229 MINWRK = 2*N 00230 * 00231 CALL ZHSEQR( 'S', JOBVS, N, 1, N, A, LDA, W, VS, LDVS, 00232 $ WORK, -1, IEVAL ) 00233 HSWORK = WORK( 1 ) 00234 * 00235 IF( .NOT.WANTVS ) THEN 00236 MAXWRK = MAX( MAXWRK, HSWORK ) 00237 ELSE 00238 MAXWRK = MAX( MAXWRK, N + ( N - 1 )*ILAENV( 1, 'ZUNGHR', 00239 $ ' ', N, 1, N, -1 ) ) 00240 MAXWRK = MAX( MAXWRK, HSWORK ) 00241 END IF 00242 LWRK = MAXWRK 00243 IF( .NOT.WANTSN ) 00244 $ LWRK = MAX( LWRK, ( N*N )/2 ) 00245 END IF 00246 WORK( 1 ) = LWRK 00247 * 00248 IF( LWORK.LT.MINWRK .AND. .NOT.LQUERY ) THEN 00249 INFO = -15 00250 END IF 00251 END IF 00252 * 00253 IF( INFO.NE.0 ) THEN 00254 CALL XERBLA( 'ZGEESX', -INFO ) 00255 RETURN 00256 ELSE IF( LQUERY ) THEN 00257 RETURN 00258 END IF 00259 * 00260 * Quick return if possible 00261 * 00262 IF( N.EQ.0 ) THEN 00263 SDIM = 0 00264 RETURN 00265 END IF 00266 * 00267 * Get machine constants 00268 * 00269 EPS = DLAMCH( 'P' ) 00270 SMLNUM = DLAMCH( 'S' ) 00271 BIGNUM = ONE / SMLNUM 00272 CALL DLABAD( SMLNUM, BIGNUM ) 00273 SMLNUM = SQRT( SMLNUM ) / EPS 00274 BIGNUM = ONE / SMLNUM 00275 * 00276 * Scale A if max element outside range [SMLNUM,BIGNUM] 00277 * 00278 ANRM = ZLANGE( 'M', N, N, A, LDA, DUM ) 00279 SCALEA = .FALSE. 00280 IF( ANRM.GT.ZERO .AND. ANRM.LT.SMLNUM ) THEN 00281 SCALEA = .TRUE. 00282 CSCALE = SMLNUM 00283 ELSE IF( ANRM.GT.BIGNUM ) THEN 00284 SCALEA = .TRUE. 00285 CSCALE = BIGNUM 00286 END IF 00287 IF( SCALEA ) 00288 $ CALL ZLASCL( 'G', 0, 0, ANRM, CSCALE, N, N, A, LDA, IERR ) 00289 * 00290 * 00291 * Permute the matrix to make it more nearly triangular 00292 * (CWorkspace: none) 00293 * (RWorkspace: need N) 00294 * 00295 IBAL = 1 00296 CALL ZGEBAL( 'P', N, A, LDA, ILO, IHI, RWORK( IBAL ), IERR ) 00297 * 00298 * Reduce to upper Hessenberg form 00299 * (CWorkspace: need 2*N, prefer N+N*NB) 00300 * (RWorkspace: none) 00301 * 00302 ITAU = 1 00303 IWRK = N + ITAU 00304 CALL ZGEHRD( N, ILO, IHI, A, LDA, WORK( ITAU ), WORK( IWRK ), 00305 $ LWORK-IWRK+1, IERR ) 00306 * 00307 IF( WANTVS ) THEN 00308 * 00309 * Copy Householder vectors to VS 00310 * 00311 CALL ZLACPY( 'L', N, N, A, LDA, VS, LDVS ) 00312 * 00313 * Generate unitary matrix in VS 00314 * (CWorkspace: need 2*N-1, prefer N+(N-1)*NB) 00315 * (RWorkspace: none) 00316 * 00317 CALL ZUNGHR( N, ILO, IHI, VS, LDVS, WORK( ITAU ), WORK( IWRK ), 00318 $ LWORK-IWRK+1, IERR ) 00319 END IF 00320 * 00321 SDIM = 0 00322 * 00323 * Perform QR iteration, accumulating Schur vectors in VS if desired 00324 * (CWorkspace: need 1, prefer HSWORK (see comments) ) 00325 * (RWorkspace: none) 00326 * 00327 IWRK = ITAU 00328 CALL ZHSEQR( 'S', JOBVS, N, ILO, IHI, A, LDA, W, VS, LDVS, 00329 $ WORK( IWRK ), LWORK-IWRK+1, IEVAL ) 00330 IF( IEVAL.GT.0 ) 00331 $ INFO = IEVAL 00332 * 00333 * Sort eigenvalues if desired 00334 * 00335 IF( WANTST .AND. INFO.EQ.0 ) THEN 00336 IF( SCALEA ) 00337 $ CALL ZLASCL( 'G', 0, 0, CSCALE, ANRM, N, 1, W, N, IERR ) 00338 DO 10 I = 1, N 00339 BWORK( I ) = SELECT( W( I ) ) 00340 10 CONTINUE 00341 * 00342 * Reorder eigenvalues, transform Schur vectors, and compute 00343 * reciprocal condition numbers 00344 * (CWorkspace: if SENSE is not 'N', need 2*SDIM*(N-SDIM) 00345 * otherwise, need none ) 00346 * (RWorkspace: none) 00347 * 00348 CALL ZTRSEN( SENSE, JOBVS, BWORK, N, A, LDA, VS, LDVS, W, SDIM, 00349 $ RCONDE, RCONDV, WORK( IWRK ), LWORK-IWRK+1, 00350 $ ICOND ) 00351 IF( .NOT.WANTSN ) 00352 $ MAXWRK = MAX( MAXWRK, 2*SDIM*( N-SDIM ) ) 00353 IF( ICOND.EQ.-14 ) THEN 00354 * 00355 * Not enough complex workspace 00356 * 00357 INFO = -15 00358 END IF 00359 END IF 00360 * 00361 IF( WANTVS ) THEN 00362 * 00363 * Undo balancing 00364 * (CWorkspace: none) 00365 * (RWorkspace: need N) 00366 * 00367 CALL ZGEBAK( 'P', 'R', N, ILO, IHI, RWORK( IBAL ), N, VS, LDVS, 00368 $ IERR ) 00369 END IF 00370 * 00371 IF( SCALEA ) THEN 00372 * 00373 * Undo scaling for the Schur form of A 00374 * 00375 CALL ZLASCL( 'U', 0, 0, CSCALE, ANRM, N, N, A, LDA, IERR ) 00376 CALL ZCOPY( N, A, LDA+1, W, 1 ) 00377 IF( ( WANTSV .OR. WANTSB ) .AND. INFO.EQ.0 ) THEN 00378 DUM( 1 ) = RCONDV 00379 CALL DLASCL( 'G', 0, 0, CSCALE, ANRM, 1, 1, DUM, 1, IERR ) 00380 RCONDV = DUM( 1 ) 00381 END IF 00382 END IF 00383 * 00384 WORK( 1 ) = MAXWRK 00385 RETURN 00386 * 00387 * End of ZGEESX 00388 * 00389 END
1.7.3 
