dlasd6()

subroutine dlasd6	(	integer	icompq,
		integer	nl,
		integer	nr,
		integer	sqre,
		double precision, dimension( * )	d,
		double precision, dimension( * )	vf,
		double precision, dimension( * )	vl,
		double precision	alpha,
		double precision	beta,
		integer, dimension( * )	idxq,
		integer, dimension( * )	perm,
		integer	givptr,
		integer, dimension( ldgcol, * )	givcol,
		integer	ldgcol,
		double precision, dimension( ldgnum, * )	givnum,
		integer	ldgnum,
		double precision, dimension( ldgnum, * )	poles,
		double precision, dimension( * )	difl,
		double precision, dimension( * )	difr,
		double precision, dimension( * )	z,
		integer	k,
		double precision	c,
		double precision	s,
		double precision, dimension( * )	work,
		integer, dimension( * )	iwork,
		integer	info )

DLASD6 computes the SVD of an updated upper bidiagonal matrix obtained by merging two smaller ones by appending a row. Used by sbdsdc.

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

Purpose:

!>
!> DLASD6 computes the SVD of an updated upper bidiagonal matrix B
!> obtained by merging two smaller ones by appending a row. This
!> routine is used only for the problem which requires all singular
!> values and optionally singular vector matrices in factored form.
!> B is an N-by-M matrix with N = NL + NR + 1 and M = N + SQRE.
!> A related subroutine, DLASD1, handles the case in which all singular
!> values and singular vectors of the bidiagonal matrix are desired.
!>
!> DLASD6 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 singular values of B can be computed using D1, D2, the first
!> components of all the right singular vectors of the lower block, and
!> the last components of all the right singular vectors of the upper
!> block. These components are stored and updated in VF and VL,
!> respectively, in DLASD6. Hence U and VT are not explicitly
!> referenced.
!>
!> The singular values are stored in D. The algorithm consists of two
!> stages:
!>
!>       The first stage consists of deflating the size of the problem
!>       when there are multiple singular values or if there is a zero
!>       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 DLASD7.
!>
!>       The second stage consists of calculating the updated
!>       singular values. This is done by finding the roots of the
!>       secular equation via the routine DLASD4 (as called by DLASD8).
!>       This routine also updates VF and VL and computes the distances
!>       between the updated singular values and the old singular
!>       values.
!>
!> DLASD6 is called from DLASDA.
!> 

Parameters

[in]	ICOMPQ	!> ICOMPQ is INTEGER !> Specifies whether singular vectors are to be computed in !> factored form: !> = 0: Compute singular values only. !> = 1: Compute singular vectors in factored form as well. !>
[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 ( 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]	VF	!> VF is DOUBLE PRECISION array, dimension ( M ) !> On entry, VF(1:NL+1) contains the first components of all !> right singular vectors of the upper block; and VF(NL+2:M) !> contains the first components of all right singular vectors !> of the lower block. On exit, VF contains the first components !> of all right singular vectors of the bidiagonal matrix. !>
[in,out]	VL	!> VL is DOUBLE PRECISION array, dimension ( M ) !> On entry, VL(1:NL+1) contains the last components of all !> right singular vectors of the upper block; and VL(NL+2:M) !> contains the last components of all right singular vectors of !> the lower block. On exit, VL contains the last components of !> all right singular vectors of the bidiagonal 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]	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]	PERM	!> PERM is INTEGER array, dimension ( N ) !> The permutations (from deflation and sorting) to be applied !> to each block. Not referenced if ICOMPQ = 0. !>
[out]	GIVPTR	!> GIVPTR is INTEGER !> The number of Givens rotations which took place in this !> subproblem. Not referenced if ICOMPQ = 0. !>
[out]	GIVCOL	!> GIVCOL is INTEGER array, dimension ( LDGCOL, 2 ) !> Each pair of numbers indicates a pair of columns to take place !> in a Givens rotation. Not referenced if ICOMPQ = 0. !>
[in]	LDGCOL	!> LDGCOL is INTEGER !> leading dimension of GIVCOL, must be at least N. !>
[out]	GIVNUM	!> GIVNUM is DOUBLE PRECISION array, dimension ( LDGNUM, 2 ) !> Each number indicates the C or S value to be used in the !> corresponding Givens rotation. Not referenced if ICOMPQ = 0. !>
[in]	LDGNUM	!> LDGNUM is INTEGER !> The leading dimension of GIVNUM and POLES, must be at least N. !>
[out]	POLES	!> POLES is DOUBLE PRECISION array, dimension ( LDGNUM, 2 ) !> On exit, POLES(1,*) is an array containing the new singular !> values obtained from solving the secular equation, and !> POLES(2,*) is an array containing the poles in the secular !> equation. Not referenced if ICOMPQ = 0. !>
[out]	DIFL	!> DIFL is DOUBLE PRECISION array, dimension ( N ) !> On exit, DIFL(I) is the distance between I-th updated !> (undeflated) singular value and the I-th (undeflated) old !> singular value. !>
[out]	DIFR	!> DIFR is DOUBLE PRECISION array, !> dimension ( LDDIFR, 2 ) if ICOMPQ = 1 and !> dimension ( K ) if ICOMPQ = 0. !> On exit, DIFR(I,1) = D(I) - DSIGMA(I+1), DIFR(K,1) is not !> defined and will not be referenced. !> !> If ICOMPQ = 1, DIFR(1:K,2) is an array containing the !> normalizing factors for the right singular vector matrix. !> !> See DLASD8 for details on DIFL and DIFR. !>
[out]	Z	!> Z is DOUBLE PRECISION array, dimension ( M ) !> The first elements of this array contain the components !> of the deflation-adjusted updating row vector. !>
[out]	K	!> K is INTEGER !> Contains the dimension of the non-deflated matrix, !> This is the order of the related secular equation. 1 <= K <=N. !>
[out]	C	!> C is DOUBLE PRECISION !> C contains garbage if SQRE =0 and the C-value of a Givens !> rotation related to the right null space if SQRE = 1. !>
[out]	S	!> S is DOUBLE PRECISION !> S contains garbage if SQRE =0 and the S-value of a Givens !> rotation related to the right null space if SQRE = 1. !>
[out]	WORK	!> WORK is DOUBLE PRECISION array, dimension ( 4 * M ) !>
[out]	IWORK	!> IWORK is INTEGER array, dimension ( 3 * N ) !>
[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