 LAPACK  3.10.0 LAPACK: Linear Algebra PACKage

## ◆ dlasdq()

 subroutine dlasdq ( character UPLO, integer SQRE, integer N, integer NCVT, integer NRU, integer NCC, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldvt, * ) VT, integer LDVT, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) WORK, integer INFO )

DLASDQ computes the SVD of a real bidiagonal matrix with diagonal d and off-diagonal e. Used by sbdsdc.

Purpose:
``` DLASDQ computes the singular value decomposition (SVD) of a real
(upper or lower) bidiagonal matrix with diagonal D and offdiagonal
E, accumulating the transformations if desired. Letting B denote
the input bidiagonal matrix, the algorithm computes orthogonal
matrices Q and P such that B = Q * S * P**T (P**T denotes the transpose
of P). The singular values S are overwritten on D.

The input matrix U  is changed to U  * Q  if desired.
The input matrix VT is changed to P**T * VT if desired.
The input matrix C  is changed to Q**T * C  if desired.

See "Computing  Small Singular Values of Bidiagonal Matrices With
Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan,
LAPACK Working Note #3, for a detailed description of the algorithm.```
Parameters
 [in] UPLO ``` UPLO is CHARACTER*1 On entry, UPLO specifies whether the input bidiagonal matrix is upper or lower bidiagonal, and whether it is square are not. UPLO = 'U' or 'u' B is upper bidiagonal. UPLO = 'L' or 'l' B is lower bidiagonal.``` [in] SQRE ``` SQRE is INTEGER = 0: then the input matrix is N-by-N. = 1: then the input matrix is N-by-(N+1) if UPLU = 'U' and (N+1)-by-N if UPLU = 'L'. The bidiagonal matrix has N = NL + NR + 1 rows and M = N + SQRE >= N columns.``` [in] N ``` N is INTEGER On entry, N specifies the number of rows and columns in the matrix. N must be at least 0.``` [in] NCVT ``` NCVT is INTEGER On entry, NCVT specifies the number of columns of the matrix VT. NCVT must be at least 0.``` [in] NRU ``` NRU is INTEGER On entry, NRU specifies the number of rows of the matrix U. NRU must be at least 0.``` [in] NCC ``` NCC is INTEGER On entry, NCC specifies the number of columns of the matrix C. NCC must be at least 0.``` [in,out] D ``` D is DOUBLE PRECISION array, dimension (N) On entry, D contains the diagonal entries of the bidiagonal matrix whose SVD is desired. On normal exit, D contains the singular values in ascending order.``` [in,out] E ``` E is DOUBLE PRECISION array. dimension is (N-1) if SQRE = 0 and N if SQRE = 1. On entry, the entries of E contain the offdiagonal entries of the bidiagonal matrix whose SVD is desired. On normal exit, E will contain 0. If the algorithm does not converge, D and E will contain the diagonal and superdiagonal entries of a bidiagonal matrix orthogonally equivalent to the one given as input.``` [in,out] VT ``` VT is DOUBLE PRECISION array, dimension (LDVT, NCVT) On entry, contains a matrix which on exit has been premultiplied by P**T, dimension N-by-NCVT if SQRE = 0 and (N+1)-by-NCVT if SQRE = 1 (not referenced if NCVT=0).``` [in] LDVT ``` LDVT is INTEGER On entry, LDVT specifies the leading dimension of VT as declared in the calling (sub) program. LDVT must be at least 1. If NCVT is nonzero LDVT must also be at least N.``` [in,out] U ``` U is DOUBLE PRECISION array, dimension (LDU, N) On entry, contains a matrix which on exit has been postmultiplied by Q, dimension NRU-by-N if SQRE = 0 and NRU-by-(N+1) if SQRE = 1 (not referenced if NRU=0).``` [in] LDU ``` LDU is INTEGER On entry, LDU specifies the leading dimension of U as declared in the calling (sub) program. LDU must be at least max( 1, NRU ) .``` [in,out] C ``` C is DOUBLE PRECISION array, dimension (LDC, NCC) On entry, contains an N-by-NCC matrix which on exit has been premultiplied by Q**T dimension N-by-NCC if SQRE = 0 and (N+1)-by-NCC if SQRE = 1 (not referenced if NCC=0).``` [in] LDC ``` LDC is INTEGER On entry, LDC specifies the leading dimension of C as declared in the calling (sub) program. LDC must be at least 1. If NCC is nonzero, LDC must also be at least N.``` [out] WORK ``` WORK is DOUBLE PRECISION array, dimension (4*N) Workspace. Only referenced if one of NCVT, NRU, or NCC is nonzero, and if N is at least 2.``` [out] INFO ``` INFO is INTEGER On exit, a value of 0 indicates a successful exit. If INFO < 0, argument number -INFO is illegal. If INFO > 0, the algorithm did not converge, and INFO specifies how many superdiagonals did not converge.```
Contributors:
Ming Gu and Huan Ren, Computer Science Division, University of California at Berkeley, USA

Definition at line 209 of file dlasdq.f.

211 *
212 * -- LAPACK auxiliary routine --
213 * -- LAPACK is a software package provided by Univ. of Tennessee, --
214 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
215 *
216 * .. Scalar Arguments ..
217  CHARACTER UPLO
218  INTEGER INFO, LDC, LDU, LDVT, N, NCC, NCVT, NRU, SQRE
219 * ..
220 * .. Array Arguments ..
221  DOUBLE PRECISION C( LDC, * ), D( * ), E( * ), U( LDU, * ),
222  \$ VT( LDVT, * ), WORK( * )
223 * ..
224 *
225 * =====================================================================
226 *
227 * .. Parameters ..
228  DOUBLE PRECISION ZERO
229  parameter( zero = 0.0d+0 )
230 * ..
231 * .. Local Scalars ..
232  LOGICAL ROTATE
233  INTEGER I, ISUB, IUPLO, J, NP1, SQRE1
234  DOUBLE PRECISION CS, R, SMIN, SN
235 * ..
236 * .. External Subroutines ..
237  EXTERNAL dbdsqr, dlartg, dlasr, dswap, xerbla
238 * ..
239 * .. External Functions ..
240  LOGICAL LSAME
241  EXTERNAL lsame
242 * ..
243 * .. Intrinsic Functions ..
244  INTRINSIC max
245 * ..
246 * .. Executable Statements ..
247 *
248 * Test the input parameters.
249 *
250  info = 0
251  iuplo = 0
252  IF( lsame( uplo, 'U' ) )
253  \$ iuplo = 1
254  IF( lsame( uplo, 'L' ) )
255  \$ iuplo = 2
256  IF( iuplo.EQ.0 ) THEN
257  info = -1
258  ELSE IF( ( sqre.LT.0 ) .OR. ( sqre.GT.1 ) ) THEN
259  info = -2
260  ELSE IF( n.LT.0 ) THEN
261  info = -3
262  ELSE IF( ncvt.LT.0 ) THEN
263  info = -4
264  ELSE IF( nru.LT.0 ) THEN
265  info = -5
266  ELSE IF( ncc.LT.0 ) THEN
267  info = -6
268  ELSE IF( ( ncvt.EQ.0 .AND. ldvt.LT.1 ) .OR.
269  \$ ( ncvt.GT.0 .AND. ldvt.LT.max( 1, n ) ) ) THEN
270  info = -10
271  ELSE IF( ldu.LT.max( 1, nru ) ) THEN
272  info = -12
273  ELSE IF( ( ncc.EQ.0 .AND. ldc.LT.1 ) .OR.
274  \$ ( ncc.GT.0 .AND. ldc.LT.max( 1, n ) ) ) THEN
275  info = -14
276  END IF
277  IF( info.NE.0 ) THEN
278  CALL xerbla( 'DLASDQ', -info )
279  RETURN
280  END IF
281  IF( n.EQ.0 )
282  \$ RETURN
283 *
284 * ROTATE is true if any singular vectors desired, false otherwise
285 *
286  rotate = ( ncvt.GT.0 ) .OR. ( nru.GT.0 ) .OR. ( ncc.GT.0 )
287  np1 = n + 1
288  sqre1 = sqre
289 *
290 * If matrix non-square upper bidiagonal, rotate to be lower
291 * bidiagonal. The rotations are on the right.
292 *
293  IF( ( iuplo.EQ.1 ) .AND. ( sqre1.EQ.1 ) ) THEN
294  DO 10 i = 1, n - 1
295  CALL dlartg( d( i ), e( i ), cs, sn, r )
296  d( i ) = r
297  e( i ) = sn*d( i+1 )
298  d( i+1 ) = cs*d( i+1 )
299  IF( rotate ) THEN
300  work( i ) = cs
301  work( n+i ) = sn
302  END IF
303  10 CONTINUE
304  CALL dlartg( d( n ), e( n ), cs, sn, r )
305  d( n ) = r
306  e( n ) = zero
307  IF( rotate ) THEN
308  work( n ) = cs
309  work( n+n ) = sn
310  END IF
311  iuplo = 2
312  sqre1 = 0
313 *
314 * Update singular vectors if desired.
315 *
316  IF( ncvt.GT.0 )
317  \$ CALL dlasr( 'L', 'V', 'F', np1, ncvt, work( 1 ),
318  \$ work( np1 ), vt, ldvt )
319  END IF
320 *
321 * If matrix lower bidiagonal, rotate to be upper bidiagonal
322 * by applying Givens rotations on the left.
323 *
324  IF( iuplo.EQ.2 ) THEN
325  DO 20 i = 1, n - 1
326  CALL dlartg( d( i ), e( i ), cs, sn, r )
327  d( i ) = r
328  e( i ) = sn*d( i+1 )
329  d( i+1 ) = cs*d( i+1 )
330  IF( rotate ) THEN
331  work( i ) = cs
332  work( n+i ) = sn
333  END IF
334  20 CONTINUE
335 *
336 * If matrix (N+1)-by-N lower bidiagonal, one additional
337 * rotation is needed.
338 *
339  IF( sqre1.EQ.1 ) THEN
340  CALL dlartg( d( n ), e( n ), cs, sn, r )
341  d( n ) = r
342  IF( rotate ) THEN
343  work( n ) = cs
344  work( n+n ) = sn
345  END IF
346  END IF
347 *
348 * Update singular vectors if desired.
349 *
350  IF( nru.GT.0 ) THEN
351  IF( sqre1.EQ.0 ) THEN
352  CALL dlasr( 'R', 'V', 'F', nru, n, work( 1 ),
353  \$ work( np1 ), u, ldu )
354  ELSE
355  CALL dlasr( 'R', 'V', 'F', nru, np1, work( 1 ),
356  \$ work( np1 ), u, ldu )
357  END IF
358  END IF
359  IF( ncc.GT.0 ) THEN
360  IF( sqre1.EQ.0 ) THEN
361  CALL dlasr( 'L', 'V', 'F', n, ncc, work( 1 ),
362  \$ work( np1 ), c, ldc )
363  ELSE
364  CALL dlasr( 'L', 'V', 'F', np1, ncc, work( 1 ),
365  \$ work( np1 ), c, ldc )
366  END IF
367  END IF
368  END IF
369 *
370 * Call DBDSQR to compute the SVD of the reduced real
371 * N-by-N upper bidiagonal matrix.
372 *
373  CALL dbdsqr( 'U', n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c,
374  \$ ldc, work, info )
375 *
376 * Sort the singular values into ascending order (insertion sort on
377 * singular values, but only one transposition per singular vector)
378 *
379  DO 40 i = 1, n
380 *
381 * Scan for smallest D(I).
382 *
383  isub = i
384  smin = d( i )
385  DO 30 j = i + 1, n
386  IF( d( j ).LT.smin ) THEN
387  isub = j
388  smin = d( j )
389  END IF
390  30 CONTINUE
391  IF( isub.NE.i ) THEN
392 *
393 * Swap singular values and vectors.
394 *
395  d( isub ) = d( i )
396  d( i ) = smin
397  IF( ncvt.GT.0 )
398  \$ CALL dswap( ncvt, vt( isub, 1 ), ldvt, vt( i, 1 ), ldvt )
399  IF( nru.GT.0 )
400  \$ CALL dswap( nru, u( 1, isub ), 1, u( 1, i ), 1 )
401  IF( ncc.GT.0 )
402  \$ CALL dswap( ncc, c( isub, 1 ), ldc, c( i, 1 ), ldc )
403  END IF
404  40 CONTINUE
405 *
406  RETURN
407 *
408 * End of DLASDQ
409 *
subroutine dlartg(f, g, c, s, r)
DLARTG generates a plane rotation with real cosine and real sine.
Definition: dlartg.f90:113
subroutine dlasr(SIDE, PIVOT, DIRECT, M, N, C, S, A, LDA)
DLASR applies a sequence of plane rotations to a general rectangular matrix.
Definition: dlasr.f:199
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine dbdsqr(UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, LDU, C, LDC, WORK, INFO)
DBDSQR
Definition: dbdsqr.f:241
subroutine dswap(N, DX, INCX, DY, INCY)
DSWAP
Definition: dswap.f:82
Here is the call graph for this function:
Here is the caller graph for this function: