dbdsdc()

subroutine dbdsdc	(	character	uplo,
		character	compq,
		integer	n,
		double precision, dimension( * )	d,
		double precision, dimension( * )	e,
		double precision, dimension( ldu, * )	u,
		integer	ldu,
		double precision, dimension( ldvt, * )	vt,
		integer	ldvt,
		double precision, dimension( * )	q,
		integer, dimension( * )	iq,
		double precision, dimension( * )	work,
		integer, dimension( * )	iwork,
		integer	info )

DBDSDC

Download DBDSDC + dependencies [TGZ] [ZIP] [TXT]

Purpose:

!>
!> DBDSDC computes the singular value decomposition (SVD) of a real
!> N-by-N (upper or lower) bidiagonal matrix B:  B = U * S * VT,
!> using a divide and conquer method, where S is a diagonal matrix
!> with non-negative diagonal elements (the singular values of B), and
!> U and VT are orthogonal matrices of left and right singular vectors,
!> respectively. DBDSDC can be used to compute all singular values,
!> and optionally, singular vectors or singular vectors in compact form.
!>
!> The code currently calls DLASDQ if singular values only are desired.
!> However, it can be slightly modified to compute singular values
!> using the divide and conquer method.
!> 

Parameters

[in]	UPLO	!> UPLO is CHARACTER*1 !> = 'U': B is upper bidiagonal. !> = 'L': B is lower bidiagonal. !>
[in]	COMPQ	!> COMPQ is CHARACTER*1 !> Specifies whether singular vectors are to be computed !> as follows: !> = 'N': Compute singular values only; !> = 'P': Compute singular values and compute singular !> vectors in compact form; !> = 'I': Compute singular values and singular vectors. !>
[in]	N	!> N is INTEGER !> The order of the matrix B. N >= 0. !>
[in,out]	D	!> D is DOUBLE PRECISION array, dimension (N) !> On entry, the n diagonal elements of the bidiagonal matrix B. !> On exit, if INFO=0, the singular values of B. !>
[in,out]	E	!> E is DOUBLE PRECISION array, dimension (N-1) !> On entry, the elements of E contain the offdiagonal !> elements of the bidiagonal matrix whose SVD is desired. !> On exit, E has been destroyed. !>
[out]	U	!> U is DOUBLE PRECISION array, dimension (LDU,N) !> If COMPQ = 'I', then: !> On exit, if INFO = 0, U contains the left singular vectors !> of the bidiagonal matrix. !> For other values of COMPQ, U is not referenced. !>
[in]	LDU	!> LDU is INTEGER !> The leading dimension of the array U. LDU >= 1. !> If singular vectors are desired, then LDU >= max( 1, N ). !>
[out]	VT	!> VT is DOUBLE PRECISION array, dimension (LDVT,N) !> If COMPQ = 'I', then: !> On exit, if INFO = 0, VT**T contains the right singular !> vectors of the bidiagonal matrix. !> For other values of COMPQ, VT is not referenced. !>
[in]	LDVT	!> LDVT is INTEGER !> The leading dimension of the array VT. LDVT >= 1. !> If singular vectors are desired, then LDVT >= max( 1, N ). !>
[out]	Q	!> Q is DOUBLE PRECISION array, dimension (LDQ) !> If COMPQ = 'P', then: !> On exit, if INFO = 0, Q and IQ contain the left !> and right singular vectors in a compact form, !> requiring O(N log N) space instead of 2*N**2. !> In particular, Q contains all the DOUBLE PRECISION data in !> LDQ >= N*(11 + 2*SMLSIZ + 8*INT(LOG_2(N/(SMLSIZ+1)))) !> words of memory, where SMLSIZ is returned by ILAENV and !> is equal to the maximum size of the subproblems at the !> bottom of the computation tree (usually about 25). !> For other values of COMPQ, Q is not referenced. !>
[out]	IQ	!> IQ is INTEGER array, dimension (LDIQ) !> If COMPQ = 'P', then: !> On exit, if INFO = 0, Q and IQ contain the left !> and right singular vectors in a compact form, !> requiring O(N log N) space instead of 2*N**2. !> In particular, IQ contains all INTEGER data in !> LDIQ >= N*(3 + 3*INT(LOG_2(N/(SMLSIZ+1)))) !> words of memory, where SMLSIZ is returned by ILAENV and !> is equal to the maximum size of the subproblems at the !> bottom of the computation tree (usually about 25). !> For other values of COMPQ, IQ is not referenced. !>
[out]	WORK	!> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) !> If COMPQ = 'N' then LWORK >= (4 * N). !> If COMPQ = 'P' then LWORK >= (6 * N). !> If COMPQ = 'I' then LWORK >= (3 * N**2 + 4 * N). !>
[out]	IWORK	!> IWORK is INTEGER array, dimension (8*N) !>
[out]	INFO	!> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, the i-th argument had an illegal value. !> > 0: The algorithm failed to compute a singular value. !> The update process of divide and conquer failed. !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors:

Ming Gu and Huan Ren, Computer Science Division, University of California at Berkeley, USA