Annotation of rpl/lapack/lapack/ztrevc.f, revision 1.1
1.1 ! bertrand 1: SUBROUTINE ZTREVC( SIDE, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR,
! 2: $ LDVR, MM, M, WORK, RWORK, INFO )
! 3: *
! 4: * -- LAPACK routine (version 3.2) --
! 5: * -- LAPACK is a software package provided by Univ. of Tennessee, --
! 6: * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
! 7: * November 2006
! 8: *
! 9: * .. Scalar Arguments ..
! 10: CHARACTER HOWMNY, SIDE
! 11: INTEGER INFO, LDT, LDVL, LDVR, M, MM, N
! 12: * ..
! 13: * .. Array Arguments ..
! 14: LOGICAL SELECT( * )
! 15: DOUBLE PRECISION RWORK( * )
! 16: COMPLEX*16 T( LDT, * ), VL( LDVL, * ), VR( LDVR, * ),
! 17: $ WORK( * )
! 18: * ..
! 19: *
! 20: * Purpose
! 21: * =======
! 22: *
! 23: * ZTREVC computes some or all of the right and/or left eigenvectors of
! 24: * a complex upper triangular matrix T.
! 25: * Matrices of this type are produced by the Schur factorization of
! 26: * a complex general matrix: A = Q*T*Q**H, as computed by ZHSEQR.
! 27: *
! 28: * The right eigenvector x and the left eigenvector y of T corresponding
! 29: * to an eigenvalue w are defined by:
! 30: *
! 31: * T*x = w*x, (y**H)*T = w*(y**H)
! 32: *
! 33: * where y**H denotes the conjugate transpose of the vector y.
! 34: * The eigenvalues are not input to this routine, but are read directly
! 35: * from the diagonal of T.
! 36: *
! 37: * This routine returns the matrices X and/or Y of right and left
! 38: * eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an
! 39: * input matrix. If Q is the unitary factor that reduces a matrix A to
! 40: * Schur form T, then Q*X and Q*Y are the matrices of right and left
! 41: * eigenvectors of A.
! 42: *
! 43: * Arguments
! 44: * =========
! 45: *
! 46: * SIDE (input) CHARACTER*1
! 47: * = 'R': compute right eigenvectors only;
! 48: * = 'L': compute left eigenvectors only;
! 49: * = 'B': compute both right and left eigenvectors.
! 50: *
! 51: * HOWMNY (input) CHARACTER*1
! 52: * = 'A': compute all right and/or left eigenvectors;
! 53: * = 'B': compute all right and/or left eigenvectors,
! 54: * backtransformed using the matrices supplied in
! 55: * VR and/or VL;
! 56: * = 'S': compute selected right and/or left eigenvectors,
! 57: * as indicated by the logical array SELECT.
! 58: *
! 59: * SELECT (input) LOGICAL array, dimension (N)
! 60: * If HOWMNY = 'S', SELECT specifies the eigenvectors to be
! 61: * computed.
! 62: * The eigenvector corresponding to the j-th eigenvalue is
! 63: * computed if SELECT(j) = .TRUE..
! 64: * Not referenced if HOWMNY = 'A' or 'B'.
! 65: *
! 66: * N (input) INTEGER
! 67: * The order of the matrix T. N >= 0.
! 68: *
! 69: * T (input/output) COMPLEX*16 array, dimension (LDT,N)
! 70: * The upper triangular matrix T. T is modified, but restored
! 71: * on exit.
! 72: *
! 73: * LDT (input) INTEGER
! 74: * The leading dimension of the array T. LDT >= max(1,N).
! 75: *
! 76: * VL (input/output) COMPLEX*16 array, dimension (LDVL,MM)
! 77: * On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must
! 78: * contain an N-by-N matrix Q (usually the unitary matrix Q of
! 79: * Schur vectors returned by ZHSEQR).
! 80: * On exit, if SIDE = 'L' or 'B', VL contains:
! 81: * if HOWMNY = 'A', the matrix Y of left eigenvectors of T;
! 82: * if HOWMNY = 'B', the matrix Q*Y;
! 83: * if HOWMNY = 'S', the left eigenvectors of T specified by
! 84: * SELECT, stored consecutively in the columns
! 85: * of VL, in the same order as their
! 86: * eigenvalues.
! 87: * Not referenced if SIDE = 'R'.
! 88: *
! 89: * LDVL (input) INTEGER
! 90: * The leading dimension of the array VL. LDVL >= 1, and if
! 91: * SIDE = 'L' or 'B', LDVL >= N.
! 92: *
! 93: * VR (input/output) COMPLEX*16 array, dimension (LDVR,MM)
! 94: * On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must
! 95: * contain an N-by-N matrix Q (usually the unitary matrix Q of
! 96: * Schur vectors returned by ZHSEQR).
! 97: * On exit, if SIDE = 'R' or 'B', VR contains:
! 98: * if HOWMNY = 'A', the matrix X of right eigenvectors of T;
! 99: * if HOWMNY = 'B', the matrix Q*X;
! 100: * if HOWMNY = 'S', the right eigenvectors of T specified by
! 101: * SELECT, stored consecutively in the columns
! 102: * of VR, in the same order as their
! 103: * eigenvalues.
! 104: * Not referenced if SIDE = 'L'.
! 105: *
! 106: * LDVR (input) INTEGER
! 107: * The leading dimension of the array VR. LDVR >= 1, and if
! 108: * SIDE = 'R' or 'B'; LDVR >= N.
! 109: *
! 110: * MM (input) INTEGER
! 111: * The number of columns in the arrays VL and/or VR. MM >= M.
! 112: *
! 113: * M (output) INTEGER
! 114: * The number of columns in the arrays VL and/or VR actually
! 115: * used to store the eigenvectors. If HOWMNY = 'A' or 'B', M
! 116: * is set to N. Each selected eigenvector occupies one
! 117: * column.
! 118: *
! 119: * WORK (workspace) COMPLEX*16 array, dimension (2*N)
! 120: *
! 121: * RWORK (workspace) DOUBLE PRECISION array, dimension (N)
! 122: *
! 123: * INFO (output) INTEGER
! 124: * = 0: successful exit
! 125: * < 0: if INFO = -i, the i-th argument had an illegal value
! 126: *
! 127: * Further Details
! 128: * ===============
! 129: *
! 130: * The algorithm used in this program is basically backward (forward)
! 131: * substitution, with scaling to make the the code robust against
! 132: * possible overflow.
! 133: *
! 134: * Each eigenvector is normalized so that the element of largest
! 135: * magnitude has magnitude 1; here the magnitude of a complex number
! 136: * (x,y) is taken to be |x| + |y|.
! 137: *
! 138: * =====================================================================
! 139: *
! 140: * .. Parameters ..
! 141: DOUBLE PRECISION ZERO, ONE
! 142: PARAMETER ( ZERO = 0.0D+0, ONE = 1.0D+0 )
! 143: COMPLEX*16 CMZERO, CMONE
! 144: PARAMETER ( CMZERO = ( 0.0D+0, 0.0D+0 ),
! 145: $ CMONE = ( 1.0D+0, 0.0D+0 ) )
! 146: * ..
! 147: * .. Local Scalars ..
! 148: LOGICAL ALLV, BOTHV, LEFTV, OVER, RIGHTV, SOMEV
! 149: INTEGER I, II, IS, J, K, KI
! 150: DOUBLE PRECISION OVFL, REMAX, SCALE, SMIN, SMLNUM, ULP, UNFL
! 151: COMPLEX*16 CDUM
! 152: * ..
! 153: * .. External Functions ..
! 154: LOGICAL LSAME
! 155: INTEGER IZAMAX
! 156: DOUBLE PRECISION DLAMCH, DZASUM
! 157: EXTERNAL LSAME, IZAMAX, DLAMCH, DZASUM
! 158: * ..
! 159: * .. External Subroutines ..
! 160: EXTERNAL XERBLA, ZCOPY, ZDSCAL, ZGEMV, ZLATRS
! 161: * ..
! 162: * .. Intrinsic Functions ..
! 163: INTRINSIC ABS, DBLE, DCMPLX, DCONJG, DIMAG, MAX
! 164: * ..
! 165: * .. Statement Functions ..
! 166: DOUBLE PRECISION CABS1
! 167: * ..
! 168: * .. Statement Function definitions ..
! 169: CABS1( CDUM ) = ABS( DBLE( CDUM ) ) + ABS( DIMAG( CDUM ) )
! 170: * ..
! 171: * .. Executable Statements ..
! 172: *
! 173: * Decode and test the input parameters
! 174: *
! 175: BOTHV = LSAME( SIDE, 'B' )
! 176: RIGHTV = LSAME( SIDE, 'R' ) .OR. BOTHV
! 177: LEFTV = LSAME( SIDE, 'L' ) .OR. BOTHV
! 178: *
! 179: ALLV = LSAME( HOWMNY, 'A' )
! 180: OVER = LSAME( HOWMNY, 'B' )
! 181: SOMEV = LSAME( HOWMNY, 'S' )
! 182: *
! 183: * Set M to the number of columns required to store the selected
! 184: * eigenvectors.
! 185: *
! 186: IF( SOMEV ) THEN
! 187: M = 0
! 188: DO 10 J = 1, N
! 189: IF( SELECT( J ) )
! 190: $ M = M + 1
! 191: 10 CONTINUE
! 192: ELSE
! 193: M = N
! 194: END IF
! 195: *
! 196: INFO = 0
! 197: IF( .NOT.RIGHTV .AND. .NOT.LEFTV ) THEN
! 198: INFO = -1
! 199: ELSE IF( .NOT.ALLV .AND. .NOT.OVER .AND. .NOT.SOMEV ) THEN
! 200: INFO = -2
! 201: ELSE IF( N.LT.0 ) THEN
! 202: INFO = -4
! 203: ELSE IF( LDT.LT.MAX( 1, N ) ) THEN
! 204: INFO = -6
! 205: ELSE IF( LDVL.LT.1 .OR. ( LEFTV .AND. LDVL.LT.N ) ) THEN
! 206: INFO = -8
! 207: ELSE IF( LDVR.LT.1 .OR. ( RIGHTV .AND. LDVR.LT.N ) ) THEN
! 208: INFO = -10
! 209: ELSE IF( MM.LT.M ) THEN
! 210: INFO = -11
! 211: END IF
! 212: IF( INFO.NE.0 ) THEN
! 213: CALL XERBLA( 'ZTREVC', -INFO )
! 214: RETURN
! 215: END IF
! 216: *
! 217: * Quick return if possible.
! 218: *
! 219: IF( N.EQ.0 )
! 220: $ RETURN
! 221: *
! 222: * Set the constants to control overflow.
! 223: *
! 224: UNFL = DLAMCH( 'Safe minimum' )
! 225: OVFL = ONE / UNFL
! 226: CALL DLABAD( UNFL, OVFL )
! 227: ULP = DLAMCH( 'Precision' )
! 228: SMLNUM = UNFL*( N / ULP )
! 229: *
! 230: * Store the diagonal elements of T in working array WORK.
! 231: *
! 232: DO 20 I = 1, N
! 233: WORK( I+N ) = T( I, I )
! 234: 20 CONTINUE
! 235: *
! 236: * Compute 1-norm of each column of strictly upper triangular
! 237: * part of T to control overflow in triangular solver.
! 238: *
! 239: RWORK( 1 ) = ZERO
! 240: DO 30 J = 2, N
! 241: RWORK( J ) = DZASUM( J-1, T( 1, J ), 1 )
! 242: 30 CONTINUE
! 243: *
! 244: IF( RIGHTV ) THEN
! 245: *
! 246: * Compute right eigenvectors.
! 247: *
! 248: IS = M
! 249: DO 80 KI = N, 1, -1
! 250: *
! 251: IF( SOMEV ) THEN
! 252: IF( .NOT.SELECT( KI ) )
! 253: $ GO TO 80
! 254: END IF
! 255: SMIN = MAX( ULP*( CABS1( T( KI, KI ) ) ), SMLNUM )
! 256: *
! 257: WORK( 1 ) = CMONE
! 258: *
! 259: * Form right-hand side.
! 260: *
! 261: DO 40 K = 1, KI - 1
! 262: WORK( K ) = -T( K, KI )
! 263: 40 CONTINUE
! 264: *
! 265: * Solve the triangular system:
! 266: * (T(1:KI-1,1:KI-1) - T(KI,KI))*X = SCALE*WORK.
! 267: *
! 268: DO 50 K = 1, KI - 1
! 269: T( K, K ) = T( K, K ) - T( KI, KI )
! 270: IF( CABS1( T( K, K ) ).LT.SMIN )
! 271: $ T( K, K ) = SMIN
! 272: 50 CONTINUE
! 273: *
! 274: IF( KI.GT.1 ) THEN
! 275: CALL ZLATRS( 'Upper', 'No transpose', 'Non-unit', 'Y',
! 276: $ KI-1, T, LDT, WORK( 1 ), SCALE, RWORK,
! 277: $ INFO )
! 278: WORK( KI ) = SCALE
! 279: END IF
! 280: *
! 281: * Copy the vector x or Q*x to VR and normalize.
! 282: *
! 283: IF( .NOT.OVER ) THEN
! 284: CALL ZCOPY( KI, WORK( 1 ), 1, VR( 1, IS ), 1 )
! 285: *
! 286: II = IZAMAX( KI, VR( 1, IS ), 1 )
! 287: REMAX = ONE / CABS1( VR( II, IS ) )
! 288: CALL ZDSCAL( KI, REMAX, VR( 1, IS ), 1 )
! 289: *
! 290: DO 60 K = KI + 1, N
! 291: VR( K, IS ) = CMZERO
! 292: 60 CONTINUE
! 293: ELSE
! 294: IF( KI.GT.1 )
! 295: $ CALL ZGEMV( 'N', N, KI-1, CMONE, VR, LDVR, WORK( 1 ),
! 296: $ 1, DCMPLX( SCALE ), VR( 1, KI ), 1 )
! 297: *
! 298: II = IZAMAX( N, VR( 1, KI ), 1 )
! 299: REMAX = ONE / CABS1( VR( II, KI ) )
! 300: CALL ZDSCAL( N, REMAX, VR( 1, KI ), 1 )
! 301: END IF
! 302: *
! 303: * Set back the original diagonal elements of T.
! 304: *
! 305: DO 70 K = 1, KI - 1
! 306: T( K, K ) = WORK( K+N )
! 307: 70 CONTINUE
! 308: *
! 309: IS = IS - 1
! 310: 80 CONTINUE
! 311: END IF
! 312: *
! 313: IF( LEFTV ) THEN
! 314: *
! 315: * Compute left eigenvectors.
! 316: *
! 317: IS = 1
! 318: DO 130 KI = 1, N
! 319: *
! 320: IF( SOMEV ) THEN
! 321: IF( .NOT.SELECT( KI ) )
! 322: $ GO TO 130
! 323: END IF
! 324: SMIN = MAX( ULP*( CABS1( T( KI, KI ) ) ), SMLNUM )
! 325: *
! 326: WORK( N ) = CMONE
! 327: *
! 328: * Form right-hand side.
! 329: *
! 330: DO 90 K = KI + 1, N
! 331: WORK( K ) = -DCONJG( T( KI, K ) )
! 332: 90 CONTINUE
! 333: *
! 334: * Solve the triangular system:
! 335: * (T(KI+1:N,KI+1:N) - T(KI,KI))'*X = SCALE*WORK.
! 336: *
! 337: DO 100 K = KI + 1, N
! 338: T( K, K ) = T( K, K ) - T( KI, KI )
! 339: IF( CABS1( T( K, K ) ).LT.SMIN )
! 340: $ T( K, K ) = SMIN
! 341: 100 CONTINUE
! 342: *
! 343: IF( KI.LT.N ) THEN
! 344: CALL ZLATRS( 'Upper', 'Conjugate transpose', 'Non-unit',
! 345: $ 'Y', N-KI, T( KI+1, KI+1 ), LDT,
! 346: $ WORK( KI+1 ), SCALE, RWORK, INFO )
! 347: WORK( KI ) = SCALE
! 348: END IF
! 349: *
! 350: * Copy the vector x or Q*x to VL and normalize.
! 351: *
! 352: IF( .NOT.OVER ) THEN
! 353: CALL ZCOPY( N-KI+1, WORK( KI ), 1, VL( KI, IS ), 1 )
! 354: *
! 355: II = IZAMAX( N-KI+1, VL( KI, IS ), 1 ) + KI - 1
! 356: REMAX = ONE / CABS1( VL( II, IS ) )
! 357: CALL ZDSCAL( N-KI+1, REMAX, VL( KI, IS ), 1 )
! 358: *
! 359: DO 110 K = 1, KI - 1
! 360: VL( K, IS ) = CMZERO
! 361: 110 CONTINUE
! 362: ELSE
! 363: IF( KI.LT.N )
! 364: $ CALL ZGEMV( 'N', N, N-KI, CMONE, VL( 1, KI+1 ), LDVL,
! 365: $ WORK( KI+1 ), 1, DCMPLX( SCALE ),
! 366: $ VL( 1, KI ), 1 )
! 367: *
! 368: II = IZAMAX( N, VL( 1, KI ), 1 )
! 369: REMAX = ONE / CABS1( VL( II, KI ) )
! 370: CALL ZDSCAL( N, REMAX, VL( 1, KI ), 1 )
! 371: END IF
! 372: *
! 373: * Set back the original diagonal elements of T.
! 374: *
! 375: DO 120 K = KI + 1, N
! 376: T( K, K ) = WORK( K+N )
! 377: 120 CONTINUE
! 378: *
! 379: IS = IS + 1
! 380: 130 CONTINUE
! 381: END IF
! 382: *
! 383: RETURN
! 384: *
! 385: * End of ZTREVC
! 386: *
! 387: END
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ztrevc.f CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / lapack / lapack