ddrvbd.f

Go to the documentation of this file.

*> \brief \b DDRVBD
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at
*            http://www.netlib.org/lapack/explore-html/
*
*  Definition:
*  ===========
*
*       SUBROUTINE DDRVBD( NSIZES, MM, NN, NTYPES, DOTYPE, ISEED, THRESH,
*                          A, LDA, U, LDU, VT, LDVT, ASAV, USAV, VTSAV, S,
*                          SSAV, E, WORK, LWORK, IWORK, NOUT, INFO )
*
*       .. Scalar Arguments ..
*       INTEGER            INFO, LDA, LDU, LDVT, LWORK, NOUT, NSIZES,
*      $                   NTYPES
*       DOUBLE PRECISION   THRESH
*       ..
*       .. Array Arguments ..
*       LOGICAL            DOTYPE( * )
*       INTEGER            ISEED( 4 ), IWORK( * ), MM( * ), NN( * )
*       DOUBLE PRECISION   A( LDA, * ), ASAV( LDA, * ), E( * ), S( * ),
*      $                   SSAV( * ), U( LDU, * ), USAV( LDU, * ),
*      $                   VT( LDVT, * ), VTSAV( LDVT, * ), WORK( * )
*       ..
*
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> DDRVBD checks the singular value decomposition (SVD) drivers
*> DGESVD, DGESDD, DGESVDQ, DGESVJ, DGEJSV, and DGESVDX.
*>
*> Both DGESVD and DGESDD factor A = U diag(S) VT, where U and VT are
*> orthogonal 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 DDRVBD 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 DGESVD:
*>
*> (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 DGESDD:
*>
*> (8)    | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (9)    | I - U'U | / ( M ulp )
*>
*> (10)   | I - VT VT' | / ( N ulp )
*>
*> (11)   S contains MNMIN nonnegative values in decreasing order.
*>        (Return 0 if true, 1/ULP if false.)
*>
*> (12)   | U - Upartial | / ( M ulp ) where Upartial is a partially
*>        computed U.
*>
*> (13)   | VT - VTpartial | / ( N ulp ) where VTpartial is a partially
*>        computed VT.
*>
*> (14)   | S - Spartial | / ( MNMIN ulp |S| ) where Spartial is the
*>        vector of singular values from the partial SVD
*>
*> Test for DGESVDQ:
*>
*> (36)   | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (37)   | I - U'U | / ( M ulp )
*>
*> (38)   | I - VT VT' | / ( N ulp )
*>
*> (39)   S contains MNMIN nonnegative values in decreasing order.
*>        (Return 0 if true, 1/ULP if false.)
*>
*> Test for DGESVJ:
*>
*> (15)   | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (16)   | I - U'U | / ( M ulp )
*>
*> (17)   | I - VT VT' | / ( N ulp )
*>
*> (18)   S contains MNMIN nonnegative values in decreasing order.
*>        (Return 0 if true, 1/ULP if false.)
*>
*> Test for DGEJSV:
*>
*> (19)   | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (20)   | I - U'U | / ( M ulp )
*>
*> (21)   | I - VT VT' | / ( N ulp )
*>
*> (22)   S contains MNMIN nonnegative values in decreasing order.
*>        (Return 0 if true, 1/ULP if false.)
*>
*> Test for DGESVDX( 'V', 'V', 'A' )/DGESVDX( 'N', 'N', 'A' )
*>
*> (23)   | A - U diag(S) VT | / ( |A| max(M,N) ulp )
*>
*> (24)   | I - U'U | / ( M ulp )
*>
*> (25)   | I - VT VT' | / ( N ulp )
*>
*> (26)   S contains MNMIN nonnegative values in decreasing order.
*>        (Return 0 if true, 1/ULP if false.)
*>
*> (27)   | U - Upartial | / ( M ulp ) where Upartial is a partially
*>        computed U.
*>
*> (28)   | VT - VTpartial | / ( N ulp ) where VTpartial is a partially
*>        computed VT.
*>
*> (29)   | S - Spartial | / ( MNMIN ulp |S| ) where Spartial is the
*>        vector of singular values from the partial SVD
*>
*> Test for DGESVDX( 'V', 'V', 'I' )
*>
*> (30)   | U' A VT''' - diag(S) | / ( |A| max(M,N) ulp )
*>
*> (31)   | I - U'U | / ( M ulp )
*>
*> (32)   | I - VT VT' | / ( N ulp )
*>
*> Test for DGESVDX( 'V', 'V', 'V' )
*>
*> (33)   | U' A VT''' - diag(S) | / ( |A| max(M,N) ulp )
*>
*> (34)   | I - U'U | / ( M ulp )
*>
*> (35)   | 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 orthogonal 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 matrix sizes (M,N) contained in the vectors
*>          MM and NN.
*> \endverbatim
*>
*> \param[in] MM
*> \verbatim
*>          MM is INTEGER array, dimension (NSIZES)
*>          The values of the matrix row dimension M.
*> \endverbatim
*>
*> \param[in] NN
*> \verbatim
*>          NN is INTEGER array, dimension (NSIZES)
*>          The values of the matrix column dimension N.
*> \endverbatim
*>
*> \param[in] NTYPES
*> \verbatim
*>          NTYPES is INTEGER
*>          The number of elements in DOTYPE.   If it is zero, DDRVBD
*>          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, 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.
*>          On exit, ISEED is changed and can be used in the next call to
*>          DDRVBD to continue the same random number sequence.
*> \endverbatim
*>
*> \param[in] THRESH
*> \verbatim
*>          THRESH is DOUBLE PRECISION
*>          The threshold value for the test ratios.  A result is
*>          included in the output file if RESULT >= THRESH.  The test
*>          ratios are scaled to be O(1), so THRESH should be a small
*>          multiple of 1, e.g., 10 or 100.  To have every test ratio
*>          printed, use THRESH = 0.
*> \endverbatim
*>
*> \param[out] A
*> \verbatim
*>          A is DOUBLE PRECISION array, dimension (LDA,NMAX)
*>          where NMAX is the maximum value of N in NN.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*>          LDA is INTEGER
*>          The leading dimension of the array A.  LDA >= max(1,MMAX),
*>          where MMAX is the maximum value of M in MM.
*> \endverbatim
*>
*> \param[out] U
*> \verbatim
*>          U is DOUBLE PRECISION array, dimension (LDU,MMAX)
*> \endverbatim
*>
*> \param[in] LDU
*> \verbatim
*>          LDU is INTEGER
*>          The leading dimension of the array U.  LDU >= max(1,MMAX).
*> \endverbatim
*>
*> \param[out] VT
*> \verbatim
*>          VT is DOUBLE PRECISION array, dimension (LDVT,NMAX)
*> \endverbatim
*>
*> \param[in] LDVT
*> \verbatim
*>          LDVT is INTEGER
*>          The leading dimension of the array VT.  LDVT >= max(1,NMAX).
*> \endverbatim
*>
*> \param[out] ASAV
*> \verbatim
*>          ASAV is DOUBLE PRECISION array, dimension (LDA,NMAX)
*> \endverbatim
*>
*> \param[out] USAV
*> \verbatim
*>          USAV is DOUBLE PRECISION array, dimension (LDU,MMAX)
*> \endverbatim
*>
*> \param[out] VTSAV
*> \verbatim
*>          VTSAV is DOUBLE PRECISION array, dimension (LDVT,NMAX)
*> \endverbatim
*>
*> \param[out] S
*> \verbatim
*>          S is DOUBLE PRECISION array, dimension
*>                      (max(min(MM,NN)))
*> \endverbatim
*>
*> \param[out] SSAV
*> \verbatim
*>          SSAV is DOUBLE PRECISION array, dimension
*>                      (max(min(MM,NN)))
*> \endverbatim
*>
*> \param[out] E
*> \verbatim
*>          E is DOUBLE PRECISION array, dimension
*>                      (max(min(MM,NN)))
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*>          WORK is DOUBLE PRECISION array, dimension (LWORK)
*> \endverbatim
*>
*> \param[in] LWORK
*> \verbatim
*>          LWORK is INTEGER
*>          The number of entries in WORK.  This must be at least
*>          max(3*MN+MX,5*MN-4)+2*MN**2 for all pairs
*>          pairs  (MN,MX)=( min(MM(j),NN(j), max(MM(j),NN(j)) )
*> \endverbatim
*>
*> \param[out] IWORK
*> \verbatim
*>          IWORK is INTEGER array, dimension at least 8*min(M,N)
*> \endverbatim
*>
*> \param[in] NOUT
*> \verbatim
*>          NOUT 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) ).
*>          -21: LWORK too small.
*>          If  DLATMS, or DGESVD 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.
*
*> \ingroup double_eig
*
*  =====================================================================
      SUBROUTINE ddrvbd( NSIZES, MM, NN, NTYPES, DOTYPE, ISEED, THRESH,
     $                   A, LDA, U, LDU, VT, LDVT, ASAV, USAV, VTSAV, S,
     $                   SSAV, E, WORK, LWORK, IWORK, NOUT, INFO )
*
      IMPLICIT NONE
*
*  -- 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, LDA, LDU, LDVT, LWORK, NOUT, NSIZES,
     $                   NTYPES
      DOUBLE PRECISION   THRESH
*     ..
*     .. Array Arguments ..
      LOGICAL            DOTYPE( * )
      INTEGER            ISEED( 4 ), IWORK( * ), MM( * ), NN( * )
      DOUBLE PRECISION   A( LDA, * ), ASAV( LDA, * ), E( * ), S( * ),
     $                   ssav( * ), u( ldu, * ), usav( ldu, * ),
     $                   vt( ldvt, * ), vtsav( ldvt, * ), work( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION  ZERO, ONE, TWO, HALF
      PARAMETER          ( ZERO = 0.0d0, one = 1.0d0, two = 2.0d0,
     $                   half = 0.5d0 )
      INTEGER            MAXTYP
      PARAMETER          ( MAXTYP = 5 )
*     ..
*     .. Local Scalars ..
      LOGICAL            BADMM, BADNN
      CHARACTER          JOBQ, JOBU, JOBVT, RANGE
      CHARACTER*3        PATH
      INTEGER            I, IINFO, IJQ, IJU, IJVT, IL,IU, IWS, IWTMP,
     $                   itemp, j, jsize, jtype, lswork, m, minwrk,
     $                   mmax, mnmax, mnmin, mtypes, n, nfail,
     $                   nmax, ns, nsi, nsv, ntest
      DOUBLE PRECISION   ANORM, DIF, DIV, OVFL, RTUNFL, ULP,
     $                   ULPINV, UNFL, VL, VU
*     ..
*     .. Local Scalars for DGESVDQ ..
      INTEGER            LIWORK, LRWORK, NUMRANK
*     ..
*     .. Local Arrays for DGESVDQ ..
      DOUBLE PRECISION   RWORK( 2 )
*     ..
*     .. Local Arrays ..
      CHARACTER          CJOB( 4 ), CJOBR( 3 ), CJOBV( 2 )
      INTEGER            IOLDSD( 4 ), ISEED2( 4 )
      DOUBLE PRECISION   RESULT( 39 )
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLAMCH, DLARND
      EXTERNAL           DLAMCH, DLARND
*     ..
*     .. External Subroutines ..
      EXTERNAL           alasvm, dbdt01, dgejsv, dgesdd, dgesvd,
     $                   dgesvdq, dgesvdx, dgesvj, dlabad, dlacpy,
     $                   dlaset, dlatms, dort01, dort03, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, dble, int, max, min
*     ..
*     .. Scalars in Common ..
      LOGICAL            LERR, OK
      CHARACTER*32       SRNAMT
      INTEGER            INFOT, NUNIT
*     ..
*     .. Common blocks ..
      COMMON             / infoc / infot, nunit, ok, lerr
      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
      BADMM = .FALSE.
      BADNN = .FALSE.
      MMAX = 1
      NMAX = 1
      MNMAX = 1
      MINWRK = 1
      DO 10 J = 1, NSIZES
         MMAX = MAX( MMAX, MM( J ) )
.LT.         IF( MM( J )0 )
     $      BADMM = .TRUE.
         NMAX = MAX( NMAX, NN( J ) )
.LT.         IF( NN( J )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 ) ), 5*MIN( MM( J ),
     $            NN( J )-4 ) )+2*MIN( MM( J ), NN( J ) )**2 )
   10 CONTINUE
*
*     Check for errors
*
.LT.      IF( NSIZES0 ) THEN
         INFO = -1
      ELSE IF( BADMM ) THEN
         INFO = -2
      ELSE IF( BADNN ) THEN
         INFO = -3
.LT.      ELSE IF( NTYPES0 ) THEN
         INFO = -4
.LT.      ELSE IF( LDAMAX( 1, MMAX ) ) THEN
         INFO = -10
.LT.      ELSE IF( LDUMAX( 1, MMAX ) ) THEN
         INFO = -12
.LT.      ELSE IF( LDVTMAX( 1, NMAX ) ) THEN
         INFO = -14
.GT.      ELSE IF( MINWRKLWORK ) THEN
         INFO = -21
      END IF
*
.NE.      IF( INFO0 ) THEN
         CALL XERBLA( 'ddrvbd', -INFO )
         RETURN
      END IF
*
*     Initialize constants
*
      PATH( 1: 1 ) = 'double precision'
      PATH( 2: 3 ) = 'bd'
      NFAIL = 0
      NTEST = 0
      UNFL = DLAMCH( 'safe minimum' )
      OVFL = ONE / UNFL
      CALL DLABAD( UNFL, OVFL )
      ULP = DLAMCH( 'precision' )
      RTUNFL = SQRT( UNFL )
      ULPINV = ONE / ULP
      INFOT = 0
*
*     Loop over sizes, types
*
      DO 240 JSIZE = 1, NSIZES
         M = MM( JSIZE )
         N = NN( JSIZE )
         MNMIN = MIN( M, N )
*
.NE.         IF( NSIZES1 ) THEN
            MTYPES = MIN( MAXTYP, NTYPES )
         ELSE
            MTYPES = MIN( MAXTYP+1, NTYPES )
         END IF
*
         DO 230 JTYPE = 1, MTYPES
.NOT.            IF( DOTYPE( JTYPE ) )
     $         GO TO 230
*
            DO 20 J = 1, 4
               IOLDSD( J ) = ISEED( J )
   20       CONTINUE
*
*           Compute "A"
*
.GT.            IF( MTYPESMAXTYP )
     $         GO TO 30
*
.EQ.            IF( JTYPE1 ) THEN
*
*              Zero matrix
*
               CALL DLASET( 'full', M, N, ZERO, ZERO, A, LDA )
*
.EQ.            ELSE IF( JTYPE2 ) THEN
*
*              Identity matrix
*
               CALL DLASET( 'full', M, N, ZERO, ONE, A, LDA )
*
            ELSE
*
*              (Scaled) random matrix
*
.EQ.               IF( JTYPE3 )
     $            ANORM = ONE
.EQ.               IF( JTYPE4 )
     $            ANORM = UNFL / ULP
.EQ.               IF( JTYPE5 )
     $            ANORM = OVFL*ULP
               CALL DLATMS( M, N, 'u', ISEED, 'n', S, 4, DBLE( MNMIN ),
     $                      ANORM, M-1, N-1, 'n', A, LDA, WORK, IINFO )
.NE.               IF( IINFO0 ) THEN
                  WRITE( NOUT, FMT = 9996 )'generator', IINFO, M, N,
     $               JTYPE, IOLDSD
                  INFO = ABS( IINFO )
                  RETURN
               END IF
            END IF
*
   30       CONTINUE
            CALL DLACPY( 'f', M, N, A, LDA, ASAV, LDA )
*
*           Do for minimal and adequate (for blocking) workspace
*
            DO 220 IWS = 1, 4
*
               DO 40 J = 1, 32
                  RESULT( J ) = -ONE
   40          CONTINUE
*
*              Test DGESVD: Factorize A
*
               IWTMP = MAX( 3*MIN( M, N )+MAX( M, N ), 5*MIN( M, N ) )
               LSWORK = IWTMP + ( IWS-1 )*( LWORK-IWTMP ) / 3
               LSWORK = MIN( LSWORK, LWORK )
               LSWORK = MAX( LSWORK, 1 )
.EQ.               IF( IWS4 )
     $            LSWORK = LWORK
*
.GT.               IF( IWS1 )
     $            CALL DLACPY( 'f', M, N, ASAV, LDA, A, LDA )
               SRNAMT = 'dgesvd'
               CALL DGESVD( 'a', 'a', M, N, A, LDA, SSAV, USAV, LDU,
     $                      VTSAV, LDVT, WORK, LSWORK, IINFO )
.NE.               IF( IINFO0 ) THEN
                  WRITE( NOUT, FMT = 9995 )'gesvd', IINFO, M, N, JTYPE,
     $               LSWORK, IOLDSD
                  INFO = ABS( IINFO )
                  RETURN
               END IF
*
*              Do tests 1--4
*
               CALL DBDT01( M, N, 0, ASAV, LDA, USAV, LDU, SSAV, E,
     $                      VTSAV, LDVT, WORK, RESULT( 1 ) )
.NE..AND..NE.               IF( M0  N0 ) THEN
                  CALL DORT01( 'columns', M, M, USAV, LDU, WORK, LWORK,
     $                         RESULT( 2 ) )
                  CALL DORT01( 'rows', N, N, VTSAV, LDVT, WORK, LWORK,
     $                         RESULT( 3 ) )
               END IF
               RESULT( 4 ) = ZERO
               DO 50 I = 1, MNMIN - 1
.LT.                  IF( SSAV( I )SSAV( I+1 ) )
     $               RESULT( 4 ) = ULPINV
.LT.                  IF( SSAV( I )ZERO )
     $               RESULT( 4 ) = ULPINV
   50          CONTINUE
.GE.               IF( MNMIN1 ) THEN
.LT.                  IF( SSAV( MNMIN )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 80 IJU = 0, 3
                  DO 70 IJVT = 0, 3
.EQ..AND..EQ..OR.                     IF( ( IJU3  IJVT3 ) 
.EQ..AND..EQ.     $                   ( IJU1  IJVT1 ) )GO TO 70
                     JOBU = CJOB( IJU+1 )
                     JOBVT = CJOB( IJVT+1 )
                     CALL DLACPY( 'f', M, N, ASAV, LDA, A, LDA )
                     SRNAMT = 'dgesvd'
                     CALL DGESVD( JOBU, JOBVT, M, N, A, LDA, S, U, LDU,
     $                            VT, LDVT, WORK, LSWORK, IINFO )
*
*                    Compare U
*
                     DIF = ZERO
.GT..AND..GT.                     IF( M0  N0 ) THEN
.EQ.                        IF( IJU1 ) THEN
                           CALL DORT03( 'c', M, MNMIN, M, MNMIN, USAV,
     $                                  LDU, A, LDA, WORK, LWORK, DIF,
     $                                  IINFO )
.EQ.                        ELSE IF( IJU2 ) THEN
                           CALL DORT03( 'c', M, MNMIN, M, MNMIN, USAV,
     $                                  LDU, U, LDU, WORK, LWORK, DIF,
     $                                  IINFO )
.EQ.                        ELSE IF( IJU3 ) THEN
                           CALL DORT03( 'c', M, M, M, MNMIN, USAV, LDU,
     $                                  U, LDU, WORK, LWORK, DIF,
     $                                  IINFO )
                        END IF
                     END IF
                     RESULT( 5 ) = MAX( RESULT( 5 ), DIF )
*
*                    Compare VT
*
                     DIF = ZERO
.GT..AND..GT.                     IF( M0  N0 ) THEN
.EQ.                        IF( IJVT1 ) THEN
                           CALL DORT03( 'r', N, MNMIN, N, MNMIN, VTSAV,
     $                                  LDVT, A, LDA, WORK, LWORK, DIF,
     $                                  IINFO )
.EQ.                        ELSE IF( IJVT2 ) THEN
                           CALL DORT03( 'r', N, MNMIN, N, MNMIN, VTSAV,
     $                                  LDVT, VT, LDVT, WORK, LWORK,
     $                                  DIF, IINFO )
.EQ.                        ELSE IF( IJVT3 ) THEN
                           CALL DORT03( 'r', N, N, N, MNMIN, VTSAV,
     $                                  LDVT, VT, LDVT, WORK, LWORK,
     $                                  DIF, IINFO )
                        END IF
                     END IF
                     RESULT( 6 ) = MAX( RESULT( 6 ), DIF )
*
*                    Compare S
*
                     DIF = ZERO
                     DIV = MAX( MNMIN*ULP*S( 1 ), UNFL )
                     DO 60 I = 1, MNMIN - 1
.LT.                        IF( SSAV( I )SSAV( I+1 ) )
     $                     DIF = ULPINV
.LT.                        IF( SSAV( I )ZERO )
     $                     DIF = ULPINV
                        DIF = MAX( DIF, ABS( SSAV( I )-S( I ) ) / DIV )
   60                CONTINUE
                     RESULT( 7 ) = MAX( RESULT( 7 ), DIF )
   70             CONTINUE
   80          CONTINUE
*
*              Test DGESDD: Factorize A
*
               IWTMP = 5*MNMIN*MNMIN + 9*MNMIN + MAX( M, N )
               LSWORK = IWTMP + ( IWS-1 )*( LWORK-IWTMP ) / 3
               LSWORK = MIN( LSWORK, LWORK )
               LSWORK = MAX( LSWORK, 1 )
.EQ.               IF( IWS4 )
     $            LSWORK = LWORK
*
               CALL DLACPY( 'f', M, N, ASAV, LDA, A, LDA )
               SRNAMT = 'dgesdd'
               CALL DGESDD( 'a', M, N, A, LDA, SSAV, USAV, LDU, VTSAV,
     $                      LDVT, WORK, LSWORK, IWORK, IINFO )
.NE.               IF( IINFO0 ) THEN
                  WRITE( NOUT, FMT = 9995 )'gesdd', IINFO, M, N, JTYPE,
     $               LSWORK, IOLDSD
                  INFO = ABS( IINFO )
                  RETURN
               END IF
*
*              Do tests 8--11
*
               CALL DBDT01( M, N, 0, ASAV, LDA, USAV, LDU, SSAV, E,
     $                      VTSAV, LDVT, WORK, RESULT( 8 ) )
.NE..AND..NE.               IF( M0  N0 ) THEN
                  CALL DORT01( 'columns', M, M, USAV, LDU, WORK, LWORK,
     $                         RESULT( 9 ) )
                  CALL DORT01( 'rows', N, N, VTSAV, LDVT, WORK, LWORK,
     $                         RESULT( 10 ) )
               END IF
               RESULT( 11 ) = ZERO
               DO 90 I = 1, MNMIN - 1
.LT.                  IF( SSAV( I )SSAV( I+1 ) )
     $               RESULT( 11 ) = ULPINV
.LT.                  IF( SSAV( I )ZERO )
     $               RESULT( 11 ) = ULPINV
   90          CONTINUE
.GE.               IF( MNMIN1 ) THEN
.LT.                  IF( SSAV( MNMIN )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 110 IJQ = 0, 2
                  JOBQ = CJOB( IJQ+1 )
                  CALL DLACPY( 'f', M, N, ASAV, LDA, A, LDA )
                  SRNAMT = 'dgesdd'
                  CALL DGESDD( JOBQ, M, N, A, LDA, S, U, LDU, VT, LDVT,
     $                         WORK, LSWORK, IWORK, IINFO )
*
*                 Compare U
*
                  DIF = ZERO
.GT..AND..GT.                  IF( M0  N0 ) THEN
.EQ.                     IF( IJQ1 ) THEN
.GE.                        IF( MN ) THEN
                           CALL DORT03( 'c', M, MNMIN, M, MNMIN, USAV,
     $                                  LDU, A, LDA, WORK, LWORK, DIF,
     $                                  INFO )
                        ELSE
                           CALL DORT03( 'c', M, MNMIN, M, MNMIN, USAV,
     $                                  LDU, U, LDU, WORK, LWORK, DIF,
     $                                  INFO )
                        END IF
.EQ.                     ELSE IF( IJQ2 ) THEN
                        CALL DORT03( 'c', M, MNMIN, M, MNMIN, USAV, LDU,
     $                               U, LDU, WORK, LWORK, DIF, INFO )
                     END IF
                  END IF
                  RESULT( 12 ) = MAX( RESULT( 12 ), DIF )
*
*                 Compare VT
*
                  DIF = ZERO
.GT..AND..GT.                  IF( M0  N0 ) THEN
.EQ.                     IF( IJQ1 ) THEN
.GE.                        IF( MN ) THEN
                           CALL DORT03( 'r', N, MNMIN, N, MNMIN, VTSAV,
     $                                  LDVT, VT, LDVT, WORK, LWORK,
     $                                  DIF, INFO )
                        ELSE
                           CALL DORT03( 'r', N, MNMIN, N, MNMIN, VTSAV,
     $                                  LDVT, A, LDA, WORK, LWORK, DIF,
     $                                  INFO )
                        END IF
.EQ.                     ELSE IF( IJQ2 ) THEN
                        CALL DORT03( 'r', n, mnmin, n, mnmin, vtsav,
     $                               ldvt, vt, ldvt, work, lwork, dif,
     $                               info )
                     END IF
                  END IF
                  result( 13 ) = max( result( 13 ), dif )
*
*                 Compare S
*
                  dif = zero
                  div = max( mnmin*ulp*s( 1 ), unfl )
                  DO 100 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 )
  100             CONTINUE
                  result( 14 ) = max( result( 14 ), dif )
  110          CONTINUE
*
*              Test DGESVDQ
*              Note: DGESVDQ only works for M >= N
*
               result( 36 ) = zero
               result( 37 ) = zero
               result( 38 ) = zero
               result( 39 ) = zero
*
               IF( m.GE.n ) THEN
                  iwtmp = 5*mnmin*mnmin + 9*mnmin + max( m, n )
                  lswork = iwtmp + ( iws-1 )*( lwork-iwtmp ) / 3
                  lswork = min( lswork, lwork )
                  lswork = max( lswork, 1 )
                  IF( iws.EQ.4 )
     $               lswork = lwork
*
                  CALL dlacpy( 'F', m, n, asav, lda, a, lda )
                  srnamt = 'DGESVDQ'
*
                  lrwork = 2
                  liwork = max( n, 1 )
                  CALL dgesvdq( 'H', 'N', 'N', 'A', 'A', 
     $                          m, n, a, lda, ssav, usav, ldu,
     $                          vtsav, ldvt, numrank, iwork, liwork,
     $                          work, lwork, rwork, lrwork, iinfo )
*
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nout, fmt = 9995 )'DGESVDQ', iinfo, m, n,
     $               jtype, lswork, ioldsd
                     info = abs( iinfo )
                     RETURN
                  END IF
*
*                 Do tests 36--39
*
                  CALL dbdt01( m, n, 0, asav, lda, usav, ldu, ssav, e,
     $                         vtsav, ldvt, work, result( 36 ) )
                  IF( m.NE.0 .AND. n.NE.0 ) THEN
                     CALL dort01( 'Columns', m, m, usav, ldu, work,
     $                            lwork, result( 37 ) )
                     CALL dort01( 'Rows', n, n, vtsav, ldvt, work,
     $                            lwork, result( 38 ) )
                  END IF
                  result( 39 ) = zero
                  DO 199 i = 1, mnmin - 1
                     IF( ssav( i ).LT.ssav( i+1 ) )
     $                  result( 39 ) = ulpinv
                     IF( ssav( i ).LT.zero )
     $                  result( 39 ) = ulpinv
  199             CONTINUE
                  IF( mnmin.GE.1 ) THEN
                     IF( ssav( mnmin ).LT.zero )
     $                  result( 39 ) = ulpinv
                  END IF
               END IF
*
*              Test DGESVJ
*              Note: DGESVJ only works for M >= N
*
               result( 15 ) = zero
               result( 16 ) = zero
               result( 17 ) = zero
               result( 18 ) = zero
*
               IF( m.GE.n ) THEN
                  iwtmp = 5*mnmin*mnmin + 9*mnmin + max( m, n )
                  lswork = iwtmp + ( iws-1 )*( lwork-iwtmp ) / 3
                  lswork = min( lswork, lwork )
                  lswork = max( lswork, 1 )
                  IF( iws.EQ.4 )
     $               lswork = lwork
*
                  CALL dlacpy( 'F', m, n, asav, lda, usav, lda )
                  srnamt = 'DGESVJ'
                  CALL dgesvj( 'G', 'U', 'V', m, n, usav, lda, ssav,
     &                        0, a, ldvt, work, lwork, info )
*
*                 DGESVJ returns V not VT
*
                  DO j=1,n
                     DO i=1,n
                        vtsav(j,i) = a(i,j)
                     END DO
                  END DO
*
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nout, fmt = 9995 )'GESVJ', iinfo, m, n,
     $               jtype, lswork, ioldsd
                     info = abs( iinfo )
                     RETURN
                  END IF
*
*                 Do tests 15--18
*
                  CALL dbdt01( m, n, 0, asav, lda, usav, ldu, ssav, e,
     $                         vtsav, ldvt, work, result( 15 ) )
                  IF( m.NE.0 .AND. n.NE.0 ) THEN
                     CALL dort01( 'Columns', m, m, usav, ldu, work,
     $                            lwork, result( 16 ) )
                     CALL dort01( 'Rows', n, n, vtsav, ldvt, work,
     $                            lwork, result( 17 ) )
                  END IF
                  result( 18 ) = zero
                  DO 120 i = 1, mnmin - 1
                     IF( ssav( i ).LT.ssav( i+1 ) )
     $                  result( 18 ) = ulpinv
                     IF( ssav( i ).LT.zero )
     $                  result( 18 ) = ulpinv
  120             CONTINUE
                  IF( mnmin.GE.1 ) THEN
                     IF( ssav( mnmin ).LT.zero )
     $                  result( 18 ) = ulpinv
                  END IF
               END IF
*
*              Test DGEJSV
*              Note: DGEJSV only works for M >= N
*
               result( 19 ) = zero
               result( 20 ) = zero
               result( 21 ) = zero
               result( 22 ) = zero
               IF( m.GE.n ) THEN
                  iwtmp = 5*mnmin*mnmin + 9*mnmin + max( m, n )
                  lswork = iwtmp + ( iws-1 )*( lwork-iwtmp ) / 3
                  lswork = min( lswork, lwork )
                  lswork = max( lswork, 1 )
                  IF( iws.EQ.4 )
     $               lswork = lwork
*
                  CALL dlacpy( 'F', m, n, asav, lda, vtsav, lda )
                  srnamt = 'DGEJSV'
                  CALL dgejsv( 'G', 'U', 'V', 'R', 'N', 'N',
     &                   m, n, vtsav, lda, ssav, usav, ldu, a, ldvt,
     &                   work, lwork, iwork, info )
*
*                 DGEJSV returns V not VT
*
                  DO 140 j=1,n
                     DO 130 i=1,n
                        vtsav(j,i) = a(i,j)
  130                END DO
  140             END DO
*
                  IF( iinfo.NE.0 ) THEN
                     WRITE( nout, fmt = 9995 )'GEJSV', iinfo, m, n,
     $               jtype, lswork, ioldsd
                     info = abs( iinfo )
                     RETURN
                  END IF
*
*                 Do tests 19--22
*
                  CALL dbdt01( m, n, 0, asav, lda, usav, ldu, ssav, e,
     $                         vtsav, ldvt, work, result( 19 ) )
                  IF( m.NE.0 .AND. n.NE.0 ) THEN
                     CALL dort01( 'Columns', m, m, usav, ldu, work,
     $                            lwork, result( 20 ) )
                     CALL dort01( 'Rows', n, n, vtsav, ldvt, work,
     $                            lwork, result( 21 ) )
                  END IF
                  result( 22 ) = zero
                  DO 150 i = 1, mnmin - 1
                     IF( ssav( i ).LT.ssav( i+1 ) )
     $                  result( 22 ) = ulpinv
                     IF( ssav( i ).LT.zero )
     $                  result( 22 ) = ulpinv
  150             CONTINUE
                  IF( mnmin.GE.1 ) THEN
                     IF( ssav( mnmin ).LT.zero )
     $                  result( 22 ) = ulpinv
                  END IF
               END IF
*
*              Test DGESVDX
*
               CALL dlacpy( 'F', m, n, asav, lda, a, lda )
               CALL dgesvdx( 'V', 'V', 'A', m, n, a, lda,
     $                       vl, vu, il, iu, ns, ssav, usav, ldu,
     $                       vtsav, ldvt, work, lwork, iwork,
     $                       iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nout, fmt = 9995 )'GESVDX', iinfo, m, n,
     $               jtype, lswork, ioldsd
                  info = abs( iinfo )
                  RETURN
               END IF
*
*              Do tests 23--29
*
               result( 23 ) = zero
               result( 24 ) = zero
               result( 25 ) = zero
               CALL dbdt01( m, n, 0, asav, lda, usav, ldu, ssav, e,
     $                      vtsav, ldvt, work, result( 23 ) )
               IF( m.NE.0 .AND. n.NE.0 ) THEN
                  CALL dort01( 'Columns', m, m, usav, ldu, work, lwork,
     $                         result( 24 ) )
                  CALL dort01( 'Rows', n, n, vtsav, ldvt, work, lwork,
     $                         result( 25 ) )
               END IF
               result( 26 ) = zero
               DO 160 i = 1, mnmin - 1
                  IF( ssav( i ).LT.ssav( i+1 ) )
     $               result( 26 ) = ulpinv
                  IF( ssav( i ).LT.zero )
     $               result( 26 ) = ulpinv
  160          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 180 iju = 0, 1
                  DO 170 ijvt = 0, 1
                     IF( ( iju.EQ.0 .AND. ijvt.EQ.0 ) .OR.
     $                   ( iju.EQ.1 .AND. ijvt.EQ.1 ) )GO TO 170
                     jobu = cjobv( iju+1 )
                     jobvt = cjobv( ijvt+1 )
                     range = cjobr( 1 )
                     CALL dlacpy( 'F', m, n, asav, lda, a, lda )
                     CALL dgesvdx( jobu, jobvt, range, m, n, a, lda,
     $                             vl, vu, il, iu, ns, s, u, ldu,
     $                             vt, ldvt, work, lwork, iwork,
     $                             iinfo )
*
*                    Compare U
*
                     dif = zero
                     IF( m.GT.0 .AND. n.GT.0 ) THEN
                        IF( iju.EQ.1 ) THEN
                           CALL dort03( 'C', m, mnmin, m, mnmin, usav,
     $                                  ldu, u, ldu, work, lwork, 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 dort03( 'R', n, mnmin, n, mnmin, vtsav,
     $                                  ldvt, vt, ldvt, work, lwork,
     $                                  dif, iinfo )
                        END IF
                     END IF
                     result( 28 ) = max( result( 28 ), dif )
*
*                    Compare S
*
                     dif = zero
                     div = max( mnmin*ulp*s( 1 ), unfl )
                     DO 190 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 )
  190                CONTINUE
                     result( 29 ) = max( result( 29 ), dif )
  170             CONTINUE
  180          CONTINUE
*
*              Do tests 30--32: DGESVDX( 'V', 'V', 'I' )
*
               DO 200 i = 1, 4
                  iseed2( i ) = iseed( i )
  200          CONTINUE
               IF( mnmin.LE.1 ) THEN
                  il = 1
                  iu = max( 1, mnmin )
               ELSE
                  il = 1 + int( ( mnmin-1 )*dlarnd( 1, iseed2 ) )
                  iu = 1 + int( ( mnmin-1 )*dlarnd( 1, iseed2 ) )
                  IF( iu.LT.il ) THEN
                     itemp = iu
                     iu = il
                     il = itemp
                  END IF
               END IF
               CALL dlacpy( 'F', m, n, asav, lda, a, lda )
               CALL dgesvdx( 'V', 'V', 'I', m, n, a, lda,
     $                       vl, vu, il, iu, nsi, s, u, ldu,
     $                       vt, ldvt, work, lwork, iwork,
     $                       iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nout, 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 dbdt05( m, n, asav, lda, s, nsi, u, ldu,
     $                      vt, ldvt, work, result( 30 ) )
               CALL dort01( 'Columns', m, nsi, u, ldu, work, lwork,
     $                      result( 31 ) )
               CALL dort01( 'Rows', nsi, n, vt, ldvt, work, lwork,
     $                      result( 32 ) )
*
*              Do tests 33--35: DGESVDX( 'V', 'V', 'V' )
*
               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 dlacpy( 'F', m, n, asav, lda, a, lda )
               CALL dgesvdx( 'V', 'V', 'V', m, n, a, lda,
     $                       vl, vu, il, iu, nsv, s, u, ldu,
     $                       vt, ldvt, work, lwork, iwork,
     $                       iinfo )
               IF( iinfo.NE.0 ) THEN
                  WRITE( nout, 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 dbdt05( m, n, asav, lda, s, nsv, u, ldu,
     $                      vt, ldvt, work, result( 33 ) )
               CALL dort01( 'columns', M, NSV, U, LDU, WORK, LWORK,
     $                      RESULT( 34 ) )
               CALL DORT01( 'rows', NSV, N, VT, LDVT, WORK, LWORK,
     $                      RESULT( 35 ) )
*
*              End of Loop -- Check for RESULT(j) > THRESH
*
               DO 210 J = 1, 39
.GE.                  IF( RESULT( J )THRESH ) THEN
.EQ.                     IF( NFAIL0 ) THEN
                        WRITE( NOUT, FMT = 9999 )
                        WRITE( NOUT, FMT = 9998 )
                     END IF
                     WRITE( NOUT, FMT = 9997 )M, N, JTYPE, IWS, IOLDSD,
     $                  J, RESULT( J )
                     NFAIL = NFAIL + 1
                  END IF
  210          CONTINUE
               NTEST = NTEST + 39
  220       CONTINUE
  230    CONTINUE
  240 CONTINUE
*
*     Summary
*
      CALL ALASVM( PATH, NOUT, NFAIL, NTEST, 0 )
*
 9999 FORMAT( ' svd -- real singular Value decomposition driver ',
     $      / ' matrix types(see ddrvbd 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 orthogonal,',
     $      / 19x, ' S is an array, and Upartial, VTpartial, and',
     $      / 19x, ' Spartial are partially computed U, VT and S),', / )
 9998 FORMAT( ' 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| )',
     $      / ' 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| )',
     $      / '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',
     $      / '19 = | u - upartial | / ( m ulp )',
     $      / '20 = | vt - vtpartial | / ( n ulp )',
     $      / '21 = | s - spartial | / ( min(m,n) ulp |s| )',
     $      / '22 = 0 if s contains min(m,n) nonnegative values in',
     $      ' decreasing order, else 1/ulp',
     $      / '23 = | a - u diag(s) vt | / ( |a| max(m,n) ulp ),',
     $      ' dgesvdx(v,v,a) ',
     $      / '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| )',
     $      / '30 = | u**t a vt**t - diag(s) | / ( |a| max(m,n) ulp ),',
     $      ' dgesvdx(v,v,i) ',
     $      / '31 = | i - u**t u | / ( m ulp ) ',
     $      / '32 = | i - vt vt**t | / ( n ulp ) ',
     $      / '33 = | u**t a vt**t - diag(s) | / ( |a| max(m,n) ulp ),',
     $      ' dgesvdx(v,v,v) ',
     $      / '34 = | i - u**t u | / ( m ulp ) ',
     $      / '35 = | i - vt vt**t | / ( n ulp ) ',
     $      ' dgesvdq(h,n,n,a,a',
     $      / '36 = | a - u diag(s) vt | / ( |a| max(m,n) ulp ) ',
     $      / '37 = | i - u**t u | / ( m ulp ) ',
     $      / '38 = | i - vt vt**t | / ( n ulp ) ',
     $      / '39 = 0 if s contains min(m,n) nonnegative values in',
     $      ' decreasing order, else 1/ulp',
     $      / / )
 9997 FORMAT( ' m=', I5, ', n=', I5, ', type ', I1, ', iws=', I1,
     $      ', seed=', 4( I4, ',' ), ' test(', I2, ')=', G11.4 )
 9996 FORMAT( ' ddrvbd: ', A, ' returned info=', I6, '.', / 9X, 'm=',
     $      I6, ', n=', I6, ', jtype=', I6, ', iseed=(', 3( I5, ',' ),
     $      I5, ')' )
 9995 FORMAT( ' ddrvbd: ', A, ' returned info=', I6, '.', / 9X, 'm=',
     $      I6, ', n=', I6, ', jtype=', I6, ', lswork=', I6, / 9X,
     $      'iseed=(', 3( I5, ',' ), I5, ')' )
*
      RETURN
*
*     End of DDRVBD
*
      END