.TH "TESTING/EIG/zdrvbd.f" 3 "Version 3.12.0" "LAPACK" \" -*- nroff -*-
.ad l
.nh
.SH NAME
TESTING/EIG/zdrvbd.f
.SH SYNOPSIS
.br
.PP
.SS "Functions/Subroutines"

.in +1c
.ti -1c
.RI "subroutine \fBzdrvbd\fP (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)"
.br
.RI "\fBZDRVBD\fP "
.in -1c
.SH "Function/Subroutine Documentation"
.PP 
.SS "subroutine zdrvbd (integer nsizes, integer, dimension( * ) mm, integer, dimension( * ) nn, integer ntypes, logical, dimension( * ) dotype, integer, dimension( 4 ) iseed, double precision thresh, complex*16, dimension( lda, * ) a, integer lda, complex*16, dimension( ldu, * ) u, integer ldu, complex*16, dimension( ldvt, * ) vt, integer ldvt, complex*16, dimension( lda, * ) asav, complex*16, dimension( ldu, * ) usav, complex*16, dimension( ldvt, * ) vtsav, double precision, dimension( * ) s, double precision, dimension( * ) ssav, double precision, dimension( * ) e, complex*16, dimension( * ) work, integer lwork, double precision, dimension( * ) rwork, integer, dimension( * ) iwork, integer nounit, integer info)"

.PP
\fBZDRVBD\fP 
.PP
\fBPurpose:\fP
.RS 4

.PP
.nf
!>
!> ZDRVBD checks the singular value decomposition (SVD) driver ZGESVD,
!> ZGESDD, ZGESVJ, ZGEJSV, ZGESVDX, and ZGESVDQ\&.
!>
!> ZGESVD and ZGESDD 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 ZDRVBD is called, a number of matrix  (M's and N's)
!> and a number of matrix  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  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 ZGESVD:
!>
!> (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 ZGESDD:
!>
!> (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 ZGESVDQ:
!>
!> (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 ZGESVJ:
!>
!> (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 ZGEJSV:
!>
!> (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 ZGESVDX( 'V', 'V', 'A' )/ZGESVDX( '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 ZGESVDX( '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 ZGESVDX( '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  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  are specified by a logical array
!> DOTYPE( 1:NTYPES ); if DOTYPE(j) is \&.TRUE\&., then matrix type 
!> 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\&.
!> 
.fi
.PP
 
.RE
.PP
\fBParameters\fP
.RS 4
\fINSIZES\fP 
.PP
.nf
!>          NSIZES is INTEGER
!>          The number of sizes of matrices to use\&.  If it is zero,
!>          ZDRVBD does nothing\&.  It must be at least zero\&.
!> 
.fi
.PP
.br
\fIMM\fP 
.PP
.nf
!>          MM is INTEGER array, dimension (NSIZES)
!>          An array containing the matrix  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\&.
!> 
.fi
.PP
.br
\fINN\fP 
.PP
.nf
!>          NN is INTEGER array, dimension (NSIZES)
!>          An array containing the matrix  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\&.
!> 
.fi
.PP
.br
\fINTYPES\fP 
.PP
.nf
!>          NTYPES is INTEGER
!>          The number of elements in DOTYPE\&.   If it is zero, ZDRVBD
!>          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\&. \&.
!> 
.fi
.PP
.br
\fIDOTYPE\fP 
.PP
.nf
!>          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\&.
!> 
.fi
.PP
.br
\fIISEED\fP 
.PP
.nf
!>          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 ZDRVBD to continue the same random number
!>          sequence\&.
!> 
.fi
.PP
.br
\fITHRESH\fP 
.PP
.nf
!>          THRESH is DOUBLE PRECISION
!>          A test will count as  if the , 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\&.
!> 
.fi
.PP
.br
\fIA\fP 
.PP
.nf
!>          A is COMPLEX*16 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\&.
!> 
.fi
.PP
.br
\fILDA\fP 
.PP
.nf
!>          LDA is INTEGER
!>          The leading dimension of A\&.  It must be at
!>          least 1 and at least max( MM )\&.
!> 
.fi
.PP
.br
\fIU\fP 
.PP
.nf
!>          U is COMPLEX*16 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\&.
!> 
.fi
.PP
.br
\fILDU\fP 
.PP
.nf
!>          LDU is INTEGER
!>          The leading dimension of U\&.  It must be at
!>          least 1 and at least max( MM )\&.
!> 
.fi
.PP
.br
\fIVT\fP 
.PP
.nf
!>          VT is COMPLEX*16 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\&.
!> 
.fi
.PP
.br
\fILDVT\fP 
.PP
.nf
!>          LDVT is INTEGER
!>          The leading dimension of VT\&.  It must be at
!>          least 1 and at least max( NN )\&.
!> 
.fi
.PP
.br
\fIASAV\fP 
.PP
.nf
!>          ASAV is COMPLEX*16 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\&.
!> 
.fi
.PP
.br
\fIUSAV\fP 
.PP
.nf
!>          USAV is COMPLEX*16 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\&.
!> 
.fi
.PP
.br
\fIVTSAV\fP 
.PP
.nf
!>          VTSAV is COMPLEX*16 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\&.
!> 
.fi
.PP
.br
\fIS\fP 
.PP
.nf
!>          S is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
!>          Contains the computed singular values\&.
!> 
.fi
.PP
.br
\fISSAV\fP 
.PP
.nf
!>          SSAV is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
!>          Contains another copy of the computed singular values\&.
!> 
.fi
.PP
.br
\fIE\fP 
.PP
.nf
!>          E is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
!>          Workspace for ZGESVD\&.
!> 
.fi
.PP
.br
\fIWORK\fP 
.PP
.nf
!>          WORK is COMPLEX*16 array, dimension (LWORK)
!> 
.fi
.PP
.br
\fILWORK\fP 
.PP
.nf
!>          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))
!> 
.fi
.PP
.br
\fIRWORK\fP 
.PP
.nf
!>          RWORK is DOUBLE PRECISION array,
!>                      dimension ( 5*max(max(MM,NN)) )
!> 
.fi
.PP
.br
\fIIWORK\fP 
.PP
.nf
!>          IWORK is INTEGER array, dimension at least 8*min(M,N)
!> 
.fi
.PP
.br
\fINOUNIT\fP 
.PP
.nf
!>          NOUNIT is INTEGER
!>          The FORTRAN unit number for printing out error messages
!>          (e\&.g\&., if a routine returns IINFO not equal to 0\&.)
!> 
.fi
.PP
.br
\fIINFO\fP 
.PP
.nf
!>          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  ZLATMS, or ZGESVD returns an error code, the
!>              absolute value of it is returned\&.
!> 
.fi
.PP
 
.RE
.PP
\fBAuthor\fP
.RS 4
Univ\&. of Tennessee 

.PP
Univ\&. of California Berkeley 

.PP
Univ\&. of Colorado Denver 

.PP
NAG Ltd\&. 
.RE
.PP

.PP
Definition at line \fB397\fP of file \fBzdrvbd\&.f\fP\&.
.SH "Author"
.PP 
Generated automatically by Doxygen for LAPACK from the source code\&.