zckgsv()

subroutine zckgsv	(	integer	nm,
		integer, dimension( * )	mval,
		integer, dimension( * )	pval,
		integer, dimension( * )	nval,
		integer	nmats,
		integer, dimension( 4 )	iseed,
		double precision	thresh,
		integer	nmax,
		complex*16, dimension( * )	a,
		complex*16, dimension( * )	af,
		complex*16, dimension( * )	b,
		complex*16, dimension( * )	bf,
		complex*16, dimension( * )	u,
		complex*16, dimension( * )	v,
		complex*16, dimension( * )	q,
		double precision, dimension( * )	alpha,
		double precision, dimension( * )	beta,
		complex*16, dimension( * )	r,
		integer, dimension( * )	iwork,
		complex*16, dimension( * )	work,
		double precision, dimension( * )	rwork,
		integer	nin,
		integer	nout,
		integer	info )

ZCKGSV

Purpose:

!>
!> ZCKGSV tests ZGGSVD:
!>        the GSVD for M-by-N matrix A and P-by-N matrix B.
!> 

Parameters

[in]	NM	!> NM is INTEGER !> The number of values of M contained in the vector MVAL. !>
[in]	MVAL	!> MVAL is INTEGER array, dimension (NM) !> The values of the matrix row dimension M. !>
[in]	PVAL	!> PVAL is INTEGER array, dimension (NP) !> The values of the matrix row dimension P. !>
[in]	NVAL	!> NVAL is INTEGER array, dimension (NN) !> The values of the matrix column dimension N. !>
[in]	NMATS	!> NMATS is INTEGER !> The number of matrix types to be tested for each combination !> of matrix dimensions. If NMATS >= NTYPES (the maximum !> number of matrix types), then all the different types are !> generated for testing. If NMATS < NTYPES, another input line !> is read to get the numbers of the matrix types to be used. !>
[in,out]	ISEED	!> ISEED is INTEGER array, dimension (4) !> On entry, the seed of the random number generator. The array !> elements should be between 0 and 4095, otherwise they will be !> reduced mod 4096, and ISEED(4) must be odd. !> On exit, the next seed in the random number sequence after !> all the test matrices have been generated. !>
[in]	THRESH	!> THRESH is DOUBLE PRECISION !> The threshold value for the test ratios. A result is !> included in the output file if RESULT >= THRESH. To have !> every test ratio printed, use THRESH = 0. !>
[in]	NMAX	!> NMAX is INTEGER !> The maximum value permitted for M or N, used in dimensioning !> the work arrays. !>
[out]	A	!> A is COMPLEX*16 array, dimension (NMAX*NMAX) !>
[out]	AF	!> AF is COMPLEX*16 array, dimension (NMAX*NMAX) !>
[out]	B	!> B is COMPLEX*16 array, dimension (NMAX*NMAX) !>
[out]	BF	!> BF is COMPLEX*16 array, dimension (NMAX*NMAX) !>
[out]	U	!> U is COMPLEX*16 array, dimension (NMAX*NMAX) !>
[out]	V	!> V is COMPLEX*16 array, dimension (NMAX*NMAX) !>
[out]	Q	!> Q is COMPLEX*16 array, dimension (NMAX*NMAX) !>
[out]	ALPHA	!> ALPHA is DOUBLE PRECISION array, dimension (NMAX) !>
[out]	BETA	!> BETA is DOUBLE PRECISION array, dimension (NMAX) !>
[out]	R	!> R is COMPLEX*16 array, dimension (NMAX*NMAX) !>
[out]	IWORK	!> IWORK is INTEGER array, dimension (NMAX) !>
[out]	WORK	!> WORK is COMPLEX*16 array, dimension (NMAX*NMAX) !>
[out]	RWORK	!> RWORK is DOUBLE PRECISION array, dimension (NMAX) !>
[in]	NIN	!> NIN is INTEGER !> The unit number for input. !>
[in]	NOUT	!> NOUT is INTEGER !> The unit number for output. !>
[out]	INFO	!> INFO is INTEGER !> = 0 : successful exit !> > 0 : If ZLATMS returns an error code, the absolute value !> of it is returned. !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 195 of file zckgsv.f.

*
*  -- LAPACK test 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            INFO, NIN, NM, NMATS, NMAX, NOUT
      DOUBLE PRECISION   THRESH
*     ..
*     .. Array Arguments ..
      INTEGER            ISEED( 4 ), IWORK( * ), MVAL( * ), NVAL( * ),
     $                   PVAL( * )
      DOUBLE PRECISION   ALPHA( * ), BETA( * ), RWORK( * )
      COMPLEX*16         A( * ), AF( * ), B( * ), BF( * ), Q( * ),
     $                   R( * ), U( * ), V( * ), WORK( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            NTESTS
      parameter( ntests = 12 )
      INTEGER            NTYPES
      parameter( ntypes = 8 )
*     ..
*     .. Local Scalars ..
      LOGICAL            FIRSTT
      CHARACTER          DISTA, DISTB, TYPE
      CHARACTER*3        PATH
      INTEGER            I, IINFO, IM, IMAT, KLA, KLB, KUA, KUB, LDA,
     $                   LDB, LDQ, LDR, LDU, LDV, LWORK, M, MODEA,
     $                   MODEB, N, NFAIL, NRUN, NT, P
      DOUBLE PRECISION   ANORM, BNORM, CNDNMA, CNDNMB
*     ..
*     .. Local Arrays ..
      LOGICAL            DOTYPE( NTYPES )
      DOUBLE PRECISION   RESULT( NTESTS )
*     ..
*     .. External Subroutines ..
      EXTERNAL           alahdg, alareq, alasum, dlatb9, zgsvts3, zlatms
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs
*     ..
*     .. Executable Statements ..
*
*     Initialize constants and the random number seed.
*
      path( 1: 3 ) = 'GSV'
      info = 0
      nrun = 0
      nfail = 0
      firstt = .true.
      CALL alareq( path, nmats, dotype, ntypes, nin, nout )
      lda = nmax
      ldb = nmax
      ldu = nmax
      ldv = nmax
      ldq = nmax
      ldr = nmax
      lwork = nmax*nmax
*
*     Do for each value of M in MVAL.
*
      DO 30 im = 1, nm
         m = mval( im )
         p = pval( im )
         n = nval( im )
*
         DO 20 imat = 1, ntypes
*
*           Do the tests only if DOTYPE( IMAT ) is true.
*
            IF( .NOT.dotype( imat ) )
     $         GO TO 20
*
*           Set up parameters with DLATB9 and generate test
*           matrices A and B with ZLATMS.
*
            CALL dlatb9( path, imat, m, p, n, TYPE, KLA, KUA, KLB, KUB,
     $                   ANORM, BNORM, MODEA, MODEB, CNDNMA, CNDNMB,
     $                   DISTA, DISTB )
*
*           Generate M by N matrix A
*
            CALL zlatms( m, n, dista, iseed, TYPE, RWORK, MODEA, CNDNMA,
     $                   ANORM, KLA, KUA, 'No packing', A, LDA, WORK,
     $                   IINFO )
            IF( iinfo.NE.0 ) THEN
               WRITE( nout, fmt = 9999 )iinfo
               info = abs( iinfo )
               GO TO 20
            END IF
*
*           Generate P by N matrix B
*
            CALL zlatms( p, n, distb, iseed, TYPE, RWORK, MODEB, CNDNMB,
     $                   BNORM, KLB, KUB, 'No packing', B, LDB, WORK,
     $                   IINFO )
            IF( iinfo.NE.0 ) THEN
               WRITE( nout, fmt = 9999 )iinfo
               info = abs( iinfo )
               GO TO 20
            END IF
*
            nt = 6
*
            CALL zgsvts3( m, p, n, a, af, lda, b, bf, ldb, u, ldu, v,
     $                    ldv, q, ldq, alpha, beta, r, ldr, iwork, work,
     $                    lwork, rwork, result )
*
*           Print information about the tests that did not
*           pass the threshold.
*
            DO 10 i = 1, nt
               IF( result( i ).GE.thresh ) THEN
                  IF( nfail.EQ.0 .AND. firstt ) THEN
                     firstt = .false.
                     CALL alahdg( nout, path )
                  END IF
                  WRITE( nout, fmt = 9998 )m, p, n, imat, i,
     $               result( i )
                  nfail = nfail + 1
               END IF
   10       CONTINUE
            nrun = nrun + nt
*
   20    CONTINUE
   30 CONTINUE
*
*     Print a summary of the results.
*
      CALL alasum( path, nout, nfail, nrun, 0 )
*
 9999 FORMAT( ' ZLATMS in ZCKGSV   INFO = ', i5 )
 9998 FORMAT( ' M=', i4, ' P=', i4, ', N=', i4, ', type ', i2,
     $      ', test ', i2, ', ratio=', g13.6 )
      RETURN
*
*     End of ZCKGSV
*

Here is the call graph for this function:

Here is the caller graph for this function: