zlals0()

subroutine zlals0	(	integer	icompq,
		integer	nl,
		integer	nr,
		integer	sqre,
		integer	nrhs,
		complex*16, dimension( ldb, * )	b,
		integer	ldb,
		complex*16, dimension( ldbx, * )	bx,
		integer	ldbx,
		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( ldgnum, * )	difr,
		double precision, dimension( * )	z,
		integer	k,
		double precision	c,
		double precision	s,
		double precision, dimension( * )	rwork,
		integer	info )

ZLALS0 applies back multiplying factors in solving the least squares problem using divide and conquer SVD approach. Used by sgelsd.

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

Purpose:

!>
!> ZLALS0 applies back the multiplying factors of either the left or the
!> right singular vector matrix of a diagonal matrix appended by a row
!> to the right hand side matrix B in solving the least squares problem
!> using the divide-and-conquer SVD approach.
!>
!> For the left singular vector matrix, three types of orthogonal
!> matrices are involved:
!>
!> (1L) Givens rotations: the number of such rotations is GIVPTR; the
!>      pairs of columns/rows they were applied to are stored in GIVCOL;
!>      and the C- and S-values of these rotations are stored in GIVNUM.
!>
!> (2L) Permutation. The (NL+1)-st row of B is to be moved to the first
!>      row, and for J=2:N, PERM(J)-th row of B is to be moved to the
!>      J-th row.
!>
!> (3L) The left singular vector matrix of the remaining matrix.
!>
!> For the right singular vector matrix, four types of orthogonal
!> matrices are involved:
!>
!> (1R) The right singular vector matrix of the remaining matrix.
!>
!> (2R) If SQRE = 1, one extra Givens rotation to generate the right
!>      null space.
!>
!> (3R) The inverse transformation of (2L).
!>
!> (4R) The inverse transformation of (1L).
!> 

Parameters

[in]	ICOMPQ	!> ICOMPQ is INTEGER !> Specifies whether singular vectors are to be computed in !> factored form: !> = 0: Left singular vector matrix. !> = 1: Right singular vector matrix. !>
[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]	NRHS	!> NRHS is INTEGER !> The number of columns of B and BX. NRHS must be at least 1. !>
[in,out]	B	!> B is COMPLEX*16 array, dimension ( LDB, NRHS ) !> On input, B contains the right hand sides of the least !> squares problem in rows 1 through M. On output, B contains !> the solution X in rows 1 through N. !>
[in]	LDB	!> LDB is INTEGER !> The leading dimension of B. LDB must be at least !> max(1,MAX( M, N ) ). !>
[out]	BX	!> BX is COMPLEX*16 array, dimension ( LDBX, NRHS ) !>
[in]	LDBX	!> LDBX is INTEGER !> The leading dimension of BX. !>
[in]	PERM	!> PERM is INTEGER array, dimension ( N ) !> The permutations (from deflation and sorting) applied !> to the two blocks. !>
[in]	GIVPTR	!> GIVPTR is INTEGER !> The number of Givens rotations which took place in this !> subproblem. !>
[in]	GIVCOL	!> GIVCOL is INTEGER array, dimension ( LDGCOL, 2 ) !> Each pair of numbers indicates a pair of rows/columns !> involved in a Givens rotation. !>
[in]	LDGCOL	!> LDGCOL is INTEGER !> The leading dimension of GIVCOL, must be at least N. !>
[in]	GIVNUM	!> GIVNUM is DOUBLE PRECISION array, dimension ( LDGNUM, 2 ) !> Each number indicates the C or S value used in the !> corresponding Givens rotation. !>
[in]	LDGNUM	!> LDGNUM is INTEGER !> The leading dimension of arrays DIFR, POLES and !> GIVNUM, must be at least K. !>
[in]	POLES	!> POLES is DOUBLE PRECISION array, dimension ( LDGNUM, 2 ) !> On entry, POLES(1:K, 1) contains the new singular !> values obtained from solving the secular equation, and !> POLES(1:K, 2) is an array containing the poles in the secular !> equation. !>
[in]	DIFL	!> DIFL is DOUBLE PRECISION array, dimension ( K ). !> On entry, DIFL(I) is the distance between I-th updated !> (undeflated) singular value and the I-th (undeflated) old !> singular value. !>
[in]	DIFR	!> DIFR is DOUBLE PRECISION array, dimension ( LDGNUM, 2 ). !> On entry, DIFR(I, 1) contains the distances between I-th !> updated (undeflated) singular value and the I+1-th !> (undeflated) old singular value. And DIFR(I, 2) is the !> normalizing factor for the I-th right singular vector. !>
[in]	Z	!> Z is DOUBLE PRECISION array, dimension ( K ) !> Contain the components of the deflation-adjusted updating row !> vector. !>
[in]	K	!> K is INTEGER !> Contains the dimension of the non-deflated matrix, !> This is the order of the related secular equation. 1 <= K <=N. !>
[in]	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. !>
[in]	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]	RWORK	!> RWORK is DOUBLE PRECISION array, dimension !> ( K*(1+NRHS) + 2*NRHS ) !>
[out]	INFO	!> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, the i-th argument had an illegal value. !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors:

Ming Gu and Ren-Cang Li, Computer Science Division, University of California at Berkeley, USA
Osni Marques, LBNL/NERSC, USA