cdrvbd.f

Go to the documentation of this file.

*> \brief \b CDRVBD
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at 
*            http://www.netlib.org/lapack/explore-html/ 
*
*  Definition:
*  ===========
*
*       SUBROUTINE CDRVBD( NSIZES, MM, NN, NTYPES, DOTYPE, ISEED, THRESH,
*                          A, LDA, U, LDU, VT, LDVT, ASAV, USAV, VTSAV, S,
*                          SSAV, E, WORK, LWORK, RWORK, IWORK, NOUNIT,
*                          INFO )
* 
*       .. Scalar Arguments ..
*       INTEGER            INFO, LDA, LDU, LDVT, LWORK, NOUNIT, NSIZES,
*      $                   NTYPES
*       REAL               THRESH
*       ..
*       .. Array Arguments ..
*       LOGICAL            DOTYPE( * )
*       INTEGER            ISEED( 4 ), IWORK( * ), MM( * ), NN( * )
*       REAL               E( * ), RWORK( * ), S( * ), SSAV( * )
*       COMPLEX            A( LDA, * ), ASAV( LDA, * ), U( LDU, * ),
*      $                   USAV( LDU, * ), VT( LDVT, * ),
*      $                   VTSAV( LDVT, * ), WORK( * )
*       ..
*  
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> CDRVBD checks the singular value decomposition (SVD) driver CGESVD
*> and CGESDD.
*> CGESVD and CGESDD factors A = U diag(S) VT, where U and VT are
*> unitary and diag(S) is diagonal with the entries of the array S on
*> its diagonal. The entries of S are the singular values, nonnegative
*> and stored in decreasing order.  U and VT can be optionally not
*> computed, overwritten on A, or computed partially.
*>
*> A is M by N. Let MNMIN = min( M, N ). S has dimension MNMIN.
*> U can be M by M or M by MNMIN. VT can be N by N or MNMIN by N.
*>
*> When CDRVBD is called, a number of matrix "sizes" (M's and N's)
*> and a number of matrix "types" are specified.  For each size (M,N)
*> and each type of matrix, and for the minimal workspace as well as
*> workspace adequate to permit blocking, an  M x N  matrix "A" will be
*> generated and used to test the SVD routines.  For each matrix, A will
*> be factored as A = U diag(S) VT and the following 12 tests computed:
*>
*> Test for CGESVD:
*>
*> (1)   | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (2)   | I - U'U | / ( M ulp )
*>
*> (3)   | I - VT VT' | / ( N ulp )
*>
*> (4)   S contains MNMIN nonnegative values in decreasing order.
*>       (Return 0 if true, 1/ULP if false.)
*>
*> (5)   | U - Upartial | / ( M ulp ) where Upartial is a partially
*>       computed U.
*>
*> (6)   | VT - VTpartial | / ( N ulp ) where VTpartial is a partially
*>       computed VT.
*>
*> (7)   | S - Spartial | / ( MNMIN ulp |S| ) where Spartial is the
*>       vector of singular values from the partial SVD
*>
*> Test for CGESDD:
*>
*> (1)   | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (2)   | I - U'U | / ( M ulp )
*>
*> (3)   | I - VT VT' | / ( N ulp )
*>
*> (4)   S contains MNMIN nonnegative values in decreasing order.
*>       (Return 0 if true, 1/ULP if false.)
*>
*> (5)   | U - Upartial | / ( M ulp ) where Upartial is a partially
*>       computed U.
*>
*> (6)   | VT - VTpartial | / ( N ulp ) where VTpartial is a partially
*>       computed VT.
*>
*> (7)   | S - Spartial | / ( MNMIN ulp |S| ) where Spartial is the
*>       vector of singular values from the partial SVD
*>
*> Test for CGESVJ:
*>
*> (1)   | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (2)   | I - U'U | / ( M ulp )
*>
*> (3)   | I - VT VT' | / ( N ulp )
*>
*> (4)   S contains MNMIN nonnegative values in decreasing order.
*>       (Return 0 if true, 1/ULP if false.)
*>
*> Test for CGEJSV:
*>
*> (1)   | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (2)   | I - U'U | / ( M ulp )
*>
*> (3)   | I - VT VT' | / ( N ulp )
*>
*> (4)   S contains MNMIN nonnegative values in decreasing order.
*>        (Return 0 if true, 1/ULP if false.)
*>
*> Test for CGESVDX( 'V', 'V', 'A' )/CGESVDX( 'N', 'N', 'A' )
*>
*> (1)   | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (2)   | I - U'U | / ( M ulp )
*>
*> (3)   | I - VT VT' | / ( N ulp )
*>
*> (4)   S contains MNMIN nonnegative values in decreasing order.
*>       (Return 0 if true, 1/ULP if false.)
*>
*> (5)   | U - Upartial | / ( M ulp ) where Upartial is a partially
*>       computed U.
*>
*> (6)   | VT - VTpartial | / ( N ulp ) where VTpartial is a partially
*>       computed VT.
*>
*> (7)   | S - Spartial | / ( MNMIN ulp |S| ) where Spartial is the
*>       vector of singular values from the partial SVD
*>      
*> Test for CGESVDX( 'V', 'V', 'I' )
*>
*> (8)   | U' A VT''' - diag(S) | / ( |A| max(M,N) ulp )
*>
*> (9)   | I - U'U | / ( M ulp )
*>
*> (10)  | I - VT VT' | / ( N ulp )
*>      
*> Test for CGESVDX( 'V', 'V', 'V' )
*>
*> (11)   | U' A VT''' - diag(S) | / ( |A| max(M,N) ulp )
*>
*> (12)   | I - U'U | / ( M ulp )
*>
*> (13)   | I - VT VT' | / ( N ulp )
*>
*> The "sizes" are specified by the arrays MM(1:NSIZES) and
*> NN(1:NSIZES); the value of each element pair (MM(j),NN(j))
*> specifies one size.  The "types" are specified by a logical array
*> DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j"
*> will be generated.
*> Currently, the list of possible types is:
*>
*> (1)  The zero matrix.
*> (2)  The identity matrix.
*> (3)  A matrix of the form  U D V, where U and V are unitary and
*>      D has evenly spaced entries 1, ..., ULP with random signs
*>      on the diagonal.
*> (4)  Same as (3), but multiplied by the underflow-threshold / ULP.
*> (5)  Same as (3), but multiplied by the overflow-threshold * ULP.
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] NSIZES
*> \verbatim
*>          NSIZES is INTEGER
*>          The number of sizes of matrices to use.  If it is zero,
*>          CDRVBD does nothing.  It must be at least zero.
*> \endverbatim
*>
*> \param[in] MM
*> \verbatim
*>          MM is INTEGER array, dimension (NSIZES)
*>          An array containing the matrix "heights" to be used.  For
*>          each j=1,...,NSIZES, if MM(j) is zero, then MM(j) and NN(j)
*>          will be ignored.  The MM(j) values must be at least zero.
*> \endverbatim
*>
*> \param[in] NN
*> \verbatim
*>          NN is INTEGER array, dimension (NSIZES)
*>          An array containing the matrix "widths" to be used.  For
*>          each j=1,...,NSIZES, if NN(j) is zero, then MM(j) and NN(j)
*>          will be ignored.  The NN(j) values must be at least zero.
*> \endverbatim
*>
*> \param[in] NTYPES
*> \verbatim
*>          NTYPES is INTEGER
*>          The number of elements in DOTYPE.   If it is zero, CDRVBD
*>          does nothing.  It must be at least zero.  If it is MAXTYP+1
*>          and NSIZES is 1, then an additional type, MAXTYP+1 is
*>          defined, which is to use whatever matrices are in A and B.
*>          This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
*>          DOTYPE(MAXTYP+1) is .TRUE. .
*> \endverbatim
*>
*> \param[in] DOTYPE
*> \verbatim
*>          DOTYPE is LOGICAL array, dimension (NTYPES)
*>          If DOTYPE(j) is .TRUE., then for each size (m,n), a matrix
*>          of type j will be generated.  If NTYPES is smaller than the
*>          maximum number of types defined (PARAMETER MAXTYP), then
*>          types NTYPES+1 through MAXTYP will not be generated.  If
*>          NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through
*>          DOTYPE(NTYPES) will be ignored.
*> \endverbatim
*>
*> \param[in,out] ISEED
*> \verbatim
*>          ISEED is INTEGER array, dimension (4)
*>          On entry ISEED specifies the seed of the random number
*>          generator. The array elements should be between 0 and 4095;
*>          if not they will be reduced mod 4096.  Also, ISEED(4) must
*>          be odd.  The random number generator uses a linear
*>          congruential sequence limited to small integers, and so
*>          should produce machine independent random numbers. The
*>          values of ISEED are changed on exit, and can be used in the
*>          next call to CDRVBD to continue the same random number
*>          sequence.
*> \endverbatim
*>
*> \param[in] THRESH
*> \verbatim
*>          THRESH is REAL
*>          A test will count as "failed" if the "error", computed as
*>          described above, exceeds THRESH.  Note that the error
*>          is scaled to be O(1), so THRESH should be a reasonably
*>          small multiple of 1, e.g., 10 or 100.  In particular,
*>          it should not depend on the precision (single vs. double)
*>          or the size of the matrix.  It must be at least zero.
*> \endverbatim
*>
*> \param[out] A
*> \verbatim
*>          A is COMPLEX array, dimension (LDA,max(NN))
*>          Used to hold the matrix whose singular values are to be
*>          computed.  On exit, A contains the last matrix actually
*>          used.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*>          LDA is INTEGER
*>          The leading dimension of A.  It must be at
*>          least 1 and at least max( MM ).
*> \endverbatim
*>
*> \param[out] U
*> \verbatim
*>          U is COMPLEX array, dimension (LDU,max(MM))
*>          Used to hold the computed matrix of right singular vectors.
*>          On exit, U contains the last such vectors actually computed.
*> \endverbatim
*>
*> \param[in] LDU
*> \verbatim
*>          LDU is INTEGER
*>          The leading dimension of U.  It must be at
*>          least 1 and at least max( MM ).
*> \endverbatim
*>
*> \param[out] VT
*> \verbatim
*>          VT is COMPLEX array, dimension (LDVT,max(NN))
*>          Used to hold the computed matrix of left singular vectors.
*>          On exit, VT contains the last such vectors actually computed.
*> \endverbatim
*>
*> \param[in] LDVT
*> \verbatim
*>          LDVT is INTEGER
*>          The leading dimension of VT.  It must be at
*>          least 1 and at least max( NN ).
*> \endverbatim
*>
*> \param[out] ASAV
*> \verbatim
*>          ASAV is COMPLEX array, dimension (LDA,max(NN))
*>          Used to hold a different copy of the matrix whose singular
*>          values are to be computed.  On exit, A contains the last
*>          matrix actually used.
*> \endverbatim
*>
*> \param[out] USAV
*> \verbatim
*>          USAV is COMPLEX array, dimension (LDU,max(MM))
*>          Used to hold a different copy of the computed matrix of
*>          right singular vectors. On exit, USAV contains the last such
*>          vectors actually computed.
*> \endverbatim
*>
*> \param[out] VTSAV
*> \verbatim
*>          VTSAV is COMPLEX array, dimension (LDVT,max(NN))
*>          Used to hold a different copy of the computed matrix of
*>          left singular vectors. On exit, VTSAV contains the last such
*>          vectors actually computed.
*> \endverbatim
*>
*> \param[out] S
*> \verbatim
*>          S is REAL array, dimension (max(min(MM,NN)))
*>          Contains the computed singular values.
*> \endverbatim
*>
*> \param[out] SSAV
*> \verbatim
*>          SSAV is REAL array, dimension (max(min(MM,NN)))
*>          Contains another copy of the computed singular values.
*> \endverbatim
*>
*> \param[out] E
*> \verbatim
*>          E is REAL array, dimension (max(min(MM,NN)))
*>          Workspace for CGESVD.
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*>          WORK is COMPLEX array, dimension (LWORK)
*> \endverbatim
*>
*> \param[in] LWORK
*> \verbatim
*>          LWORK is INTEGER
*>          The number of entries in WORK.  This must be at least
*>          MAX(3*MIN(M,N)+MAX(M,N)**2,5*MIN(M,N),3*MAX(M,N)) for all
*>          pairs  (M,N)=(MM(j),NN(j))
*> \endverbatim
*>
*> \param[out] RWORK
*> \verbatim
*>          RWORK is REAL array,
*>                      dimension ( 5*max(max(MM,NN)) )
*> \endverbatim
*>
*> \param[out] IWORK
*> \verbatim
*>          IWORK is INTEGER array, dimension at least 8*min(M,N)
*> \endverbatim
*>
*> \param[in] NOUNIT
*> \verbatim
*>          NOUNIT is INTEGER
*>          The FORTRAN unit number for printing out error messages
*>          (e.g., if a routine returns IINFO not equal to 0.)
*> \endverbatim
*>
*> \param[out] INFO
*> \verbatim
*>          INFO is INTEGER
*>          If 0, then everything ran OK.
*>           -1: NSIZES < 0
*>           -2: Some MM(j) < 0
*>           -3: Some NN(j) < 0
*>           -4: NTYPES < 0
*>           -7: THRESH < 0
*>          -10: LDA < 1 or LDA < MMAX, where MMAX is max( MM(j) ).
*>          -12: LDU < 1 or LDU < MMAX.
*>          -14: LDVT < 1 or LDVT < NMAX, where NMAX is max( NN(j) ).
*>          -29: LWORK too small.
*>          If  CLATMS, or CGESVD returns an error code, the
*>              absolute value of it is returned.
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee 
*> \author Univ. of California Berkeley 
*> \author Univ. of Colorado Denver 
*> \author NAG Ltd. 
*
*> \date June 2016
*
*> \ingroup complex_eig
*
*  =====================================================================
      SUBROUTINE cdrvbd( NSIZES, MM, NN, NTYPES, DOTYPE, ISEED, THRESH,
     $                   a, lda, u, ldu, vt, ldvt, asav, usav, vtsav, s,
     $                   ssav, e, work, lwork, rwork, iwork, nounit,
     $                   info )
*
*  -- LAPACK test routine (version 3.6.1) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     June 2016
*
*     .. Scalar Arguments ..
      INTEGER            INFO, LDA, LDU, LDVT, LWORK, NOUNIT, NSIZES,
     $                   ntypes
      REAL               THRESH
*     ..
*     .. Array Arguments ..
      LOGICAL            DOTYPE( * )
      INTEGER            ISEED( 4 ), IWORK( * ), MM( * ), NN( * )
      REAL               E( * ), RWORK( * ), S( * ), SSAV( * )
      COMPLEX            A( lda, * ), ASAV( lda, * ), U( ldu, * ),
     $                   usav( ldu, * ), vt( ldvt, * ),
     $                   vtsav( ldvt, * ), work( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL              ZERO, ONE, TWO, HALF
      parameter                ( zero = 0.0e0, one = 1.0e0, two = 2.0e0,
     $                   half = 0.5e0 )
      COMPLEX            CZERO, CONE
      parameter                ( czero = ( 0.0e+0, 0.0e+0 ),
     $                   cone = ( 1.0e+0, 0.0e+0 ) )
      INTEGER            MAXTYP
      parameter                ( maxtyp = 5 )
*     ..
*     .. Local Scalars ..
      LOGICAL            BADMM, BADNN
      CHARACTER          JOBQ, JOBU, JOBVT, RANGE
      INTEGER            I, IINFO, IJQ, IJU, IJVT, IL, IU, ITEMP,
     $                   iwspc, iwtmp, j, jsize, jtype, lswork, m,
     $                   minwrk, mmax, mnmax, mnmin, mtypes, n,
     $                   nerrs, nfail, nmax, ns, nsi, nsv, ntest,
     $                   ntestf, ntestt, lrwork
      REAL               ANORM, DIF, DIV, OVFL, RTUNFL, ULP, ULPINV, 
     $                   unfl, vl, vu
*     ..
*     .. Local Arrays ..
      CHARACTER          CJOB( 4 ), CJOBR( 3 ), CJOBV( 2 )
      INTEGER            IOLDSD( 4 ), ISEED2( 4 )
      REAL               RESULT( 35 )
*     ..
*     .. External Functions ..
      REAL               SLAMCH, SLARND
      EXTERNAL           slamch, slarnd
*     ..
*     .. External Subroutines ..
      EXTERNAL           alasvm, xerbla, cbdt01, cbdt05, cgesdd,
     $                   cgesvd, cgesvj, cgejsv, cgesvdx, clacpy,
     $                   claset, clatms, cunt01, cunt03
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, REAL, MAX, MIN
*     ..
*     .. Scalars in Common ..
      CHARACTER*32       SRNAMT
*     ..
*     .. Common blocks ..
      COMMON             / srnamc / srnamt
*     ..
*     .. Data statements ..
      DATA               cjob / 'N', 'O', 'S', 'A' /
      DATA               cjobr / 'A', 'V', 'I' /
      DATA               cjobv / 'N', 'V' /
*     ..
*     .. Executable Statements ..
*
*     Check for errors
*
      info = 0
*
*     Important constants
*
      nerrs = 0
      ntestt = 0
      ntestf = 0
      badmm = .false.
      badnn = .false.
      mmax = 1
      nmax = 1
      mnmax = 1
      minwrk = 1
      DO 10 j = 1, nsizes
         mmax = max( mmax, mm( j ) )
         IF( mm( j ).LT.0 )
     $      badmm = .true.
         nmax = max( nmax, nn( j ) )
         IF( nn( j ).LT.0 )
     $      badnn = .true.
         mnmax = max( mnmax, min( mm( j ), nn( j ) ) )
         minwrk = max( minwrk, max( 3*min( mm( j ),
     $            nn( j ) )+max( mm( j ), nn( j ) )**2, 5*min( mm( j ),
     $            nn( j ) ), 3*max( mm( j ), nn( j ) ) ) )
   10 CONTINUE
*
*     Check for errors
*
      IF( nsizes.LT.0 ) THEN
         info = -1
      ELSE IF( badmm ) THEN
         info = -2
      ELSE IF( badnn ) THEN
         info = -3
      ELSE IF( ntypes.LT.0 ) THEN
         info = -4
      ELSE IF( lda.LT.max( 1, mmax ) ) THEN
         info = -10
      ELSE IF( ldu.LT.max( 1, mmax ) ) THEN
         info = -12
      ELSE IF( ldvt.LT.max( 1, nmax ) ) THEN
         info = -14
      ELSE IF( minwrk.GT.lwork ) THEN
         info = -21
      END IF
*
      IF( info.NE.0 ) THEN
         CALL xerbla( 'CDRVBD', -info )
         RETURN
      END IF
*
*     Quick return if nothing to do
*
      IF( nsizes.EQ.0 .OR. ntypes.EQ.0 )
     $   RETURN
*
*     More Important constants
*
      unfl = slamch( 'S' )
      ovfl = one / unfl
      ulp = slamch( 'E' )
      ulpinv = one / ulp
      rtunfl = sqrt( unfl )
*
*     Loop over sizes, types
*
      nerrs = 0
*
      DO 310 jsize = 1, nsizes
         m = mm( jsize )
         n = nn( jsize )
         mnmin = min( m, n )
*
         IF( nsizes.NE.1 ) THEN
            mtypes = min( maxtyp, ntypes )
         ELSE
            mtypes = min( maxtyp+1, ntypes )
         END IF
*
         DO 300 jtype = 1, mtypes
            IF( .NOT.dotype( jtype ) )
     $         GO TO 300
            ntest = 0
*
            DO 20 j = 1, 4
               ioldsd( j ) = iseed( j )
   20       CONTINUE
*
*           Compute "A"
*
            IF( mtypes.GT.maxtyp )
     $         GO TO 50
*
            IF( jtype.EQ.1 ) THEN
*
*              Zero matrix
*
               CALL claset( 'Full', m, n, czero, czero, a, lda )
               DO 30 i = 1, min( m, n )
                  s( i ) = zero
   30          CONTINUE
*
            ELSE IF( jtype.EQ.2 ) THEN
*
*              Identity matrix
*
               CALL claset( 'Full', m, n, czero, cone, a, lda )
               DO 40 i = 1, min( m, n )
                  s( i ) = one
   40          CONTINUE
*
            ELSE
*
*              (Scaled) random matrix
*
               IF( jtype.EQ.3 )
     $            anorm = one
               IF( jtype.EQ.4 )
     $            anorm = unfl / ulp
               IF( jtype.EQ.5 )
     $            anorm = ovfl*ulp
               CALL clatms( m, n, 'U', iseed, 'N', s, 4, REAL( MNMIN ),
     $                      anorm, m-1, n-1, 'N', a, lda, work, iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9996 )'Generator', iinfo, m, n,
     $               jtype, ioldsd
                  info = abs( iinfo )
                  RETURN
               END IF
            END IF
*
   50       CONTINUE
            CALL clacpy( 'F', m, n, a, lda, asav, lda )
*
*           Do for minimal and adequate (for blocking) workspace
*
            DO 290 iwspc = 1, 4
*
*              Test for CGESVD
*
               iwtmp = 2*min( m, n )+max( m, n )
               lswork = iwtmp + ( iwspc-1 )*( lwork-iwtmp ) / 3
               lswork = min( lswork, lwork )
               lswork = max( lswork, 1 )
               IF( iwspc.EQ.4 )
     $            lswork = lwork
*
               DO 60 j = 1, 35
                  result( j ) = -one
   60          CONTINUE
*
*              Factorize A
*
               IF( iwspc.GT.1 )
     $            CALL clacpy( 'F', m, n, asav, lda, a, lda )
               srnamt = 'CGESVD'
               CALL cgesvd( 'A', 'A', m, n, a, lda, ssav, usav, ldu,
     $                      vtsav, ldvt, work, lswork, rwork, iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9995 )'GESVD', iinfo, m, n,
     $               jtype, lswork, ioldsd
                  info = abs( iinfo )
                  RETURN
               END IF
*
*              Do tests 1--4
*
               CALL cbdt01( m, n, 0, asav, lda, usav, ldu, ssav, e,
     $                      vtsav, ldvt, work, rwork, result( 1 ) )
               IF( m.NE.0 .AND. n.NE.0 ) THEN
                  CALL cunt01( 'Columns', mnmin, m, usav, ldu, work,
     $                         lwork, rwork, result( 2 ) )
                  CALL cunt01( 'Rows', mnmin, n, vtsav, ldvt, work,
     $                         lwork, rwork, result( 3 ) )
               END IF
               result( 4 ) = 0
               DO 70 i = 1, mnmin - 1
                  IF( ssav( i ).LT.ssav( i+1 ) )
     $               result( 4 ) = ulpinv
                  IF( ssav( i ).LT.zero )
     $               result( 4 ) = ulpinv
   70          CONTINUE
               IF( mnmin.GE.1 ) THEN
                  IF( ssav( mnmin ).LT.zero )
     $               result( 4 ) = ulpinv
               END IF
*
*              Do partial SVDs, comparing to SSAV, USAV, and VTSAV
*
               result( 5 ) = zero
               result( 6 ) = zero
               result( 7 ) = zero
               DO 100 iju = 0, 3
                  DO 90 ijvt = 0, 3
                     IF( ( iju.EQ.3 .AND. ijvt.EQ.3 ) .OR.
     $                   ( iju.EQ.1 .AND. ijvt.EQ.1 ) )GO TO 90
                     jobu = cjob( iju+1 )
                     jobvt = cjob( ijvt+1 )
                     CALL clacpy( 'F', m, n, asav, lda, a, lda )
                     srnamt = 'CGESVD'
                     CALL cgesvd( jobu, jobvt, m, n, a, lda, s, u, ldu,
     $                            vt, ldvt, work, lswork, rwork, iinfo )
*
*                    Compare U
*
                     dif = zero
                     IF( m.GT.0 .AND. n.GT.0 ) THEN
                        IF( iju.EQ.1 ) THEN
                           CALL cunt03( 'C', m, mnmin, m, mnmin, usav,
     $                                  ldu, a, lda, work, lwork, rwork,
     $                                  dif, iinfo )
                        ELSE IF( iju.EQ.2 ) THEN
                           CALL cunt03( 'C', m, mnmin, m, mnmin, usav,
     $                                  ldu, u, ldu, work, lwork, rwork,
     $                                  dif, iinfo )
                        ELSE IF( iju.EQ.3 ) THEN
                           CALL cunt03( 'C', m, m, m, mnmin, usav, ldu,
     $                                  u, ldu, work, lwork, rwork, dif,
     $                                  iinfo )
                        END IF
                     END IF
                     result( 5 ) = max( result( 5 ), dif )
*
*                    Compare VT
*
                     dif = zero
                     IF( m.GT.0 .AND. n.GT.0 ) THEN
                        IF( ijvt.EQ.1 ) THEN
                           CALL cunt03( 'R', n, mnmin, n, mnmin, vtsav,
     $                                  ldvt, a, lda, work, lwork,
     $                                  rwork, dif, iinfo )
                        ELSE IF( ijvt.EQ.2 ) THEN
                           CALL cunt03( 'R', n, mnmin, n, mnmin, vtsav,
     $                                  ldvt, vt, ldvt, work, lwork,
     $                                  rwork, dif, iinfo )
                        ELSE IF( ijvt.EQ.3 ) THEN
                           CALL cunt03( 'R', n, n, n, mnmin, vtsav,
     $                                  ldvt, vt, ldvt, work, lwork,
     $                                  rwork, dif, iinfo )
                        END IF
                     END IF
                     result( 6 ) = max( result( 6 ), dif )
*
*                    Compare S
*
                     dif = zero
                     div = max( REAL( mnmin )*ULP*S( 1 ),
     $                     slamch( 'Safe minimum' ) )
                     DO 80 i = 1, mnmin - 1
                        IF( ssav( i ).LT.ssav( i+1 ) )
     $                     dif = ulpinv
                        IF( ssav( i ).LT.zero )
     $                     dif = ulpinv
                        dif = max( dif, abs( ssav( i )-s( i ) ) / div )
   80                CONTINUE
                     result( 7 ) = max( result( 7 ), dif )
   90             CONTINUE
  100          CONTINUE
*
*              Test for CGESDD
*
               iwtmp = 2*mnmin*mnmin + 2*mnmin + max( m, n )
               lswork = iwtmp + ( iwspc-1 )*( lwork-iwtmp ) / 3
               lswork = min( lswork, lwork )
               lswork = max( lswork, 1 )
               IF( iwspc.EQ.4 )
     $            lswork = lwork
*
*              Factorize A
*
               CALL clacpy( 'F', m, n, asav, lda, a, lda )
               srnamt = 'CGESDD'
               CALL cgesdd( 'A', m, n, a, lda, ssav, usav, ldu, vtsav,
     $                      ldvt, work, lswork, rwork, iwork, iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9995 )'GESDD', iinfo, m, n,
     $               jtype, lswork, ioldsd
                  info = abs( iinfo )
                  RETURN
               END IF
*
*              Do tests 1--4
*
               CALL cbdt01( m, n, 0, asav, lda, usav, ldu, ssav, e,
     $                      vtsav, ldvt, work, rwork, result( 8 ) )
               IF( m.NE.0 .AND. n.NE.0 ) THEN
                  CALL cunt01( 'Columns', mnmin, m, usav, ldu, work,
     $                         lwork, rwork, result( 9 ) )
                  CALL cunt01( 'Rows', mnmin, n, vtsav, ldvt, work,
     $                         lwork, rwork, result( 10 ) )
               END IF
               result( 11 ) = 0
               DO 110 i = 1, mnmin - 1
                  IF( ssav( i ).LT.ssav( i+1 ) )
     $               result( 11 ) = ulpinv
                  IF( ssav( i ).LT.zero )
     $               result( 11 ) = ulpinv
  110          CONTINUE
               IF( mnmin.GE.1 ) THEN
                  IF( ssav( mnmin ).LT.zero )
     $               result( 11 ) = ulpinv
               END IF
*
*              Do partial SVDs, comparing to SSAV, USAV, and VTSAV
*
               result( 12 ) = zero
               result( 13 ) = zero
               result( 14 ) = zero
               DO 130 ijq = 0, 2
                  jobq = cjob( ijq+1 )
                  CALL clacpy( 'F', m, n, asav, lda, a, lda )
                  srnamt = 'CGESDD'
                  CALL cgesdd( jobq, m, n, a, lda, s, u, ldu, vt, ldvt,
     $                         work, lswork, rwork, iwork, iinfo )
*
*                 Compare U
*
                  dif = zero
                  IF( m.GT.0 .AND. n.GT.0 ) THEN
                     IF( ijq.EQ.1 ) THEN
                        IF( m.GE.n ) THEN
                           CALL cunt03( 'C', m, mnmin, m, mnmin, usav,
     $                                  ldu, a, lda, work, lwork, rwork,
     $                                  dif, iinfo )
                        ELSE
                           CALL cunt03( 'C', m, mnmin, m, mnmin, usav,
     $                                  ldu, u, ldu, work, lwork, rwork,
     $                                  dif, iinfo )
                        END IF
                     ELSE IF( ijq.EQ.2 ) THEN
                        CALL cunt03( 'C', m, mnmin, m, mnmin, usav, ldu,
     $                               u, ldu, work, lwork, rwork, dif,
     $                               iinfo )
                     END IF
                  END IF
                  result( 12 ) = max( result( 12 ), dif )
*
*                 Compare VT
*
                  dif = zero
                  IF( m.GT.0 .AND. n.GT.0 ) THEN
                     IF( ijq.EQ.1 ) THEN
                        IF( m.GE.n ) THEN
                           CALL cunt03( 'R', n, mnmin, n, mnmin, vtsav,
     $                                  ldvt, vt, ldvt, work, lwork,
     $                                  rwork, dif, iinfo )
                        ELSE
                           CALL cunt03( 'R', n, mnmin, n, mnmin, vtsav,
     $                                  ldvt, a, lda, work, lwork,
     $                                  rwork, dif, iinfo )
                        END IF
                     ELSE IF( ijq.EQ.2 ) THEN
                        CALL cunt03( 'R', n, mnmin, n, mnmin, vtsav,
     $                               ldvt, vt, ldvt, work, lwork, rwork,
     $                               dif, iinfo )
                     END IF
                  END IF
                  result( 13 ) = max( result( 13 ), dif )
*
*                 Compare S
*
                  dif = zero
                  div = max( REAL( mnmin )*ULP*S( 1 ),
     $                  slamch( 'Safe minimum' ) )
                  DO 120 i = 1, mnmin - 1
                     IF( ssav( i ).LT.ssav( i+1 ) )
     $                  dif = ulpinv
                     IF( ssav( i ).LT.zero )
     $                  dif = ulpinv
                     dif = max( dif, abs( ssav( i )-s( i ) ) / div )
  120             CONTINUE
                  result( 14 ) = max( result( 14 ), dif )
  130          CONTINUE

*
*              Test CGESVJ: Factorize A
*              Note: CGESVJ does not work for M < N
*
               result( 15 ) = zero
               result( 16 ) = zero
               result( 17 ) = zero
               result( 18 ) = zero
*
               IF( m.GE.n ) THEN
               iwtmp = 2*mnmin*mnmin + 2*mnmin + max( m, n )
               lswork = iwtmp + ( iwspc-1 )*( lwork-iwtmp ) / 3
               lswork = min( lswork, lwork )
               lswork = max( lswork, 1 )
               lrwork = max(6,n)
               IF( iwspc.EQ.4 )
     $            lswork = lwork
*
                  CALL clacpy( 'F', m, n, asav, lda, usav, lda )
                  srnamt = 'CGESVJ'
                  CALL cgesvj( 'G', 'U', 'V', m, n, usav, lda, ssav,
     &                        0, a, ldvt, work, lwork, rwork, 
     &                        lrwork, iinfo )
*
*                 CGESVJ retuns V not VT, so we transpose to use the same
*                 test suite.
*
                  DO j=1,n
                     DO i=1,n
                        vtsav(j,i) = conjg(a(i,j))
                     END DO
                  END DO
*
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nounit, fmt = 9995 )'GESVJ', iinfo, m, n,
     $               jtype, lswork, ioldsd
                     info = abs( iinfo )
                     RETURN
                  END IF
*
*                 Do tests 15--18
*
                  CALL cbdt01( m, n, 0, asav, lda, usav, ldu, ssav, e,
     $                         vtsav, ldvt, work, rwork, result( 15 ) )
                  IF( m.NE.0 .AND. n.NE.0 ) THEN
                     CALL cunt01( 'Columns', m, m, usav, ldu, work,
     $                            lwork, rwork, result( 16 ) )
                     CALL cunt01( 'Rows', n, n, vtsav, ldvt, work,
     $                            lwork, rwork, result( 17 ) )
                  END IF
                  result( 18 ) = zero
                  DO 131 i = 1, mnmin - 1
                     IF( ssav( i ).LT.ssav( i+1 ) )
     $                  result( 18 ) = ulpinv
                     IF( ssav( i ).LT.zero )
     $                  result( 18 ) = ulpinv
  131             CONTINUE
                  IF( mnmin.GE.1 ) THEN
                     IF( ssav( mnmin ).LT.zero )
     $                  result( 18 ) = ulpinv
                  END IF
               END IF
*
*              Test CGEJSV: Factorize A
*              Note: CGEJSV does not work for M < N
*
               result( 19 ) = zero
               result( 20 ) = zero
               result( 21 ) = zero
               result( 22 ) = zero
               IF( m.GE.n ) THEN
               iwtmp = 2*mnmin*mnmin + 2*mnmin + max( m, n )
               lswork = iwtmp + ( iwspc-1 )*( lwork-iwtmp ) / 3
               lswork = min( lswork, lwork )
               lswork = max( lswork, 1 )
               IF( iwspc.EQ.4 )
     $            lswork = lwork
               lrwork = max( 7, n + 2*m)
*
                 CALL clacpy( 'F', m, n, asav, lda, vtsav, lda )
                  srnamt = 'CGEJSV'
                  CALL cgejsv( 'G', 'U', 'V', 'R', 'N', 'N',
     &                   m, n, vtsav, lda, ssav, usav, ldu, a, ldvt,
     &                   work, lwork, rwork, 
     &                   lrwork, iwork, iinfo )
*
*                 CGEJSV retuns V not VT, so we transpose to use the same
*                 test suite.
*
                  DO 133 j=1,n
                     DO 132 i=1,n
                        vtsav(j,i) = conjg(a(i,j))
  132                END DO
  133             END DO
*
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nounit, fmt = 9995 )'GESVJ', iinfo, m, n,
     $               jtype, lswork, ioldsd
                     info = abs( iinfo )
                     RETURN
                  END IF
*
*                 Do tests 19--22
*
                  CALL cbdt01( m, n, 0, asav, lda, usav, ldu, ssav, e,
     $                         vtsav, ldvt, work, rwork, result( 19 ) )
                  IF( m.NE.0 .AND. n.NE.0 ) THEN
                     CALL cunt01( 'Columns', m, m, usav, ldu, work,
     $                            lwork, rwork, result( 20 ) )
                     CALL cunt01( 'Rows', n, n, vtsav, ldvt, work,
     $                            lwork, rwork, result( 21 ) )
                  END IF
                  result( 22 ) = zero
                  DO 134 i = 1, mnmin - 1
                     IF( ssav( i ).LT.ssav( i+1 ) )
     $                  result( 22 ) = ulpinv
                     IF( ssav( i ).LT.zero )
     $                  result( 22 ) = ulpinv
  134             CONTINUE
                  IF( mnmin.GE.1 ) THEN
                     IF( ssav( mnmin ).LT.zero )
     $                  result( 22 ) = ulpinv
                  END IF
               END IF
*
*              Test CGESVDX
*
*              Factorize A
*
               CALL clacpy( 'F', m, n, asav, lda, a, lda )
               srnamt = 'CGESVDX'
               CALL cgesvdx( 'V', 'V', 'A', m, n, a, lda, 
     $                       vl, vu, il, iu, ns, ssav, usav, ldu, 
     $                       vtsav, ldvt, work, lwork, rwork,
     $                       iwork, iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9995 )'GESVDX', iinfo, m, n,
     $               jtype, lswork, ioldsd
                  info = abs( iinfo )
                  RETURN
               END IF
*
*              Do tests 1--4
*
               result( 23 ) = zero
               result( 24 ) = zero
               result( 25 ) = zero
               CALL cbdt01( m, n, 0, asav, lda, usav, ldu, ssav, e,
     $                      vtsav, ldvt, work, rwork, result( 23 ) )
               IF( m.NE.0 .AND. n.NE.0 ) THEN
                  CALL cunt01( 'Columns', mnmin, m, usav, ldu, work,
     $                         lwork, rwork, result( 24 ) )
                  CALL cunt01( 'Rows', mnmin, n, vtsav, ldvt, work,
     $                         lwork, rwork, result( 25 ) )
               END IF
               result( 26 ) = zero
               DO 140 i = 1, mnmin - 1
                  IF( ssav( i ).LT.ssav( i+1 ) )
     $               result( 26 ) = ulpinv
                  IF( ssav( i ).LT.zero )
     $               result( 26 ) = ulpinv
  140          CONTINUE
               IF( mnmin.GE.1 ) THEN
                  IF( ssav( mnmin ).LT.zero )
     $               result( 26 ) = ulpinv
               END IF
*
*              Do partial SVDs, comparing to SSAV, USAV, and VTSAV
*
               result( 27 ) = zero
               result( 28 ) = zero
               result( 29 ) = zero
               DO 170 iju = 0, 1
                  DO 160 ijvt = 0, 1
                     IF( ( iju.EQ.0 .AND. ijvt.EQ.0 ) .OR.
     $                   ( iju.EQ.1 .AND. ijvt.EQ.1 ) ) GO TO 160
                     jobu = cjobv( iju+1 )
                     jobvt = cjobv( ijvt+1 )
                     range = cjobr( 1 )
                     CALL clacpy( 'F', m, n, asav, lda, a, lda )
                     srnamt = 'CGESVDX'
                     CALL cgesvdx( jobu, jobvt, 'A', m, n, a, lda, 
     $                            vl, vu, il, iu, ns, ssav, u, ldu, 
     $                            vt, ldvt, work, lwork, rwork,
     $                            iwork, iinfo )
*
*                    Compare U
*
                     dif = zero
                     IF( m.GT.0 .AND. n.GT.0 ) THEN
                        IF( iju.EQ.1 ) THEN
                           CALL cunt03( 'C', m, mnmin, m, mnmin, usav,
     $                                  ldu, u, ldu, work, lwork, rwork,
     $                                  dif, iinfo )
                        END IF
                     END IF
                     result( 27 ) = max( result( 27 ), dif )
*
*                    Compare VT
*
                     dif = zero
                     IF( m.GT.0 .AND. n.GT.0 ) THEN
                        IF( ijvt.EQ.1 ) THEN
                           CALL cunt03( 'R', n, mnmin, n, mnmin, vtsav,
     $                                  ldvt, vt, ldvt, work, lwork,
     $                                  rwork, dif, iinfo )
                        END IF
                     END IF
                     result( 28 ) = max( result( 28 ), dif )
*
*                    Compare S
*
                     dif = zero
                     div = max( REAL( mnmin )*ULP*S( 1 ),
     $                     slamch( 'Safe minimum' ) )
                     DO 150 i = 1, mnmin - 1
                        IF( ssav( i ).LT.ssav( i+1 ) )
     $                     dif = ulpinv
                        IF( ssav( i ).LT.zero )
     $                     dif = ulpinv
                        dif = max( dif, abs( ssav( i )-s( i ) ) / div )
  150                CONTINUE
                     result( 29) = max( result( 29 ), dif )
  160             CONTINUE
  170          CONTINUE
*
*              Do tests 8--10
*
               DO 180 i = 1, 4
                  iseed2( i ) = iseed( i )
  180          CONTINUE
               IF( mnmin.LE.1 ) THEN
                  il = 1
                  iu = max( 1, mnmin )
               ELSE
                  il = 1 + int( ( mnmin-1 )*slarnd( 1, iseed2 ) )
                  iu = 1 + int( ( mnmin-1 )*slarnd( 1, iseed2 ) )
                  IF( iu.LT.il ) THEN
                     itemp = iu
                     iu = il
                     il = itemp
                  END IF
               END IF  
               CALL clacpy( 'F', m, n, asav, lda, a, lda )
               srnamt = 'CGESVDX'
               CALL cgesvdx( 'V', 'V', 'I', m, n, a, lda, 
     $                       vl, vu, il, iu, nsi, s, u, ldu, 
     $                       vt, ldvt, work, lwork, rwork,
     $                       iwork, iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9995 )'GESVDX', iinfo, m, n, 
     $               jtype, lswork, ioldsd
                  info = abs( iinfo )
                  RETURN
               END IF
*
               result( 30 ) = zero
               result( 31 ) = zero
               result( 32 ) = zero
               CALL cbdt05( m, n, asav, lda, s, nsi, u, ldu,
     $                      vt, ldvt, work, result( 30 ) )
               IF( m.NE.0 .AND. n.NE.0 ) THEN
                  CALL cunt01( 'Columns', m, nsi, u, ldu, work,
     $                         lwork, rwork, result( 31 ) )
                  CALL cunt01( 'Rows', nsi, n, vt, ldvt, work,
     $                         lwork, rwork, result( 32 ) )
               END IF
*
*              Do tests 11--13
*
               IF( mnmin.GT.0 .AND. nsi.GT.1 ) THEN
                  IF( il.NE.1 ) THEN
                     vu = ssav( il ) + 
     $                    max( half*abs( ssav( il )-ssav( il-1 ) ),
     $                    ulp*anorm, two*rtunfl )
                  ELSE
                     vu = ssav( 1 ) + 
     $                    max( half*abs( ssav( ns )-ssav( 1 ) ),
     $                    ulp*anorm, two*rtunfl )
                  END IF
                  IF( iu.NE.ns ) THEN
                     vl = ssav( iu ) - max( ulp*anorm, two*rtunfl,
     $                    half*abs( ssav( iu+1 )-ssav( iu ) ) )
                  ELSE
                     vl = ssav( ns ) - max( ulp*anorm, two*rtunfl,
     $                    half*abs( ssav( ns )-ssav( 1 ) ) )
                  END IF
                  vl = max( vl,zero )
                  vu = max( vu,zero )
                  IF( vl.GE.vu ) vu = max( vu*2, vu+vl+half )
               ELSE
                  vl = zero
                  vu = one
               END IF 
               CALL clacpy( 'F', m, n, asav, lda, a, lda )
               srnamt = 'CGESVDX'
               CALL cgesvdx( 'V', 'V', 'V', m, n, a, lda, 
     $                       vl, vu, il, iu, nsv, s, u, ldu, 
     $                       vt, ldvt, work, lwork, rwork,
     $                       iwork, iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nounit, fmt = 9995 )'GESVDX', iinfo, m, n, 
     $               jtype, lswork, ioldsd
                  info = abs( iinfo )
                  RETURN
               END IF
*
               result( 33 ) = zero
               result( 34 ) = zero
               result( 35 ) = zero
               CALL cbdt05( m, n, asav, lda, s, nsv, u, ldu,
     $                      vt, ldvt, work, result( 33 ) )
               IF( m.NE.0 .AND. n.NE.0 ) THEN
                  CALL cunt01( 'Columns', m, nsv, u, ldu, work,
     $                         lwork, rwork, result( 34 ) )
                  CALL cunt01( 'Rows', nsv, n, vt, ldvt, work,
     $                         lwork, rwork, result( 35 ) )
               END IF
*
*              End of Loop -- Check for RESULT(j) > THRESH
*
               ntest = 0
               nfail = 0
               DO 190 j = 1, 35
                  IF( result( j ).GE.zero )
     $               ntest = ntest + 1
                  IF( result( j ).GE.thresh )
     $               nfail = nfail + 1
  190          CONTINUE
*
               IF( nfail.GT.0 )
     $            ntestf = ntestf + 1
               IF( ntestf.EQ.1 ) THEN
                  WRITE( nounit, fmt = 9999 )
                  WRITE( nounit, fmt = 9998 )thresh
                  ntestf = 2
               END IF
*
               DO 200 j = 1, 35
                  IF( result( j ).GE.thresh ) THEN
                     WRITE( nounit, fmt = 9997 )m, n, jtype, iwspc,
     $                  ioldsd, j, result( j )
                  END IF
  200          CONTINUE
*
               nerrs = nerrs + nfail
               ntestt = ntestt + ntest
*
  290       CONTINUE
*
  300    CONTINUE
  310 CONTINUE
*
*     Summary
*
      CALL alasvm( 'CBD', nounit, nerrs, ntestt, 0 )
*
 9999 FORMAT( ' SVD -- Complex Singular Value Decomposition Driver ',
     $      / ' Matrix types (see CDRVBD for details):',
     $      / / ' 1 = Zero matrix', / ' 2 = Identity matrix',
     $      / ' 3 = Evenly spaced singular values near 1',
     $      / ' 4 = Evenly spaced singular values near underflow',
     $      / ' 5 = Evenly spaced singular values near overflow',
     $      / / ' Tests performed: ( A is dense, U and V are unitary,',
     $      / 19x, ' S is an array, and Upartial, VTpartial, and',
     $      / 19x, ' Spartial are partially computed U, VT and S),', / )
 9998 FORMAT( ' Tests performed with Test Threshold = ', f8.2,
     $      / ' CGESVD: ', /
     $      ' 1 = | A - U diag(S) VT | / ( |A| max(M,N) ulp ) ',
     $      / ' 2 = | I - U**T U | / ( M ulp ) ',
     $      / ' 3 = | I - VT VT**T | / ( N ulp ) ',
     $      / ' 4 = 0 if S contains min(M,N) nonnegative values in',
     $      ' decreasing order, else 1/ulp',
     $      / ' 5 = | U - Upartial | / ( M ulp )',
     $      / ' 6 = | VT - VTpartial | / ( N ulp )',
     $      / ' 7 = | S - Spartial | / ( min(M,N) ulp |S| )',
     $      / ' CGESDD: ', /
     $      ' 8 = | A - U diag(S) VT | / ( |A| max(M,N) ulp ) ',
     $      / ' 9 = | I - U**T U | / ( M ulp ) ',
     $      / '10 = | I - VT VT**T | / ( N ulp ) ',
     $      / '11 = 0 if S contains min(M,N) nonnegative values in',
     $      ' decreasing order, else 1/ulp',
     $      / '12 = | U - Upartial | / ( M ulp )',
     $      / '13 = | VT - VTpartial | / ( N ulp )',
     $      / '14 = | S - Spartial | / ( min(M,N) ulp |S| )', 
     $      / ' CGESVJ: ', /
     $      / '15 = | A - U diag(S) VT | / ( |A| max(M,N) ulp ) ',
     $      / '16 = | I - U**T U | / ( M ulp ) ',
     $      / '17 = | I - VT VT**T | / ( N ulp ) ',
     $      / '18 = 0 if S contains min(M,N) nonnegative values in',
     $      ' decreasing order, else 1/ulp',
     $      / ' CGESJV: ', /
     $      / '19 = | A - U diag(S) VT | / ( |A| max(M,N) ulp )',
     $      / '20 = | I - U**T U | / ( M ulp ) ',
     $      / '21 = | I - VT VT**T | / ( N ulp ) ', 
     $      / '22 = 0 if S contains min(M,N) nonnegative values in',
     $      ' decreasing order, else 1/ulp',
     $      / ' CGESVDX(V,V,A): ', /
     $        '23 = | A - U diag(S) VT | / ( |A| max(M,N) ulp ) ',
     $      / '24 = | I - U**T U | / ( M ulp ) ',
     $      / '25 = | I - VT VT**T | / ( N ulp ) ',
     $      / '26 = 0 if S contains min(M,N) nonnegative values in',
     $      ' decreasing order, else 1/ulp',
     $      / '27 = | U - Upartial | / ( M ulp )',
     $      / '28 = | VT - VTpartial | / ( N ulp )',
     $      / '29 = | S - Spartial | / ( min(M,N) ulp |S| )',
     $      / ' CGESVDX(V,V,I): ',
     $      / '30 = | U**T A VT**T - diag(S) | / ( |A| max(M,N) ulp )',
     $      / '31 = | I - U**T U | / ( M ulp ) ',
     $      / '32 = | I - VT VT**T | / ( N ulp ) ',
     $      / ' CGESVDX(V,V,V) ',
     $      / '33 = | U**T A VT**T - diag(S) | / ( |A| max(M,N) ulp )',
     $      / '34 = | I - U**T U | / ( M ulp ) ',
     $      / '35 = | I - VT VT**T | / ( N ulp ) ',  
     $      / / )
 9997 FORMAT( ' M=', i5, ', N=', i5, ', type ', i1, ', IWS=', i1,
     $      ', seed=', 4( i4, ',' ), ' test(', i2, ')=', g11.4 )
 9996 FORMAT( ' CDRVBD: ', a, ' returned INFO=', i6, '.', / 9x, 'M=',
     $      i6, ', N=', i6, ', JTYPE=', i6, ', ISEED=(', 3( i5, ',' ),
     $      i5, ')' )
 9995 FORMAT( ' CDRVBD: ', a, ' returned INFO=', i6, '.', / 9x, 'M=',
     $      i6, ', N=', i6, ', JTYPE=', i6, ', LSWORK=', i6, / 9x,
     $      'ISEED=(', 3( i5, ',' ), i5, ')' )
*
      RETURN
*
*     End of CDRVBD
*
      END