SRC/zgsvj0.f(3)            Library Functions Manual            SRC/zgsvj0.f(3)

NAME
       SRC/zgsvj0.f

SYNOPSIS
   Functions/Subroutines
       subroutine zgsvj0 (jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin,
           tol, nsweep, work, lwork, info)
            ZGSVJ0 pre-processor for the routine zgesvj.

Function/Subroutine Documentation
   subroutine zgsvj0 (character*1 jobv, integer m, integer n, complex*16,
       dimension( lda, * ) a, integer lda, complex*16, dimension( n ) d,
       double precision, dimension( n ) sva, integer mv, complex*16,
       dimension( ldv, * ) v, integer ldv, double precision eps, double
       precision sfmin, double precision tol, integer nsweep, complex*16,
       dimension( lwork ) work, integer lwork, integer info)
        ZGSVJ0 pre-processor for the routine zgesvj.

       Purpose:


           !>
           !> ZGSVJ0 is called from ZGESVJ as a pre-processor and that is its main
           !> purpose. It applies Jacobi rotations in the same way as ZGESVJ does, but
           !> it does not check convergence (stopping criterion). Few tuning
           !> parameters (marked by [TP]) are available for the implementer.
           !>

       Parameters
           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.
           !>

           M

           !>          M is INTEGER
           !>          The number of rows of the input matrix A.  M >= 0.
           !>

           N

           !>          N is INTEGER
           !>          The number of columns of the input matrix A.
           !>          M >= N >= 0.
           !>

           A

           !>          A is COMPLEX*16 array, dimension (LDA,N)
           !>          On entry, M-by-N matrix A, such that A*diag(D) represents
           !>          the input matrix.
           !>          On exit,
           !>          A_onexit * diag(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 D, TOL and NSWEEP.)
           !>

           LDA

           !>          LDA is INTEGER
           !>          The leading dimension of the array A.  LDA >= max(1,M).
           !>

           D

           !>          D is COMPLEX*16 array, dimension (N)
           !>          The array D accumulates the scaling factors from the complex 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 A, TOL and NSWEEP.)
           !>

           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 A_onexit*diag(D_onexit).
           !>

           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.
           !>

           V

           !>          V is COMPLEX*16 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.
           !>

           LDV

           !>          LDV is INTEGER
           !>          The leading dimension of the array V,  LDV >= 1.
           !>          If JOBV = 'V', LDV >= N.
           !>          If JOBV = 'A', LDV >= MV.
           !>

           EPS

           !>          EPS is DOUBLE PRECISION
           !>          EPS = DLAMCH('Epsilon')
           !>

           SFMIN

           !>          SFMIN is DOUBLE PRECISION
           !>          SFMIN = DLAMCH('Safe Minimum')
           !>

           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 ABS(COS(angle(A(:,p),A(:,q)))) > TOL.
           !>

           NSWEEP

           !>          NSWEEP is INTEGER
           !>          NSWEEP is the number of sweeps of Jacobi rotations to be
           !>          performed.
           !>

           WORK

           !>          WORK is COMPLEX*16 array, dimension (LWORK)
           !>

           LWORK

           !>          LWORK is INTEGER
           !>          LWORK is the dimension of WORK. LWORK >= M.
           !>

           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.

       Further Details:
           ZGSVJ0 is used just to enable ZGESVJ to call a simplified version
           of itself to work on a submatrix of the original matrix.

       Contributor: Zlatko Drmac (Zagreb, Croatia)


       Bugs, Examples and Comments:
           Please report all bugs and send interesting test examples and
           comments to drmac@math.hr. Thank you.

       Definition at line 216 of file zgsvj0.f.

Author
       Generated automatically by Doxygen for LAPACK from the source code.

LAPACK                          Version 3.12.0                 SRC/zgsvj0.f(3)