slasd6()

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

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

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

Purpose:

!>
!> SLASD6 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, SLASD1, handles the case in which all singular
!> values and singular vectors of the bidiagonal matrix are desired.
!>
!> SLASD6 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 SLASD6. 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 SLASD7.
!>
!>       The second stage consists of calculating the updated
!>       singular values. This is done by finding the roots of the
!>       secular equation via the routine SLASD4 (as called by SLASD8).
!>       This routine also updates VF and VL and computes the distances
!>       between the updated singular values and the old singular
!>       values.
!>
!> SLASD6 is called from SLASDA.
!> 

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 REAL 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 REAL 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 REAL 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 REAL !> Contains the diagonal element associated with the added row. !>
[in,out]	BETA	!> BETA is REAL !> 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 REAL 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 REAL 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 REAL 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 REAL 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 SLASD8 for details on DIFL and DIFR. !>
[out]	Z	!> Z is REAL 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 REAL !> 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 REAL !> 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 REAL 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

Definition at line 307 of file slasd6.f.

*
*  -- LAPACK auxiliary routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      INTEGER            GIVPTR, ICOMPQ, INFO, K, LDGCOL, LDGNUM, NL,
     $                   NR, SQRE
      REAL               ALPHA, BETA, C, S
*     ..
*     .. Array Arguments ..
      INTEGER            GIVCOL( LDGCOL, * ), IDXQ( * ), IWORK( * ),
     $                   PERM( * )
      REAL               D( * ), DIFL( * ), DIFR( * ),
     $                   GIVNUM( LDGNUM, * ), POLES( LDGNUM, * ),
     $                   VF( * ), VL( * ), WORK( * ), Z( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               ONE, ZERO
      parameter( one = 1.0e+0, zero = 0.0e+0 )
*     ..
*     .. Local Scalars ..
      INTEGER            I, IDX, IDXC, IDXP, ISIGMA, IVFW, IVLW, IW, M,
     $                   N, N1, N2
      REAL               ORGNRM
*     ..
*     .. External Subroutines ..
      EXTERNAL           scopy, slamrg, slascl, slasd7, slasd8,
     $                   xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, max
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters.
*
      info = 0
      n = nl + nr + 1
      m = n + sqre
*
      IF( ( icompq.LT.0 ) .OR. ( icompq.GT.1 ) ) THEN
         info = -1
      ELSE IF( nl.LT.1 ) THEN
         info = -2
      ELSE IF( nr.LT.1 ) THEN
         info = -3
      ELSE IF( ( sqre.LT.0 ) .OR. ( sqre.GT.1 ) ) THEN
         info = -4
      ELSE IF( ldgcol.LT.n ) THEN
         info = -14
      ELSE IF( ldgnum.LT.n ) THEN
         info = -16
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'SLASD6', -info )
         RETURN
      END IF
*
*     The following values are for bookkeeping purposes only.  They are
*     integer pointers which indicate the portion of the workspace
*     used by a particular array in SLASD7 and SLASD8.
*
      isigma = 1
      iw = isigma + n
      ivfw = iw + m
      ivlw = ivfw + m
*
      idx = 1
      idxc = idx + n
      idxp = idxc + n
*
*     Scale.
*
      orgnrm = max( abs( alpha ), abs( beta ) )
      d( nl+1 ) = zero
      DO 10 i = 1, n
         IF( abs( d( i ) ).GT.orgnrm ) THEN
            orgnrm = abs( d( i ) )
         END IF
   10 CONTINUE
      CALL slascl( 'G', 0, 0, orgnrm, one, n, 1, d, n, info )
      alpha = alpha / orgnrm
      beta = beta / orgnrm
*
*     Sort and Deflate singular values.
*
      CALL slasd7( icompq, nl, nr, sqre, k, d, z, work( iw ), vf,
     $             work( ivfw ), vl, work( ivlw ), alpha, beta,
     $             work( isigma ), iwork( idx ), iwork( idxp ), idxq,
     $             perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s,
     $             info )
*
*     Solve Secular Equation, compute DIFL, DIFR, and update VF, VL.
*
      CALL slasd8( icompq, k, d, z, vf, vl, difl, difr, ldgnum,
     $             work( isigma ), work( iw ), info )
*
*     Report the possible convergence failure.
*
      IF( info.NE.0 ) THEN
         RETURN
      END IF
*
*     Save the poles if ICOMPQ = 1.
*
      IF( icompq.EQ.1 ) THEN
         CALL scopy( k, d, 1, poles( 1, 1 ), 1 )
         CALL scopy( k, work( isigma ), 1, poles( 1, 2 ), 1 )
      END IF
*
*     Unscale.
*
      CALL slascl( 'G', 0, 0, one, orgnrm, n, 1, d, n, info )
*
*     Prepare the IDXQ sorting permutation.
*
      n1 = k
      n2 = n - k
      CALL slamrg( n1, n2, d, 1, -1, idxq )
*
      RETURN
*
*     End of SLASD6
*

Here is the call graph for this function:

Here is the caller graph for this function: