dlasd1()

subroutine dlasd1	(	integer	nl,
		integer	nr,
		integer	sqre,
		double precision, dimension( * )	d,
		double precision	alpha,
		double precision	beta,
		double precision, dimension( ldu, * )	u,
		integer	ldu,
		double precision, dimension( ldvt, * )	vt,
		integer	ldvt,
		integer, dimension( * )	idxq,
		integer, dimension( * )	iwork,
		double precision, dimension( * )	work,
		integer	info )

DLASD1 computes the SVD of an upper bidiagonal matrix B of the specified size. Used by sbdsdc.

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

Purpose:

!>
!> DLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B,
!> where N = NL + NR + 1 and M = N + SQRE. DLASD1 is called from DLASD0.
!>
!> A related subroutine DLASD7 handles the case in which the singular
!> values (and the singular vectors in factored form) are desired.
!>
!> DLASD1 computes the SVD as follows:
!>
!>               ( D1(in)    0    0       0 )
!>   B = U(in) * (   Z1**T   a   Z2**T    b ) * VT(in)
!>               (   0       0   D2(in)   0 )
!>
!>     = U(out) * ( D(out) 0) * VT(out)
!>
!> where Z**T = (Z1**T a Z2**T b) = u**T VT**T, and u is a vector of dimension M
!> with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros
!> elsewhere; and the entry b is empty if SQRE = 0.
!>
!> The left singular vectors of the original matrix are stored in U, and
!> the transpose of the right singular vectors are stored in VT, and the
!> singular values are in D.  The algorithm consists of three stages:
!>
!>    The first stage consists of deflating the size of the problem
!>    when there are multiple singular values or when there are zeros in
!>    the Z vector.  For each such occurrence the dimension of the
!>    secular equation problem is reduced by one.  This stage is
!>    performed by the routine DLASD2.
!>
!>    The second stage consists of calculating the updated
!>    singular values. This is done by finding the square roots of the
!>    roots of the secular equation via the routine DLASD4 (as called
!>    by DLASD3). This routine also calculates the singular vectors of
!>    the current problem.
!>
!>    The final stage consists of computing the updated singular vectors
!>    directly using the updated singular values.  The singular vectors
!>    for the current problem are multiplied with the singular vectors
!>    from the overall problem.
!> 

Parameters

[in]	NL	!> NL is INTEGER !> The row dimension of the upper block. NL >= 1. !>
[in]	NR	!> NR is INTEGER !> The row dimension of the lower block. NR >= 1. !>
[in]	SQRE	!> SQRE is INTEGER !> = 0: the lower block is an NR-by-NR square matrix. !> = 1: the lower block is an NR-by-(NR+1) rectangular matrix. !> !> The bidiagonal matrix has row dimension N = NL + NR + 1, !> and column dimension M = N + SQRE. !>
[in,out]	D	!> D is DOUBLE PRECISION array, !> dimension (N = NL+NR+1). !> On entry D(1:NL,1:NL) contains the singular values of the !> upper block; and D(NL+2:N) contains the singular values of !> the lower block. On exit D(1:N) contains the singular values !> of the modified matrix. !>
[in,out]	ALPHA	!> ALPHA is DOUBLE PRECISION !> Contains the diagonal element associated with the added row. !>
[in,out]	BETA	!> BETA is DOUBLE PRECISION !> Contains the off-diagonal element associated with the added !> row. !>
[in,out]	U	!> U is DOUBLE PRECISION array, dimension(LDU,N) !> On entry U(1:NL, 1:NL) contains the left singular vectors of !> the upper block; U(NL+2:N, NL+2:N) contains the left singular !> vectors of the lower block. On exit U contains the left !> singular vectors of the bidiagonal matrix. !>
[in]	LDU	!> LDU is INTEGER !> The leading dimension of the array U. LDU >= max( 1, N ). !>
[in,out]	VT	!> VT is DOUBLE PRECISION array, dimension(LDVT,M) !> where M = N + SQRE. !> On entry VT(1:NL+1, 1:NL+1)**T contains the right singular !> vectors of the upper block; VT(NL+2:M, NL+2:M)**T contains !> the right singular vectors of the lower block. On exit !> VT**T contains the right singular vectors of the !> bidiagonal matrix. !>
[in]	LDVT	!> LDVT is INTEGER !> The leading dimension of the array VT. LDVT >= max( 1, M ). !>
[in,out]	IDXQ	!> IDXQ is INTEGER array, dimension(N) !> This contains the permutation which will reintegrate the !> subproblem just solved back into sorted order, i.e. !> D( IDXQ( I = 1, N ) ) will be in ascending order. !>
[out]	IWORK	!> IWORK is INTEGER array, dimension( 4 * N ) !>
[out]	WORK	!> WORK is DOUBLE PRECISION array, dimension( 3*M**2 + 2*M ) !>
[out]	INFO	!> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, the i-th argument had an illegal value. !> > 0: if INFO = 1, a singular value did not converge !>

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