![]() ![]() | ![]() |
Mise à jour de lapack vers la version 3.3.0.
1: SUBROUTINE DLASD3( NL, NR, SQRE, K, D, Q, LDQ, DSIGMA, U, LDU, U2, 2: $ LDU2, VT, LDVT, VT2, LDVT2, IDXC, CTOT, Z, 3: $ INFO ) 4: * 5: * -- LAPACK auxiliary routine (version 3.2.2) -- 6: * -- LAPACK is a software package provided by Univ. of Tennessee, -- 7: * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- 8: * June 2010 9: * 10: * .. Scalar Arguments .. 11: INTEGER INFO, K, LDQ, LDU, LDU2, LDVT, LDVT2, NL, NR, 12: $ SQRE 13: * .. 14: * .. Array Arguments .. 15: INTEGER CTOT( * ), IDXC( * ) 16: DOUBLE PRECISION D( * ), DSIGMA( * ), Q( LDQ, * ), U( LDU, * ), 17: $ U2( LDU2, * ), VT( LDVT, * ), VT2( LDVT2, * ), 18: $ Z( * ) 19: * .. 20: * 21: * Purpose 22: * ======= 23: * 24: * DLASD3 finds all the square roots of the roots of the secular 25: * equation, as defined by the values in D and Z. It makes the 26: * appropriate calls to DLASD4 and then updates the singular 27: * vectors by matrix multiplication. 28: * 29: * This code makes very mild assumptions about floating point 30: * arithmetic. It will work on machines with a guard digit in 31: * add/subtract, or on those binary machines without guard digits 32: * which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2. 33: * It could conceivably fail on hexadecimal or decimal machines 34: * without guard digits, but we know of none. 35: * 36: * DLASD3 is called from DLASD1. 37: * 38: * Arguments 39: * ========= 40: * 41: * NL (input) INTEGER 42: * The row dimension of the upper block. NL >= 1. 43: * 44: * NR (input) INTEGER 45: * The row dimension of the lower block. NR >= 1. 46: * 47: * SQRE (input) INTEGER 48: * = 0: the lower block is an NR-by-NR square matrix. 49: * = 1: the lower block is an NR-by-(NR+1) rectangular matrix. 50: * 51: * The bidiagonal matrix has N = NL + NR + 1 rows and 52: * M = N + SQRE >= N columns. 53: * 54: * K (input) INTEGER 55: * The size of the secular equation, 1 =< K = < N. 56: * 57: * D (output) DOUBLE PRECISION array, dimension(K) 58: * On exit the square roots of the roots of the secular equation, 59: * in ascending order. 60: * 61: * Q (workspace) DOUBLE PRECISION array, 62: * dimension at least (LDQ,K). 63: * 64: * LDQ (input) INTEGER 65: * The leading dimension of the array Q. LDQ >= K. 66: * 67: * DSIGMA (input) DOUBLE PRECISION array, dimension(K) 68: * The first K elements of this array contain the old roots 69: * of the deflated updating problem. These are the poles 70: * of the secular equation. 71: * 72: * U (output) DOUBLE PRECISION array, dimension (LDU, N) 73: * The last N - K columns of this matrix contain the deflated 74: * left singular vectors. 75: * 76: * LDU (input) INTEGER 77: * The leading dimension of the array U. LDU >= N. 78: * 79: * U2 (input/output) DOUBLE PRECISION array, dimension (LDU2, N) 80: * The first K columns of this matrix contain the non-deflated 81: * left singular vectors for the split problem. 82: * 83: * LDU2 (input) INTEGER 84: * The leading dimension of the array U2. LDU2 >= N. 85: * 86: * VT (output) DOUBLE PRECISION array, dimension (LDVT, M) 87: * The last M - K columns of VT' contain the deflated 88: * right singular vectors. 89: * 90: * LDVT (input) INTEGER 91: * The leading dimension of the array VT. LDVT >= N. 92: * 93: * VT2 (input/output) DOUBLE PRECISION array, dimension (LDVT2, N) 94: * The first K columns of VT2' contain the non-deflated 95: * right singular vectors for the split problem. 96: * 97: * LDVT2 (input) INTEGER 98: * The leading dimension of the array VT2. LDVT2 >= N. 99: * 100: * IDXC (input) INTEGER array, dimension ( N ) 101: * The permutation used to arrange the columns of U (and rows of 102: * VT) into three groups: the first group contains non-zero 103: * entries only at and above (or before) NL +1; the second 104: * contains non-zero entries only at and below (or after) NL+2; 105: * and the third is dense. The first column of U and the row of 106: * VT are treated separately, however. 107: * 108: * The rows of the singular vectors found by DLASD4 109: * must be likewise permuted before the matrix multiplies can 110: * take place. 111: * 112: * CTOT (input) INTEGER array, dimension ( 4 ) 113: * A count of the total number of the various types of columns 114: * in U (or rows in VT), as described in IDXC. The fourth column 115: * type is any column which has been deflated. 116: * 117: * Z (input) DOUBLE PRECISION array, dimension (K) 118: * The first K elements of this array contain the components 119: * of the deflation-adjusted updating row vector. 120: * 121: * INFO (output) INTEGER 122: * = 0: successful exit. 123: * < 0: if INFO = -i, the i-th argument had an illegal value. 124: * > 0: if INFO = 1, a singular value did not converge 125: * 126: * Further Details 127: * =============== 128: * 129: * Based on contributions by 130: * Ming Gu and Huan Ren, Computer Science Division, University of 131: * California at Berkeley, USA 132: * 133: * ===================================================================== 134: * 135: * .. Parameters .. 136: DOUBLE PRECISION ONE, ZERO, NEGONE 137: PARAMETER ( ONE = 1.0D+0, ZERO = 0.0D+0, 138: $ NEGONE = -1.0D+0 ) 139: * .. 140: * .. Local Scalars .. 141: INTEGER CTEMP, I, J, JC, KTEMP, M, N, NLP1, NLP2, NRP1 142: DOUBLE PRECISION RHO, TEMP 143: * .. 144: * .. External Functions .. 145: DOUBLE PRECISION DLAMC3, DNRM2 146: EXTERNAL DLAMC3, DNRM2 147: * .. 148: * .. External Subroutines .. 149: EXTERNAL DCOPY, DGEMM, DLACPY, DLASCL, DLASD4, XERBLA 150: * .. 151: * .. Intrinsic Functions .. 152: INTRINSIC ABS, SIGN, SQRT 153: * .. 154: * .. Executable Statements .. 155: * 156: * Test the input parameters. 157: * 158: INFO = 0 159: * 160: IF( NL.LT.1 ) THEN 161: INFO = -1 162: ELSE IF( NR.LT.1 ) THEN 163: INFO = -2 164: ELSE IF( ( SQRE.NE.1 ) .AND. ( SQRE.NE.0 ) ) THEN 165: INFO = -3 166: END IF 167: * 168: N = NL + NR + 1 169: M = N + SQRE 170: NLP1 = NL + 1 171: NLP2 = NL + 2 172: * 173: IF( ( K.LT.1 ) .OR. ( K.GT.N ) ) THEN 174: INFO = -4 175: ELSE IF( LDQ.LT.K ) THEN 176: INFO = -7 177: ELSE IF( LDU.LT.N ) THEN 178: INFO = -10 179: ELSE IF( LDU2.LT.N ) THEN 180: INFO = -12 181: ELSE IF( LDVT.LT.M ) THEN 182: INFO = -14 183: ELSE IF( LDVT2.LT.M ) THEN 184: INFO = -16 185: END IF 186: IF( INFO.NE.0 ) THEN 187: CALL XERBLA( 'DLASD3', -INFO ) 188: RETURN 189: END IF 190: * 191: * Quick return if possible 192: * 193: IF( K.EQ.1 ) THEN 194: D( 1 ) = ABS( Z( 1 ) ) 195: CALL DCOPY( M, VT2( 1, 1 ), LDVT2, VT( 1, 1 ), LDVT ) 196: IF( Z( 1 ).GT.ZERO ) THEN 197: CALL DCOPY( N, U2( 1, 1 ), 1, U( 1, 1 ), 1 ) 198: ELSE 199: DO 10 I = 1, N 200: U( I, 1 ) = -U2( I, 1 ) 201: 10 CONTINUE 202: END IF 203: RETURN 204: END IF 205: * 206: * Modify values DSIGMA(i) to make sure all DSIGMA(i)-DSIGMA(j) can 207: * be computed with high relative accuracy (barring over/underflow). 208: * This is a problem on machines without a guard digit in 209: * add/subtract (Cray XMP, Cray YMP, Cray C 90 and Cray 2). 210: * The following code replaces DSIGMA(I) by 2*DSIGMA(I)-DSIGMA(I), 211: * which on any of these machines zeros out the bottommost 212: * bit of DSIGMA(I) if it is 1; this makes the subsequent 213: * subtractions DSIGMA(I)-DSIGMA(J) unproblematic when cancellation 214: * occurs. On binary machines with a guard digit (almost all 215: * machines) it does not change DSIGMA(I) at all. On hexadecimal 216: * and decimal machines with a guard digit, it slightly 217: * changes the bottommost bits of DSIGMA(I). It does not account 218: * for hexadecimal or decimal machines without guard digits 219: * (we know of none). We use a subroutine call to compute 220: * 2*DSIGMA(I) to prevent optimizing compilers from eliminating 221: * this code. 222: * 223: DO 20 I = 1, K 224: DSIGMA( I ) = DLAMC3( DSIGMA( I ), DSIGMA( I ) ) - DSIGMA( I ) 225: 20 CONTINUE 226: * 227: * Keep a copy of Z. 228: * 229: CALL DCOPY( K, Z, 1, Q, 1 ) 230: * 231: * Normalize Z. 232: * 233: RHO = DNRM2( K, Z, 1 ) 234: CALL DLASCL( 'G', 0, 0, RHO, ONE, K, 1, Z, K, INFO ) 235: RHO = RHO*RHO 236: * 237: * Find the new singular values. 238: * 239: DO 30 J = 1, K 240: CALL DLASD4( K, J, DSIGMA, Z, U( 1, J ), RHO, D( J ), 241: $ VT( 1, J ), INFO ) 242: * 243: * If the zero finder fails, the computation is terminated. 244: * 245: IF( INFO.NE.0 ) THEN 246: RETURN 247: END IF 248: 30 CONTINUE 249: * 250: * Compute updated Z. 251: * 252: DO 60 I = 1, K 253: Z( I ) = U( I, K )*VT( I, K ) 254: DO 40 J = 1, I - 1 255: Z( I ) = Z( I )*( U( I, J )*VT( I, J ) / 256: $ ( DSIGMA( I )-DSIGMA( J ) ) / 257: $ ( DSIGMA( I )+DSIGMA( J ) ) ) 258: 40 CONTINUE 259: DO 50 J = I, K - 1 260: Z( I ) = Z( I )*( U( I, J )*VT( I, J ) / 261: $ ( DSIGMA( I )-DSIGMA( J+1 ) ) / 262: $ ( DSIGMA( I )+DSIGMA( J+1 ) ) ) 263: 50 CONTINUE 264: Z( I ) = SIGN( SQRT( ABS( Z( I ) ) ), Q( I, 1 ) ) 265: 60 CONTINUE 266: * 267: * Compute left singular vectors of the modified diagonal matrix, 268: * and store related information for the right singular vectors. 269: * 270: DO 90 I = 1, K 271: VT( 1, I ) = Z( 1 ) / U( 1, I ) / VT( 1, I ) 272: U( 1, I ) = NEGONE 273: DO 70 J = 2, K 274: VT( J, I ) = Z( J ) / U( J, I ) / VT( J, I ) 275: U( J, I ) = DSIGMA( J )*VT( J, I ) 276: 70 CONTINUE 277: TEMP = DNRM2( K, U( 1, I ), 1 ) 278: Q( 1, I ) = U( 1, I ) / TEMP 279: DO 80 J = 2, K 280: JC = IDXC( J ) 281: Q( J, I ) = U( JC, I ) / TEMP 282: 80 CONTINUE 283: 90 CONTINUE 284: * 285: * Update the left singular vector matrix. 286: * 287: IF( K.EQ.2 ) THEN 288: CALL DGEMM( 'N', 'N', N, K, K, ONE, U2, LDU2, Q, LDQ, ZERO, U, 289: $ LDU ) 290: GO TO 100 291: END IF 292: IF( CTOT( 1 ).GT.0 ) THEN 293: CALL DGEMM( 'N', 'N', NL, K, CTOT( 1 ), ONE, U2( 1, 2 ), LDU2, 294: $ Q( 2, 1 ), LDQ, ZERO, U( 1, 1 ), LDU ) 295: IF( CTOT( 3 ).GT.0 ) THEN 296: KTEMP = 2 + CTOT( 1 ) + CTOT( 2 ) 297: CALL DGEMM( 'N', 'N', NL, K, CTOT( 3 ), ONE, U2( 1, KTEMP ), 298: $ LDU2, Q( KTEMP, 1 ), LDQ, ONE, U( 1, 1 ), LDU ) 299: END IF 300: ELSE IF( CTOT( 3 ).GT.0 ) THEN 301: KTEMP = 2 + CTOT( 1 ) + CTOT( 2 ) 302: CALL DGEMM( 'N', 'N', NL, K, CTOT( 3 ), ONE, U2( 1, KTEMP ), 303: $ LDU2, Q( KTEMP, 1 ), LDQ, ZERO, U( 1, 1 ), LDU ) 304: ELSE 305: CALL DLACPY( 'F', NL, K, U2, LDU2, U, LDU ) 306: END IF 307: CALL DCOPY( K, Q( 1, 1 ), LDQ, U( NLP1, 1 ), LDU ) 308: KTEMP = 2 + CTOT( 1 ) 309: CTEMP = CTOT( 2 ) + CTOT( 3 ) 310: CALL DGEMM( 'N', 'N', NR, K, CTEMP, ONE, U2( NLP2, KTEMP ), LDU2, 311: $ Q( KTEMP, 1 ), LDQ, ZERO, U( NLP2, 1 ), LDU ) 312: * 313: * Generate the right singular vectors. 314: * 315: 100 CONTINUE 316: DO 120 I = 1, K 317: TEMP = DNRM2( K, VT( 1, I ), 1 ) 318: Q( I, 1 ) = VT( 1, I ) / TEMP 319: DO 110 J = 2, K 320: JC = IDXC( J ) 321: Q( I, J ) = VT( JC, I ) / TEMP 322: 110 CONTINUE 323: 120 CONTINUE 324: * 325: * Update the right singular vector matrix. 326: * 327: IF( K.EQ.2 ) THEN 328: CALL DGEMM( 'N', 'N', K, M, K, ONE, Q, LDQ, VT2, LDVT2, ZERO, 329: $ VT, LDVT ) 330: RETURN 331: END IF 332: KTEMP = 1 + CTOT( 1 ) 333: CALL DGEMM( 'N', 'N', K, NLP1, KTEMP, ONE, Q( 1, 1 ), LDQ, 334: $ VT2( 1, 1 ), LDVT2, ZERO, VT( 1, 1 ), LDVT ) 335: KTEMP = 2 + CTOT( 1 ) + CTOT( 2 ) 336: IF( KTEMP.LE.LDVT2 ) 337: $ CALL DGEMM( 'N', 'N', K, NLP1, CTOT( 3 ), ONE, Q( 1, KTEMP ), 338: $ LDQ, VT2( KTEMP, 1 ), LDVT2, ONE, VT( 1, 1 ), 339: $ LDVT ) 340: * 341: KTEMP = CTOT( 1 ) + 1 342: NRP1 = NR + SQRE 343: IF( KTEMP.GT.1 ) THEN 344: DO 130 I = 1, K 345: Q( I, KTEMP ) = Q( I, 1 ) 346: 130 CONTINUE 347: DO 140 I = NLP2, M 348: VT2( KTEMP, I ) = VT2( 1, I ) 349: 140 CONTINUE 350: END IF 351: CTEMP = 1 + CTOT( 2 ) + CTOT( 3 ) 352: CALL DGEMM( 'N', 'N', K, NRP1, CTEMP, ONE, Q( 1, KTEMP ), LDQ, 353: $ VT2( KTEMP, NLP2 ), LDVT2, ZERO, VT( 1, NLP2 ), LDVT ) 354: * 355: RETURN 356: * 357: * End of DLASD3 358: * 359: END