 |
LAPACK 3.3.1
Linear Algebra PACKage
|
|
LAPACK 3.3.1
Linear Algebra PACKage
|
00001 SUBROUTINE SBDSQR( UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, 00002 $ LDU, C, LDC, 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 * January 2007 00008 * 00009 * .. Scalar Arguments .. 00010 CHARACTER UPLO 00011 INTEGER INFO, LDC, LDU, LDVT, N, NCC, NCVT, NRU 00012 * .. 00013 * .. Array Arguments .. 00014 REAL C( LDC, * ), D( * ), E( * ), U( LDU, * ), 00015 $ VT( LDVT, * ), WORK( * ) 00016 * .. 00017 * 00018 * Purpose 00019 * ======= 00020 * 00021 * SBDSQR computes the singular values and, optionally, the right and/or 00022 * left singular vectors from the singular value decomposition (SVD) of 00023 * a real N-by-N (upper or lower) bidiagonal matrix B using the implicit 00024 * zero-shift QR algorithm. The SVD of B has the form 00025 * 00026 * B = Q * S * P**T 00027 * 00028 * where S is the diagonal matrix of singular values, Q is an orthogonal 00029 * matrix of left singular vectors, and P is an orthogonal matrix of 00030 * right singular vectors. If left singular vectors are requested, this 00031 * subroutine actually returns U*Q instead of Q, and, if right singular 00032 * vectors are requested, this subroutine returns P**T*VT instead of 00033 * P**T, for given real input matrices U and VT. When U and VT are the 00034 * orthogonal matrices that reduce a general matrix A to bidiagonal 00035 * form: A = U*B*VT, as computed by SGEBRD, then 00036 * 00037 * A = (U*Q) * S * (P**T*VT) 00038 * 00039 * is the SVD of A. Optionally, the subroutine may also compute Q**T*C 00040 * for a given real input matrix C. 00041 * 00042 * See "Computing Small Singular Values of Bidiagonal Matrices With 00043 * Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, 00044 * LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, 00045 * no. 5, pp. 873-912, Sept 1990) and 00046 * "Accurate singular values and differential qd algorithms," by 00047 * B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics 00048 * Department, University of California at Berkeley, July 1992 00049 * for a detailed description of the algorithm. 00050 * 00051 * Arguments 00052 * ========= 00053 * 00054 * UPLO (input) CHARACTER*1 00055 * = 'U': B is upper bidiagonal; 00056 * = 'L': B is lower bidiagonal. 00057 * 00058 * N (input) INTEGER 00059 * The order of the matrix B. N >= 0. 00060 * 00061 * NCVT (input) INTEGER 00062 * The number of columns of the matrix VT. NCVT >= 0. 00063 * 00064 * NRU (input) INTEGER 00065 * The number of rows of the matrix U. NRU >= 0. 00066 * 00067 * NCC (input) INTEGER 00068 * The number of columns of the matrix C. NCC >= 0. 00069 * 00070 * D (input/output) REAL array, dimension (N) 00071 * On entry, the n diagonal elements of the bidiagonal matrix B. 00072 * On exit, if INFO=0, the singular values of B in decreasing 00073 * order. 00074 * 00075 * E (input/output) REAL array, dimension (N-1) 00076 * On entry, the N-1 offdiagonal elements of the bidiagonal 00077 * matrix B. 00078 * On exit, if INFO = 0, E is destroyed; if INFO > 0, D and E 00079 * will contain the diagonal and superdiagonal elements of a 00080 * bidiagonal matrix orthogonally equivalent to the one given 00081 * as input. 00082 * 00083 * VT (input/output) REAL array, dimension (LDVT, NCVT) 00084 * On entry, an N-by-NCVT matrix VT. 00085 * On exit, VT is overwritten by P**T * VT. 00086 * Not referenced if NCVT = 0. 00087 * 00088 * LDVT (input) INTEGER 00089 * The leading dimension of the array VT. 00090 * LDVT >= max(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0. 00091 * 00092 * U (input/output) REAL array, dimension (LDU, N) 00093 * On entry, an NRU-by-N matrix U. 00094 * On exit, U is overwritten by U * Q. 00095 * Not referenced if NRU = 0. 00096 * 00097 * LDU (input) INTEGER 00098 * The leading dimension of the array U. LDU >= max(1,NRU). 00099 * 00100 * C (input/output) REAL array, dimension (LDC, NCC) 00101 * On entry, an N-by-NCC matrix C. 00102 * On exit, C is overwritten by Q**T * C. 00103 * Not referenced if NCC = 0. 00104 * 00105 * LDC (input) INTEGER 00106 * The leading dimension of the array C. 00107 * LDC >= max(1,N) if NCC > 0; LDC >=1 if NCC = 0. 00108 * 00109 * WORK (workspace) REAL array, dimension (4*N) 00110 * 00111 * INFO (output) INTEGER 00112 * = 0: successful exit 00113 * < 0: If INFO = -i, the i-th argument had an illegal value 00114 * > 0: 00115 * if NCVT = NRU = NCC = 0, 00116 * = 1, a split was marked by a positive value in E 00117 * = 2, current block of Z not diagonalized after 30*N 00118 * iterations (in inner while loop) 00119 * = 3, termination criterion of outer while loop not met 00120 * (program created more than N unreduced blocks) 00121 * else NCVT = NRU = NCC = 0, 00122 * the algorithm did not converge; D and E contain the 00123 * elements of a bidiagonal matrix which is orthogonally 00124 * similar to the input matrix B; if INFO = i, i 00125 * elements of E have not converged to zero. 00126 * 00127 * Internal Parameters 00128 * =================== 00129 * 00130 * TOLMUL REAL, default = max(10,min(100,EPS**(-1/8))) 00131 * TOLMUL controls the convergence criterion of the QR loop. 00132 * If it is positive, TOLMUL*EPS is the desired relative 00133 * precision in the computed singular values. 00134 * If it is negative, abs(TOLMUL*EPS*sigma_max) is the 00135 * desired absolute accuracy in the computed singular 00136 * values (corresponds to relative accuracy 00137 * abs(TOLMUL*EPS) in the largest singular value. 00138 * abs(TOLMUL) should be between 1 and 1/EPS, and preferably 00139 * between 10 (for fast convergence) and .1/EPS 00140 * (for there to be some accuracy in the results). 00141 * Default is to lose at either one eighth or 2 of the 00142 * available decimal digits in each computed singular value 00143 * (whichever is smaller). 00144 * 00145 * MAXITR INTEGER, default = 6 00146 * MAXITR controls the maximum number of passes of the 00147 * algorithm through its inner loop. The algorithms stops 00148 * (and so fails to converge) if the number of passes 00149 * through the inner loop exceeds MAXITR*N**2. 00150 * 00151 * ===================================================================== 00152 * 00153 * .. Parameters .. 00154 REAL ZERO 00155 PARAMETER ( ZERO = 0.0E0 ) 00156 REAL ONE 00157 PARAMETER ( ONE = 1.0E0 ) 00158 REAL NEGONE 00159 PARAMETER ( NEGONE = -1.0E0 ) 00160 REAL HNDRTH 00161 PARAMETER ( HNDRTH = 0.01E0 ) 00162 REAL TEN 00163 PARAMETER ( TEN = 10.0E0 ) 00164 REAL HNDRD 00165 PARAMETER ( HNDRD = 100.0E0 ) 00166 REAL MEIGTH 00167 PARAMETER ( MEIGTH = -0.125E0 ) 00168 INTEGER MAXITR 00169 PARAMETER ( MAXITR = 6 ) 00170 * .. 00171 * .. Local Scalars .. 00172 LOGICAL LOWER, ROTATE 00173 INTEGER I, IDIR, ISUB, ITER, J, LL, LLL, M, MAXIT, NM1, 00174 $ NM12, NM13, OLDLL, OLDM 00175 REAL ABSE, ABSS, COSL, COSR, CS, EPS, F, G, H, MU, 00176 $ OLDCS, OLDSN, R, SHIFT, SIGMN, SIGMX, SINL, 00177 $ SINR, SLL, SMAX, SMIN, SMINL, SMINOA, 00178 $ SN, THRESH, TOL, TOLMUL, UNFL 00179 * .. 00180 * .. External Functions .. 00181 LOGICAL LSAME 00182 REAL SLAMCH 00183 EXTERNAL LSAME, SLAMCH 00184 * .. 00185 * .. External Subroutines .. 00186 EXTERNAL SLARTG, SLAS2, SLASQ1, SLASR, SLASV2, SROT, 00187 $ SSCAL, SSWAP, XERBLA 00188 * .. 00189 * .. Intrinsic Functions .. 00190 INTRINSIC ABS, MAX, MIN, REAL, SIGN, SQRT 00191 * .. 00192 * .. Executable Statements .. 00193 * 00194 * Test the input parameters. 00195 * 00196 INFO = 0 00197 LOWER = LSAME( UPLO, 'L' ) 00198 IF( .NOT.LSAME( UPLO, 'U' ) .AND. .NOT.LOWER ) THEN 00199 INFO = -1 00200 ELSE IF( N.LT.0 ) THEN 00201 INFO = -2 00202 ELSE IF( NCVT.LT.0 ) THEN 00203 INFO = -3 00204 ELSE IF( NRU.LT.0 ) THEN 00205 INFO = -4 00206 ELSE IF( NCC.LT.0 ) THEN 00207 INFO = -5 00208 ELSE IF( ( NCVT.EQ.0 .AND. LDVT.LT.1 ) .OR. 00209 $ ( NCVT.GT.0 .AND. LDVT.LT.MAX( 1, N ) ) ) THEN 00210 INFO = -9 00211 ELSE IF( LDU.LT.MAX( 1, NRU ) ) THEN 00212 INFO = -11 00213 ELSE IF( ( NCC.EQ.0 .AND. LDC.LT.1 ) .OR. 00214 $ ( NCC.GT.0 .AND. LDC.LT.MAX( 1, N ) ) ) THEN 00215 INFO = -13 00216 END IF 00217 IF( INFO.NE.0 ) THEN 00218 CALL XERBLA( 'SBDSQR', -INFO ) 00219 RETURN 00220 END IF 00221 IF( N.EQ.0 ) 00222 $ RETURN 00223 IF( N.EQ.1 ) 00224 $ GO TO 160 00225 * 00226 * ROTATE is true if any singular vectors desired, false otherwise 00227 * 00228 ROTATE = ( NCVT.GT.0 ) .OR. ( NRU.GT.0 ) .OR. ( NCC.GT.0 ) 00229 * 00230 * If no singular vectors desired, use qd algorithm 00231 * 00232 IF( .NOT.ROTATE ) THEN 00233 CALL SLASQ1( N, D, E, WORK, INFO ) 00234 RETURN 00235 END IF 00236 * 00237 NM1 = N - 1 00238 NM12 = NM1 + NM1 00239 NM13 = NM12 + NM1 00240 IDIR = 0 00241 * 00242 * Get machine constants 00243 * 00244 EPS = SLAMCH( 'Epsilon' ) 00245 UNFL = SLAMCH( 'Safe minimum' ) 00246 * 00247 * If matrix lower bidiagonal, rotate to be upper bidiagonal 00248 * by applying Givens rotations on the left 00249 * 00250 IF( LOWER ) THEN 00251 DO 10 I = 1, N - 1 00252 CALL SLARTG( D( I ), E( I ), CS, SN, R ) 00253 D( I ) = R 00254 E( I ) = SN*D( I+1 ) 00255 D( I+1 ) = CS*D( I+1 ) 00256 WORK( I ) = CS 00257 WORK( NM1+I ) = SN 00258 10 CONTINUE 00259 * 00260 * Update singular vectors if desired 00261 * 00262 IF( NRU.GT.0 ) 00263 $ CALL SLASR( 'R', 'V', 'F', NRU, N, WORK( 1 ), WORK( N ), U, 00264 $ LDU ) 00265 IF( NCC.GT.0 ) 00266 $ CALL SLASR( 'L', 'V', 'F', N, NCC, WORK( 1 ), WORK( N ), C, 00267 $ LDC ) 00268 END IF 00269 * 00270 * Compute singular values to relative accuracy TOL 00271 * (By setting TOL to be negative, algorithm will compute 00272 * singular values to absolute accuracy ABS(TOL)*norm(input matrix)) 00273 * 00274 TOLMUL = MAX( TEN, MIN( HNDRD, EPS**MEIGTH ) ) 00275 TOL = TOLMUL*EPS 00276 * 00277 * Compute approximate maximum, minimum singular values 00278 * 00279 SMAX = ZERO 00280 DO 20 I = 1, N 00281 SMAX = MAX( SMAX, ABS( D( I ) ) ) 00282 20 CONTINUE 00283 DO 30 I = 1, N - 1 00284 SMAX = MAX( SMAX, ABS( E( I ) ) ) 00285 30 CONTINUE 00286 SMINL = ZERO 00287 IF( TOL.GE.ZERO ) THEN 00288 * 00289 * Relative accuracy desired 00290 * 00291 SMINOA = ABS( D( 1 ) ) 00292 IF( SMINOA.EQ.ZERO ) 00293 $ GO TO 50 00294 MU = SMINOA 00295 DO 40 I = 2, N 00296 MU = ABS( D( I ) )*( MU / ( MU+ABS( E( I-1 ) ) ) ) 00297 SMINOA = MIN( SMINOA, MU ) 00298 IF( SMINOA.EQ.ZERO ) 00299 $ GO TO 50 00300 40 CONTINUE 00301 50 CONTINUE 00302 SMINOA = SMINOA / SQRT( REAL( N ) ) 00303 THRESH = MAX( TOL*SMINOA, MAXITR*N*N*UNFL ) 00304 ELSE 00305 * 00306 * Absolute accuracy desired 00307 * 00308 THRESH = MAX( ABS( TOL )*SMAX, MAXITR*N*N*UNFL ) 00309 END IF 00310 * 00311 * Prepare for main iteration loop for the singular values 00312 * (MAXIT is the maximum number of passes through the inner 00313 * loop permitted before nonconvergence signalled.) 00314 * 00315 MAXIT = MAXITR*N*N 00316 ITER = 0 00317 OLDLL = -1 00318 OLDM = -1 00319 * 00320 * M points to last element of unconverged part of matrix 00321 * 00322 M = N 00323 * 00324 * Begin main iteration loop 00325 * 00326 60 CONTINUE 00327 * 00328 * Check for convergence or exceeding iteration count 00329 * 00330 IF( M.LE.1 ) 00331 $ GO TO 160 00332 IF( ITER.GT.MAXIT ) 00333 $ GO TO 200 00334 * 00335 * Find diagonal block of matrix to work on 00336 * 00337 IF( TOL.LT.ZERO .AND. ABS( D( M ) ).LE.THRESH ) 00338 $ D( M ) = ZERO 00339 SMAX = ABS( D( M ) ) 00340 SMIN = SMAX 00341 DO 70 LLL = 1, M - 1 00342 LL = M - LLL 00343 ABSS = ABS( D( LL ) ) 00344 ABSE = ABS( E( LL ) ) 00345 IF( TOL.LT.ZERO .AND. ABSS.LE.THRESH ) 00346 $ D( LL ) = ZERO 00347 IF( ABSE.LE.THRESH ) 00348 $ GO TO 80 00349 SMIN = MIN( SMIN, ABSS ) 00350 SMAX = MAX( SMAX, ABSS, ABSE ) 00351 70 CONTINUE 00352 LL = 0 00353 GO TO 90 00354 80 CONTINUE 00355 E( LL ) = ZERO 00356 * 00357 * Matrix splits since E(LL) = 0 00358 * 00359 IF( LL.EQ.M-1 ) THEN 00360 * 00361 * Convergence of bottom singular value, return to top of loop 00362 * 00363 M = M - 1 00364 GO TO 60 00365 END IF 00366 90 CONTINUE 00367 LL = LL + 1 00368 * 00369 * E(LL) through E(M-1) are nonzero, E(LL-1) is zero 00370 * 00371 IF( LL.EQ.M-1 ) THEN 00372 * 00373 * 2 by 2 block, handle separately 00374 * 00375 CALL SLASV2( D( M-1 ), E( M-1 ), D( M ), SIGMN, SIGMX, SINR, 00376 $ COSR, SINL, COSL ) 00377 D( M-1 ) = SIGMX 00378 E( M-1 ) = ZERO 00379 D( M ) = SIGMN 00380 * 00381 * Compute singular vectors, if desired 00382 * 00383 IF( NCVT.GT.0 ) 00384 $ CALL SROT( NCVT, VT( M-1, 1 ), LDVT, VT( M, 1 ), LDVT, COSR, 00385 $ SINR ) 00386 IF( NRU.GT.0 ) 00387 $ CALL SROT( NRU, U( 1, M-1 ), 1, U( 1, M ), 1, COSL, SINL ) 00388 IF( NCC.GT.0 ) 00389 $ CALL SROT( NCC, C( M-1, 1 ), LDC, C( M, 1 ), LDC, COSL, 00390 $ SINL ) 00391 M = M - 2 00392 GO TO 60 00393 END IF 00394 * 00395 * If working on new submatrix, choose shift direction 00396 * (from larger end diagonal element towards smaller) 00397 * 00398 IF( LL.GT.OLDM .OR. M.LT.OLDLL ) THEN 00399 IF( ABS( D( LL ) ).GE.ABS( D( M ) ) ) THEN 00400 * 00401 * Chase bulge from top (big end) to bottom (small end) 00402 * 00403 IDIR = 1 00404 ELSE 00405 * 00406 * Chase bulge from bottom (big end) to top (small end) 00407 * 00408 IDIR = 2 00409 END IF 00410 END IF 00411 * 00412 * Apply convergence tests 00413 * 00414 IF( IDIR.EQ.1 ) THEN 00415 * 00416 * Run convergence test in forward direction 00417 * First apply standard test to bottom of matrix 00418 * 00419 IF( ABS( E( M-1 ) ).LE.ABS( TOL )*ABS( D( M ) ) .OR. 00420 $ ( TOL.LT.ZERO .AND. ABS( E( M-1 ) ).LE.THRESH ) ) THEN 00421 E( M-1 ) = ZERO 00422 GO TO 60 00423 END IF 00424 * 00425 IF( TOL.GE.ZERO ) THEN 00426 * 00427 * If relative accuracy desired, 00428 * apply convergence criterion forward 00429 * 00430 MU = ABS( D( LL ) ) 00431 SMINL = MU 00432 DO 100 LLL = LL, M - 1 00433 IF( ABS( E( LLL ) ).LE.TOL*MU ) THEN 00434 E( LLL ) = ZERO 00435 GO TO 60 00436 END IF 00437 MU = ABS( D( LLL+1 ) )*( MU / ( MU+ABS( E( LLL ) ) ) ) 00438 SMINL = MIN( SMINL, MU ) 00439 100 CONTINUE 00440 END IF 00441 * 00442 ELSE 00443 * 00444 * Run convergence test in backward direction 00445 * First apply standard test to top of matrix 00446 * 00447 IF( ABS( E( LL ) ).LE.ABS( TOL )*ABS( D( LL ) ) .OR. 00448 $ ( TOL.LT.ZERO .AND. ABS( E( LL ) ).LE.THRESH ) ) THEN 00449 E( LL ) = ZERO 00450 GO TO 60 00451 END IF 00452 * 00453 IF( TOL.GE.ZERO ) THEN 00454 * 00455 * If relative accuracy desired, 00456 * apply convergence criterion backward 00457 * 00458 MU = ABS( D( M ) ) 00459 SMINL = MU 00460 DO 110 LLL = M - 1, LL, -1 00461 IF( ABS( E( LLL ) ).LE.TOL*MU ) THEN 00462 E( LLL ) = ZERO 00463 GO TO 60 00464 END IF 00465 MU = ABS( D( LLL ) )*( MU / ( MU+ABS( E( LLL ) ) ) ) 00466 SMINL = MIN( SMINL, MU ) 00467 110 CONTINUE 00468 END IF 00469 END IF 00470 OLDLL = LL 00471 OLDM = M 00472 * 00473 * Compute shift. First, test if shifting would ruin relative 00474 * accuracy, and if so set the shift to zero. 00475 * 00476 IF( TOL.GE.ZERO .AND. N*TOL*( SMINL / SMAX ).LE. 00477 $ MAX( EPS, HNDRTH*TOL ) ) THEN 00478 * 00479 * Use a zero shift to avoid loss of relative accuracy 00480 * 00481 SHIFT = ZERO 00482 ELSE 00483 * 00484 * Compute the shift from 2-by-2 block at end of matrix 00485 * 00486 IF( IDIR.EQ.1 ) THEN 00487 SLL = ABS( D( LL ) ) 00488 CALL SLAS2( D( M-1 ), E( M-1 ), D( M ), SHIFT, R ) 00489 ELSE 00490 SLL = ABS( D( M ) ) 00491 CALL SLAS2( D( LL ), E( LL ), D( LL+1 ), SHIFT, R ) 00492 END IF 00493 * 00494 * Test if shift negligible, and if so set to zero 00495 * 00496 IF( SLL.GT.ZERO ) THEN 00497 IF( ( SHIFT / SLL )**2.LT.EPS ) 00498 $ SHIFT = ZERO 00499 END IF 00500 END IF 00501 * 00502 * Increment iteration count 00503 * 00504 ITER = ITER + M - LL 00505 * 00506 * If SHIFT = 0, do simplified QR iteration 00507 * 00508 IF( SHIFT.EQ.ZERO ) THEN 00509 IF( IDIR.EQ.1 ) THEN 00510 * 00511 * Chase bulge from top to bottom 00512 * Save cosines and sines for later singular vector updates 00513 * 00514 CS = ONE 00515 OLDCS = ONE 00516 DO 120 I = LL, M - 1 00517 CALL SLARTG( D( I )*CS, E( I ), CS, SN, R ) 00518 IF( I.GT.LL ) 00519 $ E( I-1 ) = OLDSN*R 00520 CALL SLARTG( OLDCS*R, D( I+1 )*SN, OLDCS, OLDSN, D( I ) ) 00521 WORK( I-LL+1 ) = CS 00522 WORK( I-LL+1+NM1 ) = SN 00523 WORK( I-LL+1+NM12 ) = OLDCS 00524 WORK( I-LL+1+NM13 ) = OLDSN 00525 120 CONTINUE 00526 H = D( M )*CS 00527 D( M ) = H*OLDCS 00528 E( M-1 ) = H*OLDSN 00529 * 00530 * Update singular vectors 00531 * 00532 IF( NCVT.GT.0 ) 00533 $ CALL SLASR( 'L', 'V', 'F', M-LL+1, NCVT, WORK( 1 ), 00534 $ WORK( N ), VT( LL, 1 ), LDVT ) 00535 IF( NRU.GT.0 ) 00536 $ CALL SLASR( 'R', 'V', 'F', NRU, M-LL+1, WORK( NM12+1 ), 00537 $ WORK( NM13+1 ), U( 1, LL ), LDU ) 00538 IF( NCC.GT.0 ) 00539 $ CALL SLASR( 'L', 'V', 'F', M-LL+1, NCC, WORK( NM12+1 ), 00540 $ WORK( NM13+1 ), C( LL, 1 ), LDC ) 00541 * 00542 * Test convergence 00543 * 00544 IF( ABS( E( M-1 ) ).LE.THRESH ) 00545 $ E( M-1 ) = ZERO 00546 * 00547 ELSE 00548 * 00549 * Chase bulge from bottom to top 00550 * Save cosines and sines for later singular vector updates 00551 * 00552 CS = ONE 00553 OLDCS = ONE 00554 DO 130 I = M, LL + 1, -1 00555 CALL SLARTG( D( I )*CS, E( I-1 ), CS, SN, R ) 00556 IF( I.LT.M ) 00557 $ E( I ) = OLDSN*R 00558 CALL SLARTG( OLDCS*R, D( I-1 )*SN, OLDCS, OLDSN, D( I ) ) 00559 WORK( I-LL ) = CS 00560 WORK( I-LL+NM1 ) = -SN 00561 WORK( I-LL+NM12 ) = OLDCS 00562 WORK( I-LL+NM13 ) = -OLDSN 00563 130 CONTINUE 00564 H = D( LL )*CS 00565 D( LL ) = H*OLDCS 00566 E( LL ) = H*OLDSN 00567 * 00568 * Update singular vectors 00569 * 00570 IF( NCVT.GT.0 ) 00571 $ CALL SLASR( 'L', 'V', 'B', M-LL+1, NCVT, WORK( NM12+1 ), 00572 $ WORK( NM13+1 ), VT( LL, 1 ), LDVT ) 00573 IF( NRU.GT.0 ) 00574 $ CALL SLASR( 'R', 'V', 'B', NRU, M-LL+1, WORK( 1 ), 00575 $ WORK( N ), U( 1, LL ), LDU ) 00576 IF( NCC.GT.0 ) 00577 $ CALL SLASR( 'L', 'V', 'B', M-LL+1, NCC, WORK( 1 ), 00578 $ WORK( N ), C( LL, 1 ), LDC ) 00579 * 00580 * Test convergence 00581 * 00582 IF( ABS( E( LL ) ).LE.THRESH ) 00583 $ E( LL ) = ZERO 00584 END IF 00585 ELSE 00586 * 00587 * Use nonzero shift 00588 * 00589 IF( IDIR.EQ.1 ) THEN 00590 * 00591 * Chase bulge from top to bottom 00592 * Save cosines and sines for later singular vector updates 00593 * 00594 F = ( ABS( D( LL ) )-SHIFT )* 00595 $ ( SIGN( ONE, D( LL ) )+SHIFT / D( LL ) ) 00596 G = E( LL ) 00597 DO 140 I = LL, M - 1 00598 CALL SLARTG( F, G, COSR, SINR, R ) 00599 IF( I.GT.LL ) 00600 $ E( I-1 ) = R 00601 F = COSR*D( I ) + SINR*E( I ) 00602 E( I ) = COSR*E( I ) - SINR*D( I ) 00603 G = SINR*D( I+1 ) 00604 D( I+1 ) = COSR*D( I+1 ) 00605 CALL SLARTG( F, G, COSL, SINL, R ) 00606 D( I ) = R 00607 F = COSL*E( I ) + SINL*D( I+1 ) 00608 D( I+1 ) = COSL*D( I+1 ) - SINL*E( I ) 00609 IF( I.LT.M-1 ) THEN 00610 G = SINL*E( I+1 ) 00611 E( I+1 ) = COSL*E( I+1 ) 00612 END IF 00613 WORK( I-LL+1 ) = COSR 00614 WORK( I-LL+1+NM1 ) = SINR 00615 WORK( I-LL+1+NM12 ) = COSL 00616 WORK( I-LL+1+NM13 ) = SINL 00617 140 CONTINUE 00618 E( M-1 ) = F 00619 * 00620 * Update singular vectors 00621 * 00622 IF( NCVT.GT.0 ) 00623 $ CALL SLASR( 'L', 'V', 'F', M-LL+1, NCVT, WORK( 1 ), 00624 $ WORK( N ), VT( LL, 1 ), LDVT ) 00625 IF( NRU.GT.0 ) 00626 $ CALL SLASR( 'R', 'V', 'F', NRU, M-LL+1, WORK( NM12+1 ), 00627 $ WORK( NM13+1 ), U( 1, LL ), LDU ) 00628 IF( NCC.GT.0 ) 00629 $ CALL SLASR( 'L', 'V', 'F', M-LL+1, NCC, WORK( NM12+1 ), 00630 $ WORK( NM13+1 ), C( LL, 1 ), LDC ) 00631 * 00632 * Test convergence 00633 * 00634 IF( ABS( E( M-1 ) ).LE.THRESH ) 00635 $ E( M-1 ) = ZERO 00636 * 00637 ELSE 00638 * 00639 * Chase bulge from bottom to top 00640 * Save cosines and sines for later singular vector updates 00641 * 00642 F = ( ABS( D( M ) )-SHIFT )*( SIGN( ONE, D( M ) )+SHIFT / 00643 $ D( M ) ) 00644 G = E( M-1 ) 00645 DO 150 I = M, LL + 1, -1 00646 CALL SLARTG( F, G, COSR, SINR, R ) 00647 IF( I.LT.M ) 00648 $ E( I ) = R 00649 F = COSR*D( I ) + SINR*E( I-1 ) 00650 E( I-1 ) = COSR*E( I-1 ) - SINR*D( I ) 00651 G = SINR*D( I-1 ) 00652 D( I-1 ) = COSR*D( I-1 ) 00653 CALL SLARTG( F, G, COSL, SINL, R ) 00654 D( I ) = R 00655 F = COSL*E( I-1 ) + SINL*D( I-1 ) 00656 D( I-1 ) = COSL*D( I-1 ) - SINL*E( I-1 ) 00657 IF( I.GT.LL+1 ) THEN 00658 G = SINL*E( I-2 ) 00659 E( I-2 ) = COSL*E( I-2 ) 00660 END IF 00661 WORK( I-LL ) = COSR 00662 WORK( I-LL+NM1 ) = -SINR 00663 WORK( I-LL+NM12 ) = COSL 00664 WORK( I-LL+NM13 ) = -SINL 00665 150 CONTINUE 00666 E( LL ) = F 00667 * 00668 * Test convergence 00669 * 00670 IF( ABS( E( LL ) ).LE.THRESH ) 00671 $ E( LL ) = ZERO 00672 * 00673 * Update singular vectors if desired 00674 * 00675 IF( NCVT.GT.0 ) 00676 $ CALL SLASR( 'L', 'V', 'B', M-LL+1, NCVT, WORK( NM12+1 ), 00677 $ WORK( NM13+1 ), VT( LL, 1 ), LDVT ) 00678 IF( NRU.GT.0 ) 00679 $ CALL SLASR( 'R', 'V', 'B', NRU, M-LL+1, WORK( 1 ), 00680 $ WORK( N ), U( 1, LL ), LDU ) 00681 IF( NCC.GT.0 ) 00682 $ CALL SLASR( 'L', 'V', 'B', M-LL+1, NCC, WORK( 1 ), 00683 $ WORK( N ), C( LL, 1 ), LDC ) 00684 END IF 00685 END IF 00686 * 00687 * QR iteration finished, go back and check convergence 00688 * 00689 GO TO 60 00690 * 00691 * All singular values converged, so make them positive 00692 * 00693 160 CONTINUE 00694 DO 170 I = 1, N 00695 IF( D( I ).LT.ZERO ) THEN 00696 D( I ) = -D( I ) 00697 * 00698 * Change sign of singular vectors, if desired 00699 * 00700 IF( NCVT.GT.0 ) 00701 $ CALL SSCAL( NCVT, NEGONE, VT( I, 1 ), LDVT ) 00702 END IF 00703 170 CONTINUE 00704 * 00705 * Sort the singular values into decreasing order (insertion sort on 00706 * singular values, but only one transposition per singular vector) 00707 * 00708 DO 190 I = 1, N - 1 00709 * 00710 * Scan for smallest D(I) 00711 * 00712 ISUB = 1 00713 SMIN = D( 1 ) 00714 DO 180 J = 2, N + 1 - I 00715 IF( D( J ).LE.SMIN ) THEN 00716 ISUB = J 00717 SMIN = D( J ) 00718 END IF 00719 180 CONTINUE 00720 IF( ISUB.NE.N+1-I ) THEN 00721 * 00722 * Swap singular values and vectors 00723 * 00724 D( ISUB ) = D( N+1-I ) 00725 D( N+1-I ) = SMIN 00726 IF( NCVT.GT.0 ) 00727 $ CALL SSWAP( NCVT, VT( ISUB, 1 ), LDVT, VT( N+1-I, 1 ), 00728 $ LDVT ) 00729 IF( NRU.GT.0 ) 00730 $ CALL SSWAP( NRU, U( 1, ISUB ), 1, U( 1, N+1-I ), 1 ) 00731 IF( NCC.GT.0 ) 00732 $ CALL SSWAP( NCC, C( ISUB, 1 ), LDC, C( N+1-I, 1 ), LDC ) 00733 END IF 00734 190 CONTINUE 00735 GO TO 220 00736 * 00737 * Maximum number of iterations exceeded, failure to converge 00738 * 00739 200 CONTINUE 00740 INFO = 0 00741 DO 210 I = 1, N - 1 00742 IF( E( I ).NE.ZERO ) 00743 $ INFO = INFO + 1 00744 210 CONTINUE 00745 220 CONTINUE 00746 RETURN 00747 * 00748 * End of SBDSQR 00749 * 00750 END
1.7.3 
