|
LAPACK 3.3.0
|
|
LAPACK 3.3.0
|
00001 SUBROUTINE ZHBTRD( VECT, UPLO, N, KD, AB, LDAB, D, E, Q, LDQ, 00002 $ WORK, INFO ) 00003 * 00004 * -- LAPACK routine (version 3.2) -- 00005 * -- LAPACK is a software package provided by Univ. of Tennessee, -- 00006 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- 00007 * November 2006 00008 * 00009 * .. Scalar Arguments .. 00010 CHARACTER UPLO, VECT 00011 INTEGER INFO, KD, LDAB, LDQ, N 00012 * .. 00013 * .. Array Arguments .. 00014 DOUBLE PRECISION D( * ), E( * ) 00015 COMPLEX*16 AB( LDAB, * ), Q( LDQ, * ), WORK( * ) 00016 * .. 00017 * 00018 * Purpose 00019 * ======= 00020 * 00021 * ZHBTRD reduces a complex Hermitian band matrix A to real symmetric 00022 * tridiagonal form T by a unitary similarity transformation: 00023 * Q**H * A * Q = T. 00024 * 00025 * Arguments 00026 * ========= 00027 * 00028 * VECT (input) CHARACTER*1 00029 * = 'N': do not form Q; 00030 * = 'V': form Q; 00031 * = 'U': update a matrix X, by forming X*Q. 00032 * 00033 * UPLO (input) CHARACTER*1 00034 * = 'U': Upper triangle of A is stored; 00035 * = 'L': Lower triangle of A is stored. 00036 * 00037 * N (input) INTEGER 00038 * The order of the matrix A. N >= 0. 00039 * 00040 * KD (input) INTEGER 00041 * The number of superdiagonals of the matrix A if UPLO = 'U', 00042 * or the number of subdiagonals if UPLO = 'L'. KD >= 0. 00043 * 00044 * AB (input/output) COMPLEX*16 array, dimension (LDAB,N) 00045 * On entry, the upper or lower triangle of the Hermitian band 00046 * matrix A, stored in the first KD+1 rows of the array. The 00047 * j-th column of A is stored in the j-th column of the array AB 00048 * as follows: 00049 * if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j; 00050 * if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd). 00051 * On exit, the diagonal elements of AB are overwritten by the 00052 * diagonal elements of the tridiagonal matrix T; if KD > 0, the 00053 * elements on the first superdiagonal (if UPLO = 'U') or the 00054 * first subdiagonal (if UPLO = 'L') are overwritten by the 00055 * off-diagonal elements of T; the rest of AB is overwritten by 00056 * values generated during the reduction. 00057 * 00058 * LDAB (input) INTEGER 00059 * The leading dimension of the array AB. LDAB >= KD+1. 00060 * 00061 * D (output) DOUBLE PRECISION array, dimension (N) 00062 * The diagonal elements of the tridiagonal matrix T. 00063 * 00064 * E (output) DOUBLE PRECISION array, dimension (N-1) 00065 * The off-diagonal elements of the tridiagonal matrix T: 00066 * E(i) = T(i,i+1) if UPLO = 'U'; E(i) = T(i+1,i) if UPLO = 'L'. 00067 * 00068 * Q (input/output) COMPLEX*16 array, dimension (LDQ,N) 00069 * On entry, if VECT = 'U', then Q must contain an N-by-N 00070 * matrix X; if VECT = 'N' or 'V', then Q need not be set. 00071 * 00072 * On exit: 00073 * if VECT = 'V', Q contains the N-by-N unitary matrix Q; 00074 * if VECT = 'U', Q contains the product X*Q; 00075 * if VECT = 'N', the array Q is not referenced. 00076 * 00077 * LDQ (input) INTEGER 00078 * The leading dimension of the array Q. 00079 * LDQ >= 1, and LDQ >= N if VECT = 'V' or 'U'. 00080 * 00081 * WORK (workspace) COMPLEX*16 array, dimension (N) 00082 * 00083 * INFO (output) INTEGER 00084 * = 0: successful exit 00085 * < 0: if INFO = -i, the i-th argument had an illegal value 00086 * 00087 * Further Details 00088 * =============== 00089 * 00090 * Modified by Linda Kaufman, Bell Labs. 00091 * 00092 * ===================================================================== 00093 * 00094 * .. Parameters .. 00095 DOUBLE PRECISION ZERO 00096 PARAMETER ( ZERO = 0.0D+0 ) 00097 COMPLEX*16 CZERO, CONE 00098 PARAMETER ( CZERO = ( 0.0D+0, 0.0D+0 ), 00099 $ CONE = ( 1.0D+0, 0.0D+0 ) ) 00100 * .. 00101 * .. Local Scalars .. 00102 LOGICAL INITQ, UPPER, WANTQ 00103 INTEGER I, I2, IBL, INCA, INCX, IQAEND, IQB, IQEND, J, 00104 $ J1, J1END, J1INC, J2, JEND, JIN, JINC, K, KD1, 00105 $ KDM1, KDN, L, LAST, LEND, NQ, NR, NRT 00106 DOUBLE PRECISION ABST 00107 COMPLEX*16 T, TEMP 00108 * .. 00109 * .. External Subroutines .. 00110 EXTERNAL XERBLA, ZLACGV, ZLAR2V, ZLARGV, ZLARTG, ZLARTV, 00111 $ ZLASET, ZROT, ZSCAL 00112 * .. 00113 * .. Intrinsic Functions .. 00114 INTRINSIC ABS, DBLE, DCONJG, MAX, MIN 00115 * .. 00116 * .. External Functions .. 00117 LOGICAL LSAME 00118 EXTERNAL LSAME 00119 * .. 00120 * .. Executable Statements .. 00121 * 00122 * Test the input parameters 00123 * 00124 INITQ = LSAME( VECT, 'V' ) 00125 WANTQ = INITQ .OR. LSAME( VECT, 'U' ) 00126 UPPER = LSAME( UPLO, 'U' ) 00127 KD1 = KD + 1 00128 KDM1 = KD - 1 00129 INCX = LDAB - 1 00130 IQEND = 1 00131 * 00132 INFO = 0 00133 IF( .NOT.WANTQ .AND. .NOT.LSAME( VECT, 'N' ) ) THEN 00134 INFO = -1 00135 ELSE IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN 00136 INFO = -2 00137 ELSE IF( N.LT.0 ) THEN 00138 INFO = -3 00139 ELSE IF( KD.LT.0 ) THEN 00140 INFO = -4 00141 ELSE IF( LDAB.LT.KD1 ) THEN 00142 INFO = -6 00143 ELSE IF( LDQ.LT.MAX( 1, N ) .AND. WANTQ ) THEN 00144 INFO = -10 00145 END IF 00146 IF( INFO.NE.0 ) THEN 00147 CALL XERBLA( 'ZHBTRD', -INFO ) 00148 RETURN 00149 END IF 00150 * 00151 * Quick return if possible 00152 * 00153 IF( N.EQ.0 ) 00154 $ RETURN 00155 * 00156 * Initialize Q to the unit matrix, if needed 00157 * 00158 IF( INITQ ) 00159 $ CALL ZLASET( 'Full', N, N, CZERO, CONE, Q, LDQ ) 00160 * 00161 * Wherever possible, plane rotations are generated and applied in 00162 * vector operations of length NR over the index set J1:J2:KD1. 00163 * 00164 * The real cosines and complex sines of the plane rotations are 00165 * stored in the arrays D and WORK. 00166 * 00167 INCA = KD1*LDAB 00168 KDN = MIN( N-1, KD ) 00169 IF( UPPER ) THEN 00170 * 00171 IF( KD.GT.1 ) THEN 00172 * 00173 * Reduce to complex Hermitian tridiagonal form, working with 00174 * the upper triangle 00175 * 00176 NR = 0 00177 J1 = KDN + 2 00178 J2 = 1 00179 * 00180 AB( KD1, 1 ) = DBLE( AB( KD1, 1 ) ) 00181 DO 90 I = 1, N - 2 00182 * 00183 * Reduce i-th row of matrix to tridiagonal form 00184 * 00185 DO 80 K = KDN + 1, 2, -1 00186 J1 = J1 + KDN 00187 J2 = J2 + KDN 00188 * 00189 IF( NR.GT.0 ) THEN 00190 * 00191 * generate plane rotations to annihilate nonzero 00192 * elements which have been created outside the band 00193 * 00194 CALL ZLARGV( NR, AB( 1, J1-1 ), INCA, WORK( J1 ), 00195 $ KD1, D( J1 ), KD1 ) 00196 * 00197 * apply rotations from the right 00198 * 00199 * 00200 * Dependent on the the number of diagonals either 00201 * ZLARTV or ZROT is used 00202 * 00203 IF( NR.GE.2*KD-1 ) THEN 00204 DO 10 L = 1, KD - 1 00205 CALL ZLARTV( NR, AB( L+1, J1-1 ), INCA, 00206 $ AB( L, J1 ), INCA, D( J1 ), 00207 $ WORK( J1 ), KD1 ) 00208 10 CONTINUE 00209 * 00210 ELSE 00211 JEND = J1 + ( NR-1 )*KD1 00212 DO 20 JINC = J1, JEND, KD1 00213 CALL ZROT( KDM1, AB( 2, JINC-1 ), 1, 00214 $ AB( 1, JINC ), 1, D( JINC ), 00215 $ WORK( JINC ) ) 00216 20 CONTINUE 00217 END IF 00218 END IF 00219 * 00220 * 00221 IF( K.GT.2 ) THEN 00222 IF( K.LE.N-I+1 ) THEN 00223 * 00224 * generate plane rotation to annihilate a(i,i+k-1) 00225 * within the band 00226 * 00227 CALL ZLARTG( AB( KD-K+3, I+K-2 ), 00228 $ AB( KD-K+2, I+K-1 ), D( I+K-1 ), 00229 $ WORK( I+K-1 ), TEMP ) 00230 AB( KD-K+3, I+K-2 ) = TEMP 00231 * 00232 * apply rotation from the right 00233 * 00234 CALL ZROT( K-3, AB( KD-K+4, I+K-2 ), 1, 00235 $ AB( KD-K+3, I+K-1 ), 1, D( I+K-1 ), 00236 $ WORK( I+K-1 ) ) 00237 END IF 00238 NR = NR + 1 00239 J1 = J1 - KDN - 1 00240 END IF 00241 * 00242 * apply plane rotations from both sides to diagonal 00243 * blocks 00244 * 00245 IF( NR.GT.0 ) 00246 $ CALL ZLAR2V( NR, AB( KD1, J1-1 ), AB( KD1, J1 ), 00247 $ AB( KD, J1 ), INCA, D( J1 ), 00248 $ WORK( J1 ), KD1 ) 00249 * 00250 * apply plane rotations from the left 00251 * 00252 IF( NR.GT.0 ) THEN 00253 CALL ZLACGV( NR, WORK( J1 ), KD1 ) 00254 IF( 2*KD-1.LT.NR ) THEN 00255 * 00256 * Dependent on the the number of diagonals either 00257 * ZLARTV or ZROT is used 00258 * 00259 DO 30 L = 1, KD - 1 00260 IF( J2+L.GT.N ) THEN 00261 NRT = NR - 1 00262 ELSE 00263 NRT = NR 00264 END IF 00265 IF( NRT.GT.0 ) 00266 $ CALL ZLARTV( NRT, AB( KD-L, J1+L ), INCA, 00267 $ AB( KD-L+1, J1+L ), INCA, 00268 $ D( J1 ), WORK( J1 ), KD1 ) 00269 30 CONTINUE 00270 ELSE 00271 J1END = J1 + KD1*( NR-2 ) 00272 IF( J1END.GE.J1 ) THEN 00273 DO 40 JIN = J1, J1END, KD1 00274 CALL ZROT( KD-1, AB( KD-1, JIN+1 ), INCX, 00275 $ AB( KD, JIN+1 ), INCX, 00276 $ D( JIN ), WORK( JIN ) ) 00277 40 CONTINUE 00278 END IF 00279 LEND = MIN( KDM1, N-J2 ) 00280 LAST = J1END + KD1 00281 IF( LEND.GT.0 ) 00282 $ CALL ZROT( LEND, AB( KD-1, LAST+1 ), INCX, 00283 $ AB( KD, LAST+1 ), INCX, D( LAST ), 00284 $ WORK( LAST ) ) 00285 END IF 00286 END IF 00287 * 00288 IF( WANTQ ) THEN 00289 * 00290 * accumulate product of plane rotations in Q 00291 * 00292 IF( INITQ ) THEN 00293 * 00294 * take advantage of the fact that Q was 00295 * initially the Identity matrix 00296 * 00297 IQEND = MAX( IQEND, J2 ) 00298 I2 = MAX( 0, K-3 ) 00299 IQAEND = 1 + I*KD 00300 IF( K.EQ.2 ) 00301 $ IQAEND = IQAEND + KD 00302 IQAEND = MIN( IQAEND, IQEND ) 00303 DO 50 J = J1, J2, KD1 00304 IBL = I - I2 / KDM1 00305 I2 = I2 + 1 00306 IQB = MAX( 1, J-IBL ) 00307 NQ = 1 + IQAEND - IQB 00308 IQAEND = MIN( IQAEND+KD, IQEND ) 00309 CALL ZROT( NQ, Q( IQB, J-1 ), 1, Q( IQB, J ), 00310 $ 1, D( J ), DCONJG( WORK( J ) ) ) 00311 50 CONTINUE 00312 ELSE 00313 * 00314 DO 60 J = J1, J2, KD1 00315 CALL ZROT( N, Q( 1, J-1 ), 1, Q( 1, J ), 1, 00316 $ D( J ), DCONJG( WORK( J ) ) ) 00317 60 CONTINUE 00318 END IF 00319 * 00320 END IF 00321 * 00322 IF( J2+KDN.GT.N ) THEN 00323 * 00324 * adjust J2 to keep within the bounds of the matrix 00325 * 00326 NR = NR - 1 00327 J2 = J2 - KDN - 1 00328 END IF 00329 * 00330 DO 70 J = J1, J2, KD1 00331 * 00332 * create nonzero element a(j-1,j+kd) outside the band 00333 * and store it in WORK 00334 * 00335 WORK( J+KD ) = WORK( J )*AB( 1, J+KD ) 00336 AB( 1, J+KD ) = D( J )*AB( 1, J+KD ) 00337 70 CONTINUE 00338 80 CONTINUE 00339 90 CONTINUE 00340 END IF 00341 * 00342 IF( KD.GT.0 ) THEN 00343 * 00344 * make off-diagonal elements real and copy them to E 00345 * 00346 DO 100 I = 1, N - 1 00347 T = AB( KD, I+1 ) 00348 ABST = ABS( T ) 00349 AB( KD, I+1 ) = ABST 00350 E( I ) = ABST 00351 IF( ABST.NE.ZERO ) THEN 00352 T = T / ABST 00353 ELSE 00354 T = CONE 00355 END IF 00356 IF( I.LT.N-1 ) 00357 $ AB( KD, I+2 ) = AB( KD, I+2 )*T 00358 IF( WANTQ ) THEN 00359 CALL ZSCAL( N, DCONJG( T ), Q( 1, I+1 ), 1 ) 00360 END IF 00361 100 CONTINUE 00362 ELSE 00363 * 00364 * set E to zero if original matrix was diagonal 00365 * 00366 DO 110 I = 1, N - 1 00367 E( I ) = ZERO 00368 110 CONTINUE 00369 END IF 00370 * 00371 * copy diagonal elements to D 00372 * 00373 DO 120 I = 1, N 00374 D( I ) = AB( KD1, I ) 00375 120 CONTINUE 00376 * 00377 ELSE 00378 * 00379 IF( KD.GT.1 ) THEN 00380 * 00381 * Reduce to complex Hermitian tridiagonal form, working with 00382 * the lower triangle 00383 * 00384 NR = 0 00385 J1 = KDN + 2 00386 J2 = 1 00387 * 00388 AB( 1, 1 ) = DBLE( AB( 1, 1 ) ) 00389 DO 210 I = 1, N - 2 00390 * 00391 * Reduce i-th column of matrix to tridiagonal form 00392 * 00393 DO 200 K = KDN + 1, 2, -1 00394 J1 = J1 + KDN 00395 J2 = J2 + KDN 00396 * 00397 IF( NR.GT.0 ) THEN 00398 * 00399 * generate plane rotations to annihilate nonzero 00400 * elements which have been created outside the band 00401 * 00402 CALL ZLARGV( NR, AB( KD1, J1-KD1 ), INCA, 00403 $ WORK( J1 ), KD1, D( J1 ), KD1 ) 00404 * 00405 * apply plane rotations from one side 00406 * 00407 * 00408 * Dependent on the the number of diagonals either 00409 * ZLARTV or ZROT is used 00410 * 00411 IF( NR.GT.2*KD-1 ) THEN 00412 DO 130 L = 1, KD - 1 00413 CALL ZLARTV( NR, AB( KD1-L, J1-KD1+L ), INCA, 00414 $ AB( KD1-L+1, J1-KD1+L ), INCA, 00415 $ D( J1 ), WORK( J1 ), KD1 ) 00416 130 CONTINUE 00417 ELSE 00418 JEND = J1 + KD1*( NR-1 ) 00419 DO 140 JINC = J1, JEND, KD1 00420 CALL ZROT( KDM1, AB( KD, JINC-KD ), INCX, 00421 $ AB( KD1, JINC-KD ), INCX, 00422 $ D( JINC ), WORK( JINC ) ) 00423 140 CONTINUE 00424 END IF 00425 * 00426 END IF 00427 * 00428 IF( K.GT.2 ) THEN 00429 IF( K.LE.N-I+1 ) THEN 00430 * 00431 * generate plane rotation to annihilate a(i+k-1,i) 00432 * within the band 00433 * 00434 CALL ZLARTG( AB( K-1, I ), AB( K, I ), 00435 $ D( I+K-1 ), WORK( I+K-1 ), TEMP ) 00436 AB( K-1, I ) = TEMP 00437 * 00438 * apply rotation from the left 00439 * 00440 CALL ZROT( K-3, AB( K-2, I+1 ), LDAB-1, 00441 $ AB( K-1, I+1 ), LDAB-1, D( I+K-1 ), 00442 $ WORK( I+K-1 ) ) 00443 END IF 00444 NR = NR + 1 00445 J1 = J1 - KDN - 1 00446 END IF 00447 * 00448 * apply plane rotations from both sides to diagonal 00449 * blocks 00450 * 00451 IF( NR.GT.0 ) 00452 $ CALL ZLAR2V( NR, AB( 1, J1-1 ), AB( 1, J1 ), 00453 $ AB( 2, J1-1 ), INCA, D( J1 ), 00454 $ WORK( J1 ), KD1 ) 00455 * 00456 * apply plane rotations from the right 00457 * 00458 * 00459 * Dependent on the the number of diagonals either 00460 * ZLARTV or ZROT is used 00461 * 00462 IF( NR.GT.0 ) THEN 00463 CALL ZLACGV( NR, WORK( J1 ), KD1 ) 00464 IF( NR.GT.2*KD-1 ) THEN 00465 DO 150 L = 1, KD - 1 00466 IF( J2+L.GT.N ) THEN 00467 NRT = NR - 1 00468 ELSE 00469 NRT = NR 00470 END IF 00471 IF( NRT.GT.0 ) 00472 $ CALL ZLARTV( NRT, AB( L+2, J1-1 ), INCA, 00473 $ AB( L+1, J1 ), INCA, D( J1 ), 00474 $ WORK( J1 ), KD1 ) 00475 150 CONTINUE 00476 ELSE 00477 J1END = J1 + KD1*( NR-2 ) 00478 IF( J1END.GE.J1 ) THEN 00479 DO 160 J1INC = J1, J1END, KD1 00480 CALL ZROT( KDM1, AB( 3, J1INC-1 ), 1, 00481 $ AB( 2, J1INC ), 1, D( J1INC ), 00482 $ WORK( J1INC ) ) 00483 160 CONTINUE 00484 END IF 00485 LEND = MIN( KDM1, N-J2 ) 00486 LAST = J1END + KD1 00487 IF( LEND.GT.0 ) 00488 $ CALL ZROT( LEND, AB( 3, LAST-1 ), 1, 00489 $ AB( 2, LAST ), 1, D( LAST ), 00490 $ WORK( LAST ) ) 00491 END IF 00492 END IF 00493 * 00494 * 00495 * 00496 IF( WANTQ ) THEN 00497 * 00498 * accumulate product of plane rotations in Q 00499 * 00500 IF( INITQ ) THEN 00501 * 00502 * take advantage of the fact that Q was 00503 * initially the Identity matrix 00504 * 00505 IQEND = MAX( IQEND, J2 ) 00506 I2 = MAX( 0, K-3 ) 00507 IQAEND = 1 + I*KD 00508 IF( K.EQ.2 ) 00509 $ IQAEND = IQAEND + KD 00510 IQAEND = MIN( IQAEND, IQEND ) 00511 DO 170 J = J1, J2, KD1 00512 IBL = I - I2 / KDM1 00513 I2 = I2 + 1 00514 IQB = MAX( 1, J-IBL ) 00515 NQ = 1 + IQAEND - IQB 00516 IQAEND = MIN( IQAEND+KD, IQEND ) 00517 CALL ZROT( NQ, Q( IQB, J-1 ), 1, Q( IQB, J ), 00518 $ 1, D( J ), WORK( J ) ) 00519 170 CONTINUE 00520 ELSE 00521 * 00522 DO 180 J = J1, J2, KD1 00523 CALL ZROT( N, Q( 1, J-1 ), 1, Q( 1, J ), 1, 00524 $ D( J ), WORK( J ) ) 00525 180 CONTINUE 00526 END IF 00527 END IF 00528 * 00529 IF( J2+KDN.GT.N ) THEN 00530 * 00531 * adjust J2 to keep within the bounds of the matrix 00532 * 00533 NR = NR - 1 00534 J2 = J2 - KDN - 1 00535 END IF 00536 * 00537 DO 190 J = J1, J2, KD1 00538 * 00539 * create nonzero element a(j+kd,j-1) outside the 00540 * band and store it in WORK 00541 * 00542 WORK( J+KD ) = WORK( J )*AB( KD1, J ) 00543 AB( KD1, J ) = D( J )*AB( KD1, J ) 00544 190 CONTINUE 00545 200 CONTINUE 00546 210 CONTINUE 00547 END IF 00548 * 00549 IF( KD.GT.0 ) THEN 00550 * 00551 * make off-diagonal elements real and copy them to E 00552 * 00553 DO 220 I = 1, N - 1 00554 T = AB( 2, I ) 00555 ABST = ABS( T ) 00556 AB( 2, I ) = ABST 00557 E( I ) = ABST 00558 IF( ABST.NE.ZERO ) THEN 00559 T = T / ABST 00560 ELSE 00561 T = CONE 00562 END IF 00563 IF( I.LT.N-1 ) 00564 $ AB( 2, I+1 ) = AB( 2, I+1 )*T 00565 IF( WANTQ ) THEN 00566 CALL ZSCAL( N, T, Q( 1, I+1 ), 1 ) 00567 END IF 00568 220 CONTINUE 00569 ELSE 00570 * 00571 * set E to zero if original matrix was diagonal 00572 * 00573 DO 230 I = 1, N - 1 00574 E( I ) = ZERO 00575 230 CONTINUE 00576 END IF 00577 * 00578 * copy diagonal elements to D 00579 * 00580 DO 240 I = 1, N 00581 D( I ) = AB( 1, I ) 00582 240 CONTINUE 00583 END IF 00584 * 00585 RETURN 00586 * 00587 * End of ZHBTRD 00588 * 00589 END
1.7.3 
