Annotation of rpl/lapack/lapack/dlasd3.f, revision 1.1
1.1 ! bertrand 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) --
! 6: * -- LAPACK is a software package provided by Univ. of Tennessee, --
! 7: * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
! 8: * November 2006
! 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, an 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
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dlasd3.f CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / lapack / lapack