dgsvj1()

subroutine dgsvj1	(	character*1	jobv,
		integer	m,
		integer	n,
		integer	n1,
		double precision, dimension( lda, * )	a,
		integer	lda,
		double precision, dimension( n )	d,
		double precision, dimension( n )	sva,
		integer	mv,
		double precision, dimension( ldv, * )	v,
		integer	ldv,
		double precision	eps,
		double precision	sfmin,
		double precision	tol,
		integer	nsweep,
		double precision, dimension( lwork )	work,
		integer	lwork,
		integer	info )

DGSVJ1 pre-processor for the routine dgesvj, applies Jacobi rotations targeting only particular pivots.

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

Purpose:

!>
!> DGSVJ1 is called from DGESVJ as a pre-processor and that is its main
!> purpose. It applies Jacobi rotations in the same way as DGESVJ does, but
!> it targets only particular pivots and it does not check convergence
!> (stopping criterion). Few tuning parameters (marked by [TP]) are
!> available for the implementer.
!>
!> Further Details
!> ~~~~~~~~~~~~~~~
!> DGSVJ1 applies few sweeps of Jacobi rotations in the column space of
!> the input M-by-N matrix A. The pivot pairs are taken from the (1,2)
!> off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The
!> block-entries (tiles) of the (1,2) off-diagonal block are marked by the
!> [x]'s in the following scheme:
!>
!>    | *  *  * [x] [x] [x]|
!>    | *  *  * [x] [x] [x]|    Row-cycling in the nblr-by-nblc [x] blocks.
!>    | *  *  * [x] [x] [x]|    Row-cyclic pivoting inside each [x] block.
!>    |[x] [x] [x] *  *  * |
!>    |[x] [x] [x] *  *  * |
!>    |[x] [x] [x] *  *  * |
!>
!> In terms of the columns of A, the first N1 columns are rotated 'against'
!> the remaining N-N1 columns, trying to increase the angle between the
!> corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is
!> tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter.
!> The number of sweeps is given in NSWEEP and the orthogonality threshold
!> is given in TOL.
!> 

Parameters

[in]	JOBV	!> JOBV is CHARACTER*1 !> Specifies whether the output from this procedure is used !> to compute the matrix V: !> = 'V': the product of the Jacobi rotations is accumulated !> by postmultiplying the N-by-N array V. !> (See the description of V.) !> = 'A': the product of the Jacobi rotations is accumulated !> by postmultiplying the MV-by-N array V. !> (See the descriptions of MV and V.) !> = 'N': the Jacobi rotations are not accumulated. !>
[in]	M	!> M is INTEGER !> The number of rows of the input matrix A. M >= 0. !>
[in]	N	!> N is INTEGER !> The number of columns of the input matrix A. !> M >= N >= 0. !>
[in]	N1	!> N1 is INTEGER !> N1 specifies the 2 x 2 block partition, the first N1 columns are !> rotated 'against' the remaining N-N1 columns of A. !>
[in,out]	A	!> A is DOUBLE PRECISION array, dimension (LDA,N) !> On entry, M-by-N matrix A, such that A*diag(D) represents !> the input matrix. !> On exit, !> A_onexit * D_onexit represents the input matrix A*diag(D) !> post-multiplied by a sequence of Jacobi rotations, where the !> rotation threshold and the total number of sweeps are given in !> TOL and NSWEEP, respectively. !> (See the descriptions of N1, D, TOL and NSWEEP.) !>
[in]	LDA	!> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !>
[in,out]	D	!> D is DOUBLE PRECISION array, dimension (N) !> The array D accumulates the scaling factors from the fast scaled !> Jacobi rotations. !> On entry, A*diag(D) represents the input matrix. !> On exit, A_onexit*diag(D_onexit) represents the input matrix !> post-multiplied by a sequence of Jacobi rotations, where the !> rotation threshold and the total number of sweeps are given in !> TOL and NSWEEP, respectively. !> (See the descriptions of N1, A, TOL and NSWEEP.) !>
[in,out]	SVA	!> SVA is DOUBLE PRECISION array, dimension (N) !> On entry, SVA contains the Euclidean norms of the columns of !> the matrix A*diag(D). !> On exit, SVA contains the Euclidean norms of the columns of !> the matrix onexit*diag(D_onexit). !>
[in]	MV	!> MV is INTEGER !> If JOBV = 'A', then MV rows of V are post-multiplied by a !> sequence of Jacobi rotations. !> If JOBV = 'N', then MV is not referenced. !>
[in,out]	V	!> V is DOUBLE PRECISION array, dimension (LDV,N) !> If JOBV = 'V', then N rows of V are post-multiplied by a !> sequence of Jacobi rotations. !> If JOBV = 'A', then MV rows of V are post-multiplied by a !> sequence of Jacobi rotations. !> If JOBV = 'N', then V is not referenced. !>
[in]	LDV	!> LDV is INTEGER !> The leading dimension of the array V, LDV >= 1. !> If JOBV = 'V', LDV >= N. !> If JOBV = 'A', LDV >= MV. !>
[in]	EPS	!> EPS is DOUBLE PRECISION !> EPS = DLAMCH('Epsilon') !>
[in]	SFMIN	!> SFMIN is DOUBLE PRECISION !> SFMIN = DLAMCH('Safe Minimum') !>
[in]	TOL	!> TOL is DOUBLE PRECISION !> TOL is the threshold for Jacobi rotations. For a pair !> A(:,p), A(:,q) of pivot columns, the Jacobi rotation is !> applied only if DABS(COS(angle(A(:,p),A(:,q)))) > TOL. !>
[in]	NSWEEP	!> NSWEEP is INTEGER !> NSWEEP is the number of sweeps of Jacobi rotations to be !> performed. !>
[out]	WORK	!> WORK is DOUBLE PRECISION array, dimension (LWORK) !>
[in]	LWORK	!> LWORK is INTEGER !> LWORK is the dimension of WORK. LWORK >= M. !>
[out]	INFO	!> INFO is INTEGER !> = 0: successful exit. !> < 0: if INFO = -i, then the i-th argument had an illegal value !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors:

Zlatko Drmac (Zagreb, Croatia) and Kresimir Veselic (Hagen, Germany)